diff --git a/.coderabbit.yaml b/.coderabbit.yaml
new file mode 100644
index 000000000..2408084cf
--- /dev/null
+++ b/.coderabbit.yaml
@@ -0,0 +1,6 @@
+# yaml-language-server: $schema=https://coderabbit.ai/integrations/schema.v2.json
+reviews:
+  auto_review:
+    # Dependabot bumps are checked by CI; skip CodeRabbit reviews on them.
+    ignore_usernames:
+      - "dependabot[bot]"
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 000000000..d39962e1c
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,32 @@
+version: 2
+updates:
+  # Maintain Rust / Cargo dependencies
+  - package-ecosystem: "cargo"
+    directories:
+      - "/"
+      - "/plugins"
+    schedule:
+      interval: "daily"
+      time: "06:00"
+      timezone: "America/New_York"
+    # Consolidate updates into a single PR rather than one PR per crate
+    groups:
+      cargo-dependencies:
+        patterns:
+          - "*"
+    commit-message:
+      prefix: "chore(deps)"
+
+  # Maintain GitHub Actions workflows
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "daily"
+      time: "06:00"
+      timezone: "America/New_York"
+    groups:
+      actions:
+        patterns:
+          - "*"
+    commit-message:
+      prefix: "ci(deps)"
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index e613617a1..1968076f2 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,9 +1,7 @@
-# CI for pull requests and main: format, clippy, tests, dependency layering, asset attribution and
-# the wasm32 check (the same gates as `cargo xtask ci`). Linux only: macOS is built and tested only
-# by release.yml (the org's macOS runners are kept for releases; craftrules release/playbook.md),
-# and Windows/FreeBSD packaging have their own workflows.
 name: CI
 
+# Quality gates for every push to main and every pull request (`cargo xtask ci`), through the
+# suite's shared gate workflow in craft-common-actions.
 on:
   push:
     branches: [main]
@@ -13,76 +11,21 @@ on:
 permissions:
   contents: read
 
-env:
-  CARGO_TERM_COLOR: always
-  CARGO_INCREMENTAL: 0
-  RUST_BACKTRACE: 1
-  # Debug and test builds keep line tables (file:line in panic backtraces) but drop the rest of the
-  # debug info: faster codegen and links, and a smaller target dir.
-  CARGO_PROFILE_DEV_DEBUG: line-tables-only
-
-# A newer push to a PR branch cancels its older run. Runs on main are never cancelled, so every
-# main state that gets a run is checked to the end.
+# A newer push to a PR branch cancels its older run; every push to main runs to the end.
 concurrency:
-  group: ci-${{ github.ref }}
+  group: ci-${{ github.event_name == 'pull_request' && github.ref || github.run_id }}
   cancel-in-progress: ${{ github.event_name == 'pull_request' }}
 
 jobs:
-  test:
-    timeout-minutes: 35
-    name: test (ubuntu-latest)
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Install Linux system dependencies (egui/winit/rfd)
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y --no-install-recommends \
-            libxkbcommon-dev libwayland-dev libx11-dev libxrandr-dev libxi-dev \
-            libgl1-mesa-dev libgtk-3-dev
-
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          components: clippy, rustfmt
-
-      # Only main saves caches; PRs restore main's, so PR caches don't evict main's.
-      - uses: Swatinem/rust-cache@v2
-        with:
-          save-if: ${{ github.ref == 'refs/heads/main' }}
-          cache-on-failure: true
-
-      - name: Format
-        run: cargo fmt --all -- --check
-
-      - name: Clippy
-        run: cargo clippy --workspace --all-targets --locked -- -D warnings
-
-      # Without craft-fonts (the optional CRAFT_FONTS_DIR input, which .cargo/config.toml points at
-      # a sibling checkout that CI doesn't have): everything must build and pass without it.
-      - name: Test
-        run: cargo test --workspace --locked
-
-      - name: Dependency layering
-        run: cargo run --locked -q -p xtask -- layers
-
-      - name: Asset attribution
-        run: cargo run --locked -q -p xtask -- assets
-
-  wasm:
-    timeout-minutes: 30
-    name: wasm32 check
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          targets: wasm32-unknown-unknown
-      - uses: Swatinem/rust-cache@v2
-        with:
-          key: wasm32
-          save-if: ${{ github.ref == 'refs/heads/main' }}
-          cache-on-failure: true
-      # The engine, the UI crate and apps/figcraft-web must keep compiling for the browser.
-      - name: Check wasm-safe crates
-        run: cargo run --locked -q -p xtask -- wasm
+  gate:
+    # Tracks @main so suite-wide CI fixes reach every app without a PR in each repository.
+    uses: storytold/craft-common-actions/.github/workflows/gate.yml@main
+    with:
+      # The craft-fonts commit release.yml builds with. Needs fonts/latin-manifest.txt (Inter):
+      # crates/text/build.rs fails a build that requires craft-fonts without it. Only craft-fonts'
+      # pr/latin-presentation-fonts has it; its main has Noto Sans Georgian but no Inter. Re-pin
+      # once one commit has both (storytold/craft-fonts#42).
+      craft-fonts-ref: 43913056ce82a3fdad0ef69f6b88d1dc922a8104
+      packages: >-
+        libxkbcommon-dev libwayland-dev libx11-dev libxrandr-dev libxi-dev libgl1-mesa-dev
+        libgtk-3-dev
diff --git a/.github/workflows/freebsd.yml b/.github/workflows/freebsd.yml
index dcd0192f0..3b03a99c3 100644
--- a/.github/workflows/freebsd.yml
+++ b/.github/workflows/freebsd.yml
@@ -1,16 +1,13 @@
 # Builds and tests the workspace on FreeBSD, inside a FreeBSD VM on a Linux runner
-# (GitHub has no FreeBSD runners).
-# It then runs packaging/freebsd/package.sh, the script the release job runs, and checks the
-# tarball, so a broken FreeBSD package fails here before it can fail a release. Nothing is
-# uploaded and no secrets are used.
+# (GitHub has no FreeBSD runners). It then runs packaging/freebsd/package.sh, the script
+# the release job runs, and checks the tarball, so a broken FreeBSD package fails here
+# before it can fail a release. Nothing is uploaded and no secrets are used.
 name: FreeBSD
 
-# The VM build is slow, so it runs nightly on main and on pushes to `release`, not on every push
-# or dependency change: a drifted dependency still shows up within a day, and always before a
-# release ships. PRs that change the FreeBSD packaging itself still run it.
+# The VM build is slow, so it runs nightly on main and on pushes to `release`, not on every pull
+# request: a drifted dependency still shows up within a day, and always before a release ships.
+# PRs that change the FreeBSD workflow or packaging itself still run it.
 on:
-  schedule:
-    - cron: "17 2 * * *"
   push:
     branches: [release]
   pull_request:
@@ -18,6 +15,8 @@ on:
       - .github/workflows/freebsd.yml
       - packaging/freebsd/**
       - packaging/env.sh
+  schedule:
+    - cron: "17 2 * * *"
   workflow_dispatch:
 
 concurrency:
@@ -29,36 +28,8 @@ permissions:
 
 jobs:
   freebsd:
-    name: FreeBSD 14 (build + test + package)
-    runs-on: ubuntu-latest
-    timeout-minutes: 300
-    steps:
-      - uses: actions/checkout@v4
-      - name: Build, test and package in a FreeBSD VM
-        uses: vmactions/freebsd-vm@c46abacb49f09938ca4e1702d15d836285d694cc # v1
-        with:
-          release: "14.3"
-          usesh: true
-          cpu: 4
-          mem: 12288
-          # Nothing to bring back; copying the target dir out of the VM fails on large builds.
-          copyback: false
-          # dejavu: the text tests need one real font, as the Ubuntu runner has.
-          prepare: |
-            pkg install -y bash git curl pkgconf cmake python3 libxkbcommon wayland libX11 libXcursor libXrandr libXi libxcb mesa-libs vulkan-loader gtk3 fontconfig freetype2 dejavu
-            curl -fsSL https://sh.rustup.rs | sh -s -- -y --profile minimal
-          run: |
-            set -e
-            . "$HOME/.cargo/env"
-            # The checkout is synced in under another owner; let tests that call git read it.
-            git config --global --add safe.directory "*"
-            rustc --version
-            CARGO_PROFILE_DEV_DEBUG=0 cargo build --workspace --all-targets --locked
-            CARGO_PROFILE_DEV_DEBUG=0 cargo test --workspace --locked
-            # The release package, as release.yml builds it. Free the debug build's disk first.
-            rm -rf target/debug
-            CARGO_BUILD_JOBS=4 bash packaging/freebsd/package.sh
-            tar -tzf dist/release/figcraft-*-freebsd-x86_64.tar.gz >"$HOME/freebsd-contents.txt"
-            for f in '/bin/figcraft$' '/share/applications/ai\.storyteller\.figcraft\.desktop$' '/share/doc/figcraft/LICENSE-MIT$'; do
-              grep -E "$f" "$HOME/freebsd-contents.txt"
-            done
+    # Intentionally tracked at @main (not SHA-pinned) so org-wide CI improvements, security fixes, and build optimizations propagate without PR churn across all craftapp repos.
+    uses: storytold/craft-common-actions/.github/workflows/freebsd.yml@main
+    with:
+      run-package-check: true
+      craft-fonts-ref: a71c20e30af613287c504f7e685ca8fad77752bc
diff --git a/.github/workflows/nix.yml b/.github/workflows/nix.yml
new file mode 100644
index 000000000..01cb9cd66
--- /dev/null
+++ b/.github/workflows/nix.yml
@@ -0,0 +1,23 @@
+# Evaluates the Nix flake (no build, about a minute): `nix build` / `nix develop` stop at evaluation
+# when Cargo.lock gains something nix/package.nix can't vendor, and nothing else would notice.
+name: Nix
+
+on:
+  push:
+    branches: [main]
+    paths: ["flake.nix", "flake.lock", "nix/**", "Cargo.lock", ".github/workflows/nix.yml"]
+  pull_request:
+    paths: ["flake.nix", "flake.lock", "nix/**", "Cargo.lock", ".github/workflows/nix.yml"]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: nix-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  nix:
+    # Intentionally tracked at @main (not SHA-pinned) so org-wide CI improvements, security fixes, and build optimizations propagate without PR churn across all craftapp repos.
+    uses: storytold/craft-common-actions/.github/workflows/nix.yml@main
diff --git a/.github/workflows/packaging-lint.yml b/.github/workflows/packaging-lint.yml
index 26fad8759..386989022 100644
--- a/.github/workflows/packaging-lint.yml
+++ b/.github/workflows/packaging-lint.yml
@@ -19,58 +19,7 @@ concurrency:
 
 jobs:
   lint:
-    timeout-minutes: 15
-    runs-on: ubuntu-latest
-    env:
-      ACTIONLINT_VERSION: 1.7.12
-    steps:
-      - uses: actions/checkout@v4
-      - name: Install tools
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y --no-install-recommends shellcheck desktop-file-utils appstream libxml2-utils python3-yaml
-          curl -fsSL "https://github.com/rhysd/actionlint/releases/download/v${ACTIONLINT_VERSION}/actionlint_${ACTIONLINT_VERSION}_linux_amd64.tar.gz" \
-            | tar -xz -C "$RUNNER_TEMP" actionlint
-      - name: actionlint
-        run: |
-          "$RUNNER_TEMP/actionlint" -color
-      - name: shellcheck
-        run: shellcheck packaging/*.sh packaging/*/*.sh packaging/linux/AppRun
-      - name: Server install script (Caddyfile handling)
-        run: bash packaging/server/install-test.sh
-      - name: AppImage AppRun desktop integration
-        run: bash packaging/linux/apprun-test.sh
-      - name: PowerShell
-        shell: pwsh
-        run: |
-          foreach ($f in Get-ChildItem packaging/windows/*.ps1) {
-            $errors = $null
-            [System.Management.Automation.Language.Parser]::ParseFile($f.FullName, [ref]$null, [ref]$errors) | Out-Null
-            if ($errors) { $errors | ForEach-Object { Write-Output "::error file=$($f.Name)::$_" }; exit 1 }
-            Write-Output "ok $($f.Name)"
-          }
-          ./packaging/windows/check-icons.ps1
-      - name: FreeBSD package layout (dry run, no build)
-        run: bash packaging/freebsd/package.sh --dry-run
-      - name: No template leftovers from other apps in package metadata
-        run: |
-          if grep -rniE 'photoshop|psd|photocraft|vectorcraft|illustrator|adobe|figma' packaging/ .github/ --exclude=packaging-lint.yml; then
-            echo "::error::package metadata mentions another product (see above)"
-            exit 1
-          fi
-      - name: XML, desktop entry, AppStream, Flatpak manifest
-        run: |
-          xmllint --noout packaging/windows/figcraft.wxs packaging/windows/figcraft.en-us.wxl packaging/macos/*.plist* packaging/linux/*.xml*
-          desktop-file-validate packaging/linux/ai.storyteller.figcraft.desktop
-          sed -e 's/@VERSION@/0.0.0/' -e 's/@DATE@/2026-01-01/' packaging/linux/ai.storyteller.figcraft.metainfo.xml.in >"$RUNNER_TEMP/ai.storyteller.figcraft.metainfo.xml"
-          appstreamcli validate --no-net --explain "$RUNNER_TEMP/ai.storyteller.figcraft.metainfo.xml"
-          python3 - <<'EOF'
-          import yaml
-          src = yaml.safe_load(open("packaging/linux/flatpak/ai.storyteller.figcraft.yml"))
-          bundle = yaml.safe_load(open("packaging/linux/flatpak/ai.storyteller.figcraft.bundle.yml"))
-          for m in (src, bundle):
-              assert m["id"] == "ai.storyteller.figcraft" and m["command"] == "figcraft", m["id"]
-          for key in ("runtime", "runtime-version", "sdk", "finish-args"):
-              assert src[key] == bundle[key], f"Flatpak manifests disagree on {key}: {src[key]} vs {bundle[key]}"
-          print("Flatpak manifests ok")
-          EOF
+    # Intentionally tracked at @main (not SHA-pinned) so org-wide CI improvements, security fixes, and build optimizations propagate without PR churn across all craftapp repos.
+    uses: storytold/craft-common-actions/.github/workflows/packaging-lint.yml@main
+    with:
+      extra-checks-script: packaging/check-app-specific.sh
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index ddf622d7b..dd2aefddb 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -1,11 +1,3 @@
-# Release pipeline: every push to `release` builds signed installers for every platform and
-# creates or updates the draft GitHub Release "FigCraft v<version>". See docs/releasing.md.
-#
-# Only the jobs that read secrets (macOS and Windows signing, and the draft release) run in the
-# `release` environment (restricted to the `release` branch), which holds the signing secrets; the
-# rest build on any branch, so `gh workflow run release.yml --ref <branch>` is a real dry run.
-# Every secret is optional: missing ones produce unsigned artifacts and a warning, never a failed
-# build. Playbook: storytold/craftrules release/playbook.md.
 name: Release
 
 on:
@@ -19,543 +11,40 @@ on:
         default: ""
 
 permissions:
-  contents: read
+  contents: write
 
 concurrency:
   group: release-${{ github.ref }}
-  # Never cancel a run mid-notarization or mid-upload; a newer push waits its turn.
   cancel-in-progress: false
 
-env:
-  CARGO_TERM_COLOR: always
-  CARGO_INCREMENTAL: 0
-  RUST_BACKTRACE: 1
-  FIGCRAFT_BUILD_SHA: ${{ github.sha }}
-  INPUT_VERSION: ${{ inputs.version }}
-  # craft-fonts (https://github.com/storytold/craft-fonts): shared font assets every release
-  # embeds (Inter and the Latin presentation fonts from fonts/latin-manifest.txt; the web build
-  # embeds Inter only, see crates/text/build.rs). An optional build input for everyone else.
-  # crates/text/build.rs needs fonts/latin-manifest.txt, so the pin must include it. Bump
-  # deliberately; every build job checks out this commit.
-  CRAFT_FONTS_REF: 43913056ce82a3fdad0ef69f6b88d1dc922a8104
-
 jobs:
-  version:
-    timeout-minutes: 10
-    name: version
-    runs-on: ubuntu-latest
-    # No `environment: release`: this job reads no secrets, so a branch dry run can run it.
-    outputs:
-      version: ${{ steps.v.outputs.version }}
-      date: ${{ steps.v.outputs.date }}
-      prerelease: ${{ steps.v.outputs.prerelease }}
-    steps:
-      - uses: actions/checkout@v4
-      - id: v
-        name: Resolve version
-        run: |
-          . packaging/env.sh
-          v="${INPUT_VERSION#v}"
-          v="${v:-$VERSION}"
-          if ! printf '%s' "$v" | grep -Eq '^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)(-[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?$'; then
-            echo "::error::'$v' is not a version like 1.2.3 or 1.2.3-rc.1"
-            exit 1
-          fi
-          case "$v" in *-*) pre=true ;; *) pre=false ;; esac
-          {
-            echo "version=$v"
-            echo "date=$(date -u +%Y-%m-%d)"
-            echo "prerelease=$pre"
-          } >>"$GITHUB_OUTPUT"
-          echo "### FigCraft v$v (\`${GITHUB_SHA::9}\`)" >>"$GITHUB_STEP_SUMMARY"
-
-  macos:
-    timeout-minutes: 90
-    name: macOS universal
-    needs: version
-    runs-on: macos-15-xlarge  # M2 Pro larger runner; use only in release.yml (actions_macos_xl budget caps spend)
-    environment: release
-    env:
-      FIGCRAFT_VERSION: ${{ needs.version.outputs.version }}
-      FIGCRAFT_BUILD_DATE: ${{ needs.version.outputs.date }}
-    steps:
-      - uses: actions/checkout@v4
-      - name: Check out craft-fonts (embedded fonts)
-        uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
-        with:
-          repository: storytold/craft-fonts
-          ref: ${{ env.CRAFT_FONTS_REF }}
-          path: craft-fonts
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          targets: aarch64-apple-darwin, x86_64-apple-darwin
-      - uses: Swatinem/rust-cache@v2
-        with:
-          key: release-macos-universal
-      - name: Apply version override
-        if: inputs.version != ''
-        run: cargo run --locked -q -p xtask -- version set "$FIGCRAFT_VERSION"
-      - name: Import signing certificate
-        env:
-          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
-          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
-          KEYCHAIN_PASSWORD: ${{ secrets.KEYCHAIN_PASSWORD }}
-        run: packaging/macos/import-cert.sh
-      - name: Build, sign, notarize
-        env:
-          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
-      # Unpacks the CLI zip and checks the binary users get: Developer ID, hardened runtime,
-      # timestamp, and Gatekeeper's notarization lookup (codesign --verify, spctl). Also the DMG's
-      # stapled ticket. Strict when the signing secrets are present, warnings otherwise.
-      - name: Verify signatures and notarization
-        env:
-          APPLE_ID: ${{ secrets.APPLE_ID }}
-          APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
-          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
-        run: packaging/macos/verify.sh --arch universal
-      - uses: actions/upload-artifact@v4
-        with:
-          name: release-macos
-          path: dist/release/*
-          if-no-files-found: error
-      - name: Remove temporary keychain
-        if: always()
-        run: |
-          if [ -n "${MACOS_KEYCHAIN:-}" ]; then security delete-keychain "$MACOS_KEYCHAIN" || true; fi
-
-  windows:
-    timeout-minutes: 90
-    name: Windows ${{ matrix.arch }}
-    needs: version
-    runs-on: windows-latest
-    environment: release
-    strategy:
-      fail-fast: false
-      matrix:
-        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:
-      FIGCRAFT_VERSION: ${{ needs.version.outputs.version }}
-      FIGCRAFT_BUILD_DATE: ${{ needs.version.outputs.date }}
-    steps:
-      - uses: actions/checkout@v4
-      - name: Check out craft-fonts (embedded fonts)
-        uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
-        with:
-          repository: storytold/craft-fonts
-          ref: ${{ env.CRAFT_FONTS_REF }}
-          path: craft-fonts
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          targets: ${{ matrix.target }}
-      - uses: Swatinem/rust-cache@v2
-        with:
-          key: release-windows-${{ matrix.arch }}
-      - name: Apply version override
-        if: inputs.version != ''
-        shell: bash
-        run: cargo run --locked -q -p xtask -- version set "$FIGCRAFT_VERSION"
-      - name: Install WiX
-        shell: pwsh
-        run: |
-          dotnet tool install --global wix --version 5.0.2
-          wix extension add -g WixToolset.UI.wixext/5.0.2 WixToolset.Util.wixext/5.0.2
-      - name: Build, sign, package
-        shell: pwsh
-        env:
-          WINDOWS_CERTIFICATE: ${{ secrets.WINDOWS_CERTIFICATE }}
-          WINDOWS_CERTIFICATE_PASSWORD: ${{ secrets.WINDOWS_CERTIFICATE_PASSWORD }}
-          AZURE_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
-          AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
-          AZURE_CLIENT_SECRET: ${{ secrets.AZURE_CLIENT_SECRET }}
-          AZURE_SIGNING_ENDPOINT: ${{ secrets.AZURE_SIGNING_ENDPOINT }}
-          AZURE_SIGNING_ACCOUNT: ${{ secrets.AZURE_SIGNING_ACCOUNT }}
-          AZURE_CERT_PROFILE: ${{ secrets.AZURE_CERT_PROFILE }}
-          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:
-          name: release-windows-${{ matrix.arch }}
-          path: dist/release/*
-          if-no-files-found: error
-
-  linux:
-    timeout-minutes: 90
-    name: Linux ${{ matrix.arch }}
-    needs: version
-    # The oldest GitHub-hosted image, so the binaries only need glibc >= 2.35 (Ubuntu 22.04+,
-    # Debian 12+, Fedora 36+, RHEL 10). See docs/releasing.md.
-    runs-on: ${{ matrix.runner }}
-    # No `environment: release`: this job reads no secrets, so a branch dry run can run it.
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - { arch: x86_64, runner: ubuntu-22.04, deb: amd64 }
-          - { arch: aarch64, runner: ubuntu-22.04-arm, deb: arm64 }
-    env:
-      FIGCRAFT_VERSION: ${{ needs.version.outputs.version }}
-      FIGCRAFT_BUILD_DATE: ${{ needs.version.outputs.date }}
-      NFPM_VERSION: 2.47.0
-    steps:
-      - uses: actions/checkout@v4
-      - name: Check out craft-fonts (embedded fonts)
-        uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
-        with:
-          repository: storytold/craft-fonts
-          ref: ${{ env.CRAFT_FONTS_REF }}
-          path: craft-fonts
-      - name: Install build and packaging tools
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y --no-install-recommends \
-            libxkbcommon-dev libwayland-dev libx11-dev libxrandr-dev libxi-dev libgl1-mesa-dev \
-            desktop-file-utils appstream python3-yaml zsync
-          curl -fsSL -o "$RUNNER_TEMP/nfpm.deb" \
-            "https://github.com/goreleaser/nfpm/releases/download/v${NFPM_VERSION}/nfpm_${NFPM_VERSION}_${{ matrix.deb }}.deb"
-          sudo dpkg -i "$RUNNER_TEMP/nfpm.deb"
-      - uses: dtolnay/rust-toolchain@stable
-      - uses: Swatinem/rust-cache@v2
-        with:
-          key: release-linux-${{ matrix.arch }}
-      - name: Apply version override
-        if: inputs.version != ''
-        run: cargo run --locked -q -p xtask -- version set "$FIGCRAFT_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: |
-          dpkg-deb --info dist/release/*.deb
-          dpkg-deb --contents dist/release/*.deb | grep -E 'usr/bin/figcraft$|metainfo|applications'
-          ldd target/release/figcraft
-          python3 -c "import yaml; m = yaml.safe_load(open('packaging/linux/flatpak/ai.storyteller.figcraft.yml')); assert m['id'] == 'ai.storyteller.figcraft'"
-          for appimage in dist/release/*.AppImage; do
-            chmod +x "$appimage"
-            APPIMAGE_EXTRACT_AND_RUN=1 "$appimage" --version
-            # Update information is embedded, and the .zsync for delta updates sits beside it.
-            "$appimage" --appimage-updateinformation | grep -F 'gh-releases-zsync|'
-            test -s "$appimage.zsync"
-          done
-      - uses: actions/upload-artifact@v4
-        with:
-          name: release-linux-${{ matrix.arch }}
-          path: dist/release/*
-          if-no-files-found: error
-
-  server:
-    timeout-minutes: 90
-    name: Server Linux ${{ matrix.arch }}
-    needs: version
-    # The headless collaboration server (docs/server.md): figcraft-server-<v>-linux-<arch>.tar.gz
-    # with the binary, licences, docs/server.md and the deployment examples. Same runners as the
-    # app, so the same glibc floor; no craft-fonts (the server draws no text).
-    # shortcut: Linux only (where servers run); add macOS/Windows archives, signed like figcraft-cli,
-    # when people host there.
-    runs-on: ${{ matrix.runner }}
-    # No `environment: release`: this job reads no secrets, so a branch dry run can run it.
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - { arch: x86_64, runner: ubuntu-22.04 }
-          - { arch: aarch64, runner: ubuntu-22.04-arm }
-    env:
-      FIGCRAFT_VERSION: ${{ needs.version.outputs.version }}
-      FIGCRAFT_BUILD_DATE: ${{ needs.version.outputs.date }}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@stable
-      - uses: Swatinem/rust-cache@v2
-        with:
-          key: release-server-${{ matrix.arch }}
-      - name: Apply version override
-        if: inputs.version != ''
-        run: cargo run --locked -q -p xtask -- version set "$FIGCRAFT_VERSION"
-      - name: Build and package (tar.gz)
-        run: packaging/server/package.sh
-      - name: Check the archive
-        run: |
-          tar -tzf "dist/release/figcraft-server-$FIGCRAFT_VERSION-linux-${{ matrix.arch }}.tar.gz" | tee "$RUNNER_TEMP/server-contents.txt"
-          for f in '/figcraft-server$' '/figcraft-server\.service$' '/Caddyfile$' '/nginx\.conf$' '/install\.sh$' '/figcraft-backup\.timer$' '/server\.md$' '/LICENSE-MIT$'; do
-            grep -E "$f" "$RUNNER_TEMP/server-contents.txt"
-          done
-          ldd target/release/figcraft-server
-      - uses: actions/upload-artifact@v4
-        with:
-          name: release-server-linux-${{ matrix.arch }}
-          path: dist/release/*.tar.gz
-          if-no-files-found: error
-
-  flatpak:
-    timeout-minutes: 90
-    name: Flatpak ${{ matrix.arch }}
-    needs: [version, linux]
-    # Repackages the Linux job's tarball (the same binaries as the AppImage/deb/rpm); no Rust
-    # build here. 24.04 for a newer flatpak-builder (1.4) than 22.04 ships.
-    runs-on: ${{ matrix.runner }}
-    # No `environment: release`: this job signs nothing, so it gets no release secrets.
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - { arch: x86_64, runner: ubuntu-24.04 }
-          - { arch: aarch64, runner: ubuntu-24.04-arm }
-    env:
-      FIGCRAFT_VERSION: ${{ needs.version.outputs.version }}
-      FIGCRAFT_BUILD_DATE: ${{ needs.version.outputs.date }}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/download-artifact@v4
-        with:
-          name: release-linux-${{ matrix.arch }}
-          path: dist/linux
-      - name: Install flatpak-builder
-        run: |
-          sudo apt-get update
-          # librsvg2-common: the SVG pixbuf loader. flatpak-builder runs the host's
-          # `appstreamcli compose`, which renders the scalable icon and fails without it.
-          sudo apt-get install -y --no-install-recommends flatpak flatpak-builder librsvg2-common
-          # Ubuntu 24.04's AppArmor blocks the unprivileged user namespaces bubblewrap needs.
-          sudo sysctl -w kernel.apparmor_restrict_unprivileged_userns=0
-      - name: Build the Flatpak bundle
-        run: packaging/linux/flatpak-bundle.sh "dist/linux/figcraft-$FIGCRAFT_VERSION-linux-${{ matrix.arch }}.tar.gz"
-      - uses: actions/upload-artifact@v4
-        with:
-          name: release-flatpak-${{ matrix.arch }}
-          path: dist/release/*.flatpak
-          if-no-files-found: error
-
-  freebsd:
-    name: FreeBSD x86_64
-    needs: version
-    # GitHub has no FreeBSD runners: build in a FreeBSD 14.3 VM, the same image and packages as
-    # .github/workflows/freebsd.yml. A private repo's ubuntu-latest has 2 vCPUs and 7 GB, too small
-    # for this VM (QEMU "cannot set up guest memory"), so it runs on the org's 16-core larger runner.
-    runs-on: github-ubuntu-16core
-    timeout-minutes: 180
-    # No `environment: release`: this job signs nothing, so it gets no release secrets.
-    env:
-      FIGCRAFT_VERSION: ${{ needs.version.outputs.version }}
-      FIGCRAFT_BUILD_DATE: ${{ needs.version.outputs.date }}
-    steps:
-      - uses: actions/checkout@v4
-      - name: Check out craft-fonts (embedded fonts)
-        uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
-        with:
-          repository: storytold/craft-fonts
-          ref: ${{ env.CRAFT_FONTS_REF }}
-          path: craft-fonts
-      - name: Build and package in a FreeBSD VM (tar.gz)
-        # vmactions/freebsd-vm v1.5.9, pinned by commit (it runs our build).
-        uses: vmactions/freebsd-vm@c46abacb49f09938ca4e1702d15d836285d694cc
-        with:
-          release: "14.3"
-          usesh: true
-          cpu: 4
-          mem: 12288
-          # Passed into the VM by name; never templated into the script below.
-          envs: "FIGCRAFT_VERSION FIGCRAFT_BUILD_DATE FIGCRAFT_BUILD_SHA INPUT_VERSION"
-          # The FreeBSD CI packages, plus bash for the packaging script.
-          prepare: |
-            pkg install -y bash git curl pkgconf cmake python3 libxkbcommon wayland libX11 libXcursor libXrandr libXi libxcb mesa-libs vulkan-loader gtk3 fontconfig freetype2
-            curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --profile minimal --default-toolchain stable
-          run: |
-            set -e
-            . "$HOME/.cargo/env"
-            git config --global --add safe.directory "$PWD"
-            # Build outside the checkout so only dist/ is copied back out of the VM (copying the
-            # target dir back fails on large builds). 4 jobs: more runs the VM out of memory.
-            export CARGO_TARGET_DIR=/var/tmp/figcraft-target CARGO_BUILD_JOBS=4
-            if [ -n "$INPUT_VERSION" ]; then cargo run --locked -q -p xtask -- version set "$FIGCRAFT_VERSION"; fi
-            # craft-fonts was checked out next to the sources and synced into the VM with them.
-            export CRAFT_FONTS_DIR="$PWD/craft-fonts" CRAFT_FONTS_REQUIRED=1
-            bash packaging/freebsd/package.sh
-            tar -tzf dist/release/figcraft-*-freebsd-x86_64.tar.gz >"$HOME/freebsd-contents.txt"
-            for f in '/bin/figcraft$' '/share/applications/ai\.storyteller\.figcraft\.desktop$' '/share/doc/figcraft/LICENSE-MIT$'; do
-              grep -E "$f" "$HOME/freebsd-contents.txt"
-            done
-      - uses: actions/upload-artifact@v4
-        with:
-          name: release-freebsd-x86_64
-          path: dist/release/*
-          if-no-files-found: error
-
-  web:
-    timeout-minutes: 90
-    name: Web (wasm)
-    needs: version
-    runs-on: ubuntu-latest
-    # No `environment: release`: this job reads no secrets, so a branch dry run can run it.
-    env:
-      FIGCRAFT_VERSION: ${{ needs.version.outputs.version }}
-      FIGCRAFT_BUILD_DATE: ${{ needs.version.outputs.date }}
-      TRUNK_VERSION: 0.21.14
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          targets: wasm32-unknown-unknown
-      - uses: Swatinem/rust-cache@v2
-        with:
-          key: release-web
-      - name: Install trunk
-        run: |
-          curl -fsSL "https://github.com/trunk-rs/trunk/releases/download/v${TRUNK_VERSION}/trunk-x86_64-unknown-linux-gnu.tar.gz" \
-            | tar -xz -C "$HOME/.cargo/bin" trunk
-          trunk --version
-      - name: Apply version override
-        if: inputs.version != ''
-        run: cargo run --locked -q -p xtask -- version set "$FIGCRAFT_VERSION"
-      # The wasm32 build embeds only Inter from craft-fonts (crates/text/build.rs): browsers have
-      # no system fonts to fall back on, and the rest would push the wasm towards
-      # packaging/web/package.sh's 24 MiB gate.
-      - name: Check out craft-fonts (embedded fonts)
-        uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
-        with:
-          repository: storytold/craft-fonts
-          ref: ${{ env.CRAFT_FONTS_REF }}
-          path: craft-fonts
-      - 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:
-          name: release-web
-          path: dist/release/*
-          if-no-files-found: error
-
-  linux-riscv64:
-    timeout-minutes: 90
-    name: Linux riscv64
-    needs: version
-    # Cross-compiled on x86_64 (no hosted RISC-V runners) against the runner's own Ubuntu release
-    # from ports.ubuntu.com, so the binaries need that release's glibc (24.04: 2.39). 22.04's
-    # riscv64 ports lag its amd64 updates, which breaks the multiarch install. tar.gz only; the
-    # CLI is smoke-tested under QEMU.
-    runs-on: ubuntu-24.04
-    # No `environment: release`: this job reads no secrets, so a branch dry run can run it.
-    env:
-      FIGCRAFT_VERSION: ${{ needs.version.outputs.version }}
-      FIGCRAFT_BUILD_DATE: ${{ needs.version.outputs.date }}
-    steps:
-      - uses: actions/checkout@v4
-      - name: Check out craft-fonts (embedded fonts)
-        uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
-        with:
-          repository: storytold/craft-fonts
-          ref: ${{ env.CRAFT_FONTS_REF }}
-          path: craft-fonts
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          targets: riscv64gc-unknown-linux-gnu
-      - uses: Swatinem/rust-cache@v2
-        with:
-          key: release-linux-riscv64
-      - name: Apply version override
-        if: inputs.version != ''
-        run: cargo run --locked -q -p xtask -- version set "$FIGCRAFT_VERSION"
-      - name: Install cross-compilation dependencies
-        run: |
-          . /etc/os-release
-          sudo dpkg --add-architecture riscv64
-          # Pin the existing (archive.ubuntu.com) sources to amd64; riscv64 comes from ports.
-          if [ -f /etc/apt/sources.list.d/ubuntu.sources ]; then
-            sudo sed -i '/^Types: deb/a Architectures: amd64' /etc/apt/sources.list.d/ubuntu.sources
-          fi
-          if [ -f /etc/apt/sources.list ]; then
-            sudo sed -i 's/^deb /deb [arch=amd64] /g' /etc/apt/sources.list
-            sudo sed -i 's/^deb-src /deb-src [arch=amd64] /g' /etc/apt/sources.list
-          fi
-          for suite in "$VERSION_CODENAME" "$VERSION_CODENAME-updates" "$VERSION_CODENAME-security"; do
-            echo "deb [arch=riscv64] http://ports.ubuntu.com/ubuntu-ports $suite main universe restricted multiverse"
-          done | sudo tee /etc/apt/sources.list.d/riscv64.list
-          sudo apt-get update
-          sudo apt-get install -y --no-install-recommends \
-            gcc-riscv64-linux-gnu binutils-riscv64-linux-gnu libc6-dev-riscv64-cross libc6-dev:riscv64 qemu-user \
-            libxkbcommon-dev:riscv64 libwayland-dev:riscv64 libx11-dev:riscv64 libxrandr-dev:riscv64 \
-            libxi-dev:riscv64 libgl1-mesa-dev:riscv64
-      - name: Build and package (tar.gz)
-        env:
-          CRAFT_FONTS_DIR: ${{ github.workspace }}/craft-fonts
-          CRAFT_FONTS_REQUIRED: "1"
-          CARGO_TARGET_RISCV64GC_UNKNOWN_LINUX_GNU_LINKER: riscv64-linux-gnu-gcc
-          PKG_CONFIG_SYSROOT_DIR: /
-          PKG_CONFIG_PATH: /usr/lib/riscv64-linux-gnu/pkgconfig:/usr/share/pkgconfig
-          PKG_CONFIG_ALLOW_CROSS: "1"
-          CROSS_ARCH: riscv64
-          CROSS_TARGET: riscv64gc-unknown-linux-gnu
-          CROSS_COMPILE: riscv64-linux-gnu-
-          EMULATOR: qemu-riscv64
-          QEMU_LD_PREFIX: /usr/riscv64-linux-gnu
-        run: packaging/linux/package.sh --formats tar
-      - uses: actions/upload-artifact@v4
-        with:
-          name: release-linux-riscv64
-          path: dist/release/*.tar.gz
-          if-no-files-found: error
-
   release:
-    timeout-minutes: 10
-    name: Draft GitHub Release
-    needs: [version, macos, windows, linux, linux-riscv64, flatpak, freebsd, web, server]
-    runs-on: ubuntu-latest
-    environment: release
-    permissions:
-      contents: write
-    env:
-      VERSION: ${{ needs.version.outputs.version }}
-      PRERELEASE: ${{ needs.version.outputs.prerelease }}
-      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      GH_REPO: ${{ github.repository }}
-    steps:
-      - uses: actions/download-artifact@v4
-        with:
-          pattern: release-*
-          path: artifacts
-          merge-multiple: true
-      - name: Checksums
-        working-directory: artifacts
-        run: |
-          sha256sum -- * | tee SHA256SUMS.txt
-      - name: Create or update the draft release
-        working-directory: artifacts
-        run: |
-          tag="v$VERSION"
-          title="FigCraft v$VERSION"
-          pre=()
-          if [ "$PRERELEASE" = true ]; then pre=(--prerelease); fi
-          if draft="$(gh release view "$tag" --json isDraft --jq .isDraft 2>/dev/null)"; then
-            if [ "$draft" != "true" ]; then
-              echo "::error::Release $tag is already published. Bump the version (cargo run -p xtask -- version set X.Y.Z) before pushing to release."
-              exit 1
-            fi
-            echo "Updating draft $tag: replacing its assets"
-            gh release view "$tag" --json assets --jq '.assets[].name' | while read -r asset; do
-              gh release delete-asset "$tag" "$asset" --yes
-            done
-            gh release edit "$tag" --draft --title "$title" --target "$GITHUB_SHA" --prerelease="$PRERELEASE"
-            gh release upload "$tag" --clobber -- *
-          else
-            echo "Creating draft $tag"
-            gh release create "$tag" --draft --title "$title" --target "$GITHUB_SHA" --generate-notes "${pre[@]}" -- *
-          fi
-          {
-            echo "Draft release **$title** at \`${GITHUB_SHA::9}\`:"
-            echo
-            sed 's/^/    /' SHA256SUMS.txt
-          } >>"$GITHUB_STEP_SUMMARY"
+    # Intentionally tracked at @main (not SHA-pinned) so org-wide CI improvements, security fixes, and build optimizations propagate without PR churn across all craftapp repos.
+    uses: storytold/craft-common-actions/.github/workflows/release.yml@main
+    with:
+      app-name: figcraft
+      app-title: FigCraft
+      # Needs fonts/latin-manifest.txt (Inter): crates/text/build.rs fails a release without it. Only
+      # craft-fonts' pr/latin-presentation-fonts has it; its main has Noto Sans Georgian but no Inter.
+      # Re-pin once one commit has both (storytold/craft-fonts#42).
+      craft-fonts-ref: 43913056ce82a3fdad0ef69f6b88d1dc922a8104
+      has-server: true
+      # The browser has no system fonts: without craft-fonts the web build can't draw text (#885).
+      # crates/text/build.rs keeps the web build to Inter.
+      web-craft-fonts: true
+      version: ${{ inputs.version }}
+    secrets:
+      APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
+      APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
+      KEYCHAIN_PASSWORD: ${{ secrets.KEYCHAIN_PASSWORD }}
+      APPLE_ID: ${{ secrets.APPLE_ID }}
+      APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
+      APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
+      WINDOWS_CERTIFICATE: ${{ secrets.WINDOWS_CERTIFICATE }}
+      WINDOWS_CERTIFICATE_PASSWORD: ${{ secrets.WINDOWS_CERTIFICATE_PASSWORD }}
+      AZURE_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
+      AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
+      AZURE_CLIENT_SECRET: ${{ secrets.AZURE_CLIENT_SECRET }}
+      AZURE_SIGNING_ENDPOINT: ${{ secrets.AZURE_SIGNING_ENDPOINT }}
+      AZURE_SIGNING_ACCOUNT: ${{ secrets.AZURE_SIGNING_ACCOUNT }}
+      AZURE_CERT_PROFILE: ${{ secrets.AZURE_CERT_PROFILE }}
diff --git a/.github/workflows/sonarcloud.yml b/.github/workflows/sonarcloud.yml
new file mode 100644
index 000000000..e78fe1ea3
--- /dev/null
+++ b/.github/workflows/sonarcloud.yml
@@ -0,0 +1,21 @@
+name: SonarCloud
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+permissions:
+  contents: read
+
+concurrency:
+  group: sonarcloud-${{ github.ref }}
+  # A push to main is the run that publishes coverage; superseded runs there would never finish.
+  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
+jobs:
+  sonarcloud:
+    # Tracked at @main so org-wide CI improvements propagate without PR churn.
+    uses: storytold/craft-common-actions/.github/workflows/sonarcloud.yml@main
+    secrets: inherit
diff --git a/.github/workflows/windows-arm64.yml b/.github/workflows/windows-arm64.yml
index a289df720..4cceb9225 100644
--- a/.github/workflows/windows-arm64.yml
+++ b/.github/workflows/windows-arm64.yml
@@ -24,77 +24,10 @@ concurrency:
 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
-          wix extension add -g WixToolset.UI.wixext/5.0.2 WixToolset.Util.wixext/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: figcraft-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: figcraft-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 'FigCraft'
-          # figcraft-cli.exe ships once apps/figcraft-cli exists; check it when installed.
-          foreach ($exe in 'figcraft.exe', 'figcraft-cli.exe') {
-            $path = Join-Path $dir $exe
-            if (-not (Test-Path $path)) {
-              if ($exe -eq 'figcraft-cli.exe') { Write-Output "skip $exe (not in this build)"; continue }
-              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 binary runs natively on ARM64 (the CLI when present, else the app's --version).
-          $cli = Join-Path $dir 'figcraft-cli.exe'
-          if (-not (Test-Path $cli)) { $cli = Join-Path $dir 'figcraft.exe' }
-          $out = & $cli --version 2>&1 | Out-String
-          if ($LASTEXITCODE -ne 0) { Write-Output $out; throw "$cli --version exited $LASTEXITCODE" }
-          Write-Output "ok $(Split-Path -Leaf $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 'figcraft.exe')) { throw 'uninstall left figcraft.exe behind' }
-          Write-Output 'ok uninstalled'
+  windows-arm64:
+    # Intentionally tracked at @main (not SHA-pinned) so org-wide CI improvements, security fixes, and build optimizations propagate without PR churn across all craftapp repos.
+    uses: storytold/craft-common-actions/.github/workflows/windows-arm64.yml@main
+    with:
+      app-name: figcraft
+      app-dir: FigCraft
diff --git a/AGENTS.md b/AGENTS.md
index 708da805c..b2384311a 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -81,6 +81,7 @@ code.
   L6 depends on egui/eframe/rfd/winit. **The UI crate is swappable.**
 - **The UI is thin**: panels read engine state and act through `app.run(id, params)` /
   `app.set_props(ids, props)`. Colours come from `theme::Tokens`.
+- **Time goes through `chrono`** (workspace dependency). Never hand-roll UTC/calendar conversion (days-to-date algorithms, leap-year math); a crate owns only its output format string. The one exception is range extension: past the years chrono can represent, shift the date by whole 400-year Gregorian cycles (146,097 days, after which the calendar repeats), let chrono compute the month and day, and add the cycles back to the year (splitting seconds into hours, minutes and seconds is plain arithmetic).
 - **Rust only** (no handwritten JS/TS). **Never break wasm** (`cargo xtask wasm`).
 
 ### Quality gates (before every commit)
diff --git a/ATTRIBUTION.md b/ATTRIBUTION.md
index 1f72aeb7c..96dff6a9e 100644
--- a/ATTRIBUTION.md
+++ b/ATTRIBUTION.md
@@ -25,6 +25,7 @@ Release builds embed fonts from the optional craft-fonts build input
 | Family | Licence | Upstream |
 |---|---|---|
 | Inter | SIL Open Font License 1.1 | https://github.com/rsms/inter |
+| Archivo | SIL Open Font License 1.1 | [Google Fonts / Archivo](https://github.com/google/fonts/tree/6c70c829f09ea345d3590406693220ea35c6553f/ofl/archivo) |
 | Roboto, Montserrat, Lato, Open Sans, Poppins, Nunito Sans, Merriweather, Playfair Display, Source Sans 3, Source Serif 4, Carlito, Caladea | SIL Open Font License 1.1 | Google Fonts / upstream repositories (see craft-fonts) |
 | Liberation Sans, Serif, Mono | SIL Open Font License 1.1 | https://github.com/liberationfonts |
 | BIZ UDPGothic, BIZ UDMincho, Shippori Mincho, Noto Sans Arabic | SIL Open Font License 1.1 | Google Fonts (see craft-fonts) |
diff --git a/CLAUDE.md b/CLAUDE.md
index 708da805c..b2384311a 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -81,6 +81,7 @@ code.
   L6 depends on egui/eframe/rfd/winit. **The UI crate is swappable.**
 - **The UI is thin**: panels read engine state and act through `app.run(id, params)` /
   `app.set_props(ids, props)`. Colours come from `theme::Tokens`.
+- **Time goes through `chrono`** (workspace dependency). Never hand-roll UTC/calendar conversion (days-to-date algorithms, leap-year math); a crate owns only its output format string. The one exception is range extension: past the years chrono can represent, shift the date by whole 400-year Gregorian cycles (146,097 days, after which the calendar repeats), let chrono compute the month and day, and add the cycles back to the year (splitting seconds into hours, minutes and seconds is plain arithmetic).
 - **Rust only** (no handwritten JS/TS). **Never break wasm** (`cargo xtask wasm`).
 
 ### Quality gates (before every commit)
diff --git a/Cargo.lock b/Cargo.lock
index b2f9d9d0a..1aea3b97a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -244,9 +244,9 @@ dependencies = [
 
 [[package]]
 name = "arboard"
-version = "3.6.1"
+version = "3.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0348a1c054491f4bfe6ab86a7b6ab1e44e45d899005de92f58b3df180b36ddaf"
+checksum = "aeb9553e62312c8756a5979254fc6d7da8bbeb5986a1e17037fab932f7037917"
 dependencies = [
  "clipboard-win",
  "image",
@@ -258,7 +258,8 @@ dependencies = [
  "objc2-foundation 0.3.2",
  "parking_lot",
  "percent-encoding",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
+ "wl-clipboard-rs",
  "x11rb",
 ]
 
@@ -391,7 +392,7 @@ checksum = "4f8abc12baad266b1c8cec146854c195b5864b4221d4b2ca7296a7ae82d9e451"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.6",
+ "syn 3.0.9",
 ]
 
 [[package]]
@@ -426,7 +427,7 @@ checksum = "82f6aeea286b8eb4dd3431a1be1b59d290ace00f5bfd8e2a159bc2a05e2c1667"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.6",
+ "syn 3.0.9",
 ]
 
 [[package]]
@@ -490,15 +491,6 @@ version = "0.23.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5"
 
-[[package]]
-name = "bit-set"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3"
-dependencies = [
- "bit-vec 0.8.0",
-]
-
 [[package]]
 name = "bit-set"
 version = "0.10.0"
@@ -509,10 +501,13 @@ dependencies = [
 ]
 
 [[package]]
-name = "bit-vec"
-version = "0.8.0"
+name = "bit-set"
+version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"
+checksum = "56d87354e4229f54a44f7bf2435906a4656dba36026ab6eaca629a2c436a691c"
+dependencies = [
+ "bit-vec 0.10.1",
+]
 
 [[package]]
 name = "bit-vec"
@@ -520,6 +515,16 @@ version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b71798fca2c1fe1086445a7258a4bc81e6e49dcd24c8d0dd9a1e57395b603f51"
 
+[[package]]
+name = "bit-vec"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5727b15fa97d4f4fee0a3b7c3d550ed0269f54329207b86388de918604e31269"
+dependencies = [
+ "borsh",
+ "serde",
+]
+
 [[package]]
 name = "bitflags"
 version = "1.3.2"
@@ -581,6 +586,30 @@ dependencies = [
  "piper",
 ]
 
+[[package]]
+name = "borsh"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "553c5d846a6ba5150c65e3b1b8ec073bcf1abc20f9b7220de384a4443ea4e20a"
+dependencies = [
+ "borsh-derive",
+ "bytes",
+ "cfg_aliases",
+]
+
+[[package]]
+name = "borsh-derive"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12cdfe656708a01f89b451a7d36466e6fe6c414de0aa18fc54f864f6f9ca9f56"
+dependencies = [
+ "once_cell",
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "syn 3.0.9",
+]
+
 [[package]]
 name = "bumpalo"
 version = "3.20.3"
@@ -604,7 +633,7 @@ checksum = "6a1f896587b6f2c069c73d2f0913e2d590c3990285cd2f0b6aa02b786b4c679c"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.6",
+ "syn 3.0.9",
 ]
 
 [[package]]
@@ -671,9 +700,9 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.6.0"
+version = "1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f74872d07caf508b30a21f6836e7d7016a2eaf7d9ff4f48deaa58cd8a0407630"
+checksum = "877bf67ac8e52449eb2f9e98a344ea163beb70dd1f9eebe3cc5357dcfeaee4df"
 dependencies = [
  "find-msvc-tools",
  "jobserver",
@@ -713,6 +742,15 @@ dependencies = [
  "rand_core 0.10.1",
 ]
 
+[[package]]
+name = "chrono"
+version = "0.4.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1aa79e62e7697b8e29b513a68abacf485adcd1fe8284a4316c5ae868e6633327"
+dependencies = [
+ "num-traits",
+]
+
 [[package]]
 name = "clipboard-win"
 version = "5.4.1"
@@ -765,9 +803,9 @@ checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"
 
 [[package]]
 name = "combine"
-version = "4.6.8"
+version = "4.6.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cfc320937d09e6de266b31b9afb480f197d7a861be86be7cb2ea7e5d1bfffc5e"
+checksum = "4356eba6976435498d05a311ee9fc486da3bc81c200d3f0d7dd9703b41913f92"
 dependencies = [
  "bytes",
  "memchr",
@@ -828,6 +866,12 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "core_detect"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f8f80099a98041a3d1622845c271458a2d73e688351bf3cb999266764b81d48"
+
 [[package]]
 name = "core_maths"
 version = "0.1.1"
@@ -855,11 +899,25 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "craft-docpath"
+version = "0.1.0"
+source = "git+https://github.com/storytold/craft-libs?rev=82a24b006eefa036b43c09a67fb9a3fbd17ffe63#82a24b006eefa036b43c09a67fb9a3fbd17ffe63"
+
+[[package]]
+name = "craft-window"
+version = "0.1.0"
+source = "git+https://github.com/storytold/craft-libs?rev=1f805378d454dac48b5c214029d254055fdf961b#1f805378d454dac48b5c214029d254055fdf961b"
+dependencies = [
+ "egui",
+ "wayland-client",
+]
+
 [[package]]
 name = "crc32fast"
-version = "1.5.2"
+version = "1.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "01a7799fd6b852db0e61728dde9a204c423b44d689dbd432522543614b490e78"
+checksum = "0ba106e844045ddc02c20768ac4b0b7cb45f2cc2ecbd833ac9f5dacb183c2055"
 dependencies = [
  "cfg-if",
 ]
@@ -945,9 +1003,9 @@ checksum = "be1e0bca6c3637f992fc1cc7cbc52a78c1ef6db076dbf1059c4323d6a2048376"
 
 [[package]]
 name = "defmt"
-version = "1.1.1"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2953bfe4f93bbd20cc71198842756f77d161884c99ebbabc41d80231ded88d1"
+checksum = "e4a0795ac740cb54d7b3775c9c17345f6aaecf884c01733b39d6017738e0e3e1"
 dependencies = [
  "bitflags 1.3.2",
  "defmt-macros",
@@ -955,21 +1013,21 @@ dependencies = [
 
 [[package]]
 name = "defmt-macros"
-version = "1.1.1"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bad9c72e7ca2137e0dc3813245a0d282fd6daad32fd800af018306a9169b5fe8"
+checksum = "840bb056bd99c495c9188198a258ab787c79f306d864db3e6e8451442d6d8366"
 dependencies = [
  "defmt-parser",
  "proc-macro2",
  "quote",
- "syn 2.0.119",
+ "syn 3.0.9",
 ]
 
 [[package]]
 name = "defmt-parser"
-version = "1.0.0"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10d60334b3b2e7c9d91ef8150abfb6fa4c1c39ebbcf4a81c2e346aad939fee3e"
+checksum = "71958f69fb2de856c5dd51ac9377e986ca1aa5919f931bf5395a807277f889a0"
 dependencies = [
  "thiserror 2.0.21",
 ]
@@ -982,7 +1040,7 @@ checksum = "1b034bd7d5f032402a2479444dcc6f74e36a03f31854d41680fb240ef682a1ac"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.6",
+ "syn 3.0.9",
 ]
 
 [[package]]
@@ -1032,7 +1090,7 @@ checksum = "c6232dd377dcc64799954cbd3a9bb882e9cdc1308ccd87b1c098f1fb2eaf82a8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.6",
+ "syn 3.0.9",
 ]
 
 [[package]]
@@ -1307,7 +1365,7 @@ dependencies = [
  "ecolor",
  "emath",
  "epaint_default_fonts",
- "font-types 0.12.6",
+ "font-types 0.12.7",
  "harfrust 0.12.0",
  "log",
  "nohash-hasher",
@@ -1329,9 +1387,9 @@ checksum = "773fa9c96dd0dbef887e39d0ed6177f141cce4d68e6041df77570aa3702dfa13"
 
 [[package]]
 name = "equivalent"
-version = "1.0.2"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+checksum = "00d174d5400e5e8fd687ad1049e2f578285fa914201b1af7e8b112a4546bd826"
 
 [[package]]
 name = "errno"
@@ -1407,9 +1465,10 @@ checksum = "b97b65636e5b9ef369943878ac74335ba1c55c1cb6adbf1e2c293c624248d693"
 
 [[package]]
 name = "figcraft"
-version = "0.6.0"
+version = "0.10.0"
 dependencies = [
  "arboard",
+ "craft-window",
  "eframe",
  "egui",
  "env_logger",
@@ -1426,13 +1485,14 @@ dependencies = [
  "wat",
  "webbrowser",
  "windows",
+ "winit",
  "winresource",
  "zbus",
 ]
 
 [[package]]
 name = "figcraft-cli"
-version = "0.6.0"
+version = "0.10.0"
 dependencies = [
  "figcraft-doc",
  "figcraft-engine",
@@ -1446,9 +1506,10 @@ dependencies = [
 
 [[package]]
 name = "figcraft-collab"
-version = "0.6.0"
+version = "0.10.0"
 dependencies = [
  "base64 0.22.1",
+ "chrono",
  "figcraft-color",
  "figcraft-doc",
  "figcraft-geom",
@@ -1461,7 +1522,7 @@ dependencies = [
 
 [[package]]
 name = "figcraft-collab-net"
-version = "0.6.0"
+version = "0.10.0"
 dependencies = [
  "base64 0.22.1",
  "figcraft-collab",
@@ -1484,7 +1545,7 @@ dependencies = [
 
 [[package]]
 name = "figcraft-color"
-version = "0.6.0"
+version = "0.10.0"
 dependencies = [
  "kurbo",
  "serde",
@@ -1493,7 +1554,7 @@ dependencies = [
 
 [[package]]
 name = "figcraft-doc"
-version = "0.6.0"
+version = "0.10.0"
 dependencies = [
  "figcraft-color",
  "figcraft-geom",
@@ -1505,9 +1566,10 @@ dependencies = [
 
 [[package]]
 name = "figcraft-engine"
-version = "0.6.0"
+version = "0.10.0"
 dependencies = [
  "base64 0.22.1",
+ "craft-docpath",
  "figcraft-collab",
  "figcraft-color",
  "figcraft-doc",
@@ -1532,7 +1594,7 @@ dependencies = [
 
 [[package]]
 name = "figcraft-format"
-version = "0.6.0"
+version = "0.10.0"
 dependencies = [
  "figcraft-doc",
  "figcraft-pathops",
@@ -1547,7 +1609,7 @@ dependencies = [
 
 [[package]]
 name = "figcraft-geom"
-version = "0.6.0"
+version = "0.10.0"
 dependencies = [
  "kurbo",
  "serde",
@@ -1555,7 +1617,7 @@ dependencies = [
 
 [[package]]
 name = "figcraft-layout"
-version = "0.6.0"
+version = "0.10.0"
 dependencies = [
  "figcraft-doc",
  "figcraft-geom",
@@ -1563,7 +1625,7 @@ dependencies = [
 
 [[package]]
 name = "figcraft-mcp"
-version = "0.6.0"
+version = "0.10.0"
 dependencies = [
  "base64 0.22.1",
  "figcraft-collab-net",
@@ -1579,7 +1641,7 @@ dependencies = [
 
 [[package]]
 name = "figcraft-pathops"
-version = "0.6.0"
+version = "0.10.0"
 dependencies = [
  "figcraft-doc",
  "figcraft-geom",
@@ -1588,7 +1650,7 @@ dependencies = [
 
 [[package]]
 name = "figcraft-pdf"
-version = "0.6.0"
+version = "0.10.0"
 dependencies = [
  "figcraft-color",
  "figcraft-doc",
@@ -1600,12 +1662,12 @@ dependencies = [
  "krilla",
  "log",
  "thiserror 2.0.21",
- "tiny-skia",
+ "tiny-skia 0.12.0",
 ]
 
 [[package]]
 name = "figcraft-plugin"
-version = "0.6.0"
+version = "0.10.0"
 dependencies = [
  "figcraft-color",
  "serde",
@@ -1618,7 +1680,7 @@ dependencies = [
 
 [[package]]
 name = "figcraft-render"
-version = "0.6.0"
+version = "0.10.0"
 dependencies = [
  "crc32fast",
  "figcraft-color",
@@ -1631,12 +1693,12 @@ dependencies = [
  "moxcms",
  "png",
  "rayon",
- "tiny-skia",
+ "tiny-skia 0.12.0",
 ]
 
 [[package]]
 name = "figcraft-server"
-version = "0.6.0"
+version = "0.10.0"
 dependencies = [
  "crc32fast",
  "ctrlc",
@@ -1660,7 +1722,7 @@ dependencies = [
 
 [[package]]
 name = "figcraft-svg"
-version = "0.6.0"
+version = "0.10.0"
 dependencies = [
  "base64 0.22.1",
  "figcraft-color",
@@ -1676,7 +1738,7 @@ dependencies = [
 
 [[package]]
 name = "figcraft-text"
-version = "0.6.0"
+version = "0.10.0"
 dependencies = [
  "figcraft-doc",
  "figcraft-geom",
@@ -1690,9 +1752,10 @@ dependencies = [
 
 [[package]]
 name = "figcraft-ui-egui"
-version = "0.6.0"
+version = "0.10.0"
 dependencies = [
  "base64 0.22.1",
+ "chrono",
  "egui",
  "egui_extras",
  "figcraft-color",
@@ -1715,7 +1778,7 @@ dependencies = [
 
 [[package]]
 name = "figcraft-web"
-version = "0.6.0"
+version = "0.10.0"
 dependencies = [
  "eframe",
  "egui",
@@ -1731,9 +1794,15 @@ dependencies = [
 
 [[package]]
 name = "find-msvc-tools"
-version = "0.1.14"
+version = "0.1.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aedcfb3409746eddb02b9e19ebda1c3394f759a152e48ee875a0844d1b955484"
+checksum = "1c66915cc5391097de7a2b0b972e8505aa33c0df401fd3a6811dbdb32881ba48"
+
+[[package]]
+name = "fixedbitset"
+version = "0.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
 
 [[package]]
 name = "flate2"
@@ -1795,9 +1864,9 @@ dependencies = [
 
 [[package]]
 name = "font-types"
-version = "0.12.6"
+version = "0.12.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c92d9081c7ab3bd83ef1eecdfad090f3d966e3ce74106779664114cfe1a6274"
+checksum = "835ae9d781464a79026cde387f9cbc650c9a4909d7cf7e658b127e3c35d2f35d"
 dependencies = [
  "bytemuck",
 ]
@@ -1842,7 +1911,7 @@ checksum = "ea5190182e6915eb873ddbc16e23b711b6eb1f9c00a0d0a3a91b5f6228475225"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.6",
+ "syn 3.0.9",
 ]
 
 [[package]]
@@ -1893,7 +1962,7 @@ checksum = "9fb9654ba8355388abeb8dcb4fc62f511300867002afc858860463bdd9fe0c44"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.6",
+ "syn 3.0.9",
 ]
 
 [[package]]
@@ -2564,7 +2633,7 @@ dependencies = [
  "skrifa 0.42.1",
  "smallvec",
  "subsetter",
- "tiny-skia-path",
+ "tiny-skia-path 0.12.0",
  "xmp-writer",
  "yoke",
  "zune-jpeg",
@@ -2591,9 +2660,9 @@ checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
 
 [[package]]
 name = "libc"
-version = "0.2.190"
+version = "0.2.191"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce5d3ddc6d3fa000eb1536d85e147bfe31aacaba692ed6a876f95cb7c855be78"
+checksum = "65cd87c9a6d60536580b316ad985726104730a5151c99845f2490428ef91240a"
 
 [[package]]
 name = "libloading"
@@ -2620,7 +2689,7 @@ dependencies = [
  "bitflags 2.13.2",
  "libc",
  "plain",
- "redox_syscall 0.9.4",
+ "redox_syscall 0.9.5",
 ]
 
 [[package]]
@@ -2662,9 +2731,9 @@ checksum = "47d9d19d1d6efa0109d2f65ff4c85cddd50bd572e5a00127ab10987290bcefae"
 
 [[package]]
 name = "litrs"
-version = "1.0.0"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11d3d7f243d5c5a8b9bb5d6dd2b1602c0cb0b9db1621bafc7ed66e35ff9fe092"
+checksum = "4744e383959f0db86ede514b809b1c53251889093803c05267acc7d4e7030d70"
 
 [[package]]
 name = "lock_api"
@@ -2821,6 +2890,15 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2bf50223579dc7cdcfb3bfcacf7069ff68243f8c363f62ffa99cf000a6b9c451"
 
+[[package]]
+name = "nom"
+version = "8.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df9761775871bdef83bee530e60050f7e54b1105350d6884eb0fb4f46c2f9405"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "num-traits"
 version = "0.2.19"
@@ -3205,6 +3283,16 @@ dependencies = [
  "pin-project-lite",
 ]
 
+[[package]]
+name = "os_pipe"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "parking"
 version = "2.2.1"
@@ -3265,6 +3353,17 @@ version = "2.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
 
+[[package]]
+name = "petgraph"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8701b58ea97060d5e5b155d383a69952a60943f0e6dfe30b04c287beb0b27455"
+dependencies = [
+ "fixedbitset",
+ "hashbrown 0.15.5",
+ "indexmap",
+]
+
 [[package]]
 name = "phf"
 version = "0.13.1"
@@ -3447,15 +3546,6 @@ dependencies = [
  "zerovec",
 ]
 
-[[package]]
-name = "ppv-lite86"
-version = "0.2.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
-dependencies = [
- "zerocopy",
-]
-
 [[package]]
 name = "presser"
 version = "0.3.1"
@@ -3488,16 +3578,17 @@ checksum = "3d595e54a326bc53c1c197b32d295e14b169e3cfeaa8dc82b529f947fba6bcf5"
 
 [[package]]
 name = "proptest"
-version = "1.11.0"
+version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b45fcc2344c680f5025fe57779faef368840d0bd1f42f216291f0dc4ace4744"
+checksum = "b8530004ccb15eae51c7e40009fbe317f341f804db54dc033eec1c50be28cfa0"
 dependencies = [
- "bit-set 0.8.0",
- "bit-vec 0.8.0",
+ "bit-set 0.11.1",
+ "bit-vec 0.10.1",
  "bitflags 2.13.2",
+ "chacha20",
+ "core_detect",
  "num-traits",
- "rand 0.9.5",
- "rand_chacha",
+ "rand",
  "rand_xorshift",
  "regex-syntax",
  "rusty-fork",
@@ -3553,16 +3644,6 @@ version = "6.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
 
-[[package]]
-name = "rand"
-version = "0.9.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9ef1d0d795eb7d84685bca4f72f3649f064e6641543d3a8c415898726a57b41"
-dependencies = [
- "rand_chacha",
- "rand_core 0.9.5",
-]
-
 [[package]]
 name = "rand"
 version = "0.10.3"
@@ -3574,24 +3655,11 @@ dependencies = [
  "rand_core 0.10.1",
 ]
 
-[[package]]
-name = "rand_chacha"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
-dependencies = [
- "ppv-lite86",
- "rand_core 0.9.5",
-]
-
 [[package]]
 name = "rand_core"
 version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
-dependencies = [
- "getrandom 0.3.4",
-]
 
 [[package]]
 name = "rand_core"
@@ -3601,11 +3669,11 @@ checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"
 
 [[package]]
 name = "rand_xorshift"
-version = "0.4.0"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "513962919efc330f829edb2535844d1b912b0fbe2ca165d613e4e8788bb05a5a"
+checksum = "60aa6af80be32871323012e02e6e65f8a7cc7890931ae421d217ad8fe0df2ccf"
 dependencies = [
- "rand_core 0.9.5",
+ "rand_core 0.10.1",
 ]
 
 [[package]]
@@ -3678,7 +3746,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "046a7d674daf459825b32f5062056d6882db0d2f5a479fbd76ccfc870ac18709"
 dependencies = [
  "bytemuck",
- "font-types 0.12.6",
+ "font-types 0.12.7",
  "once_cell",
 ]
 
@@ -3689,7 +3757,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "005c8acf251756c478b0bf402885bfd88a1476020c4c7e6060edc1aa68da38ea"
 dependencies = [
  "bytemuck",
- "font-types 0.12.6",
+ "font-types 0.12.7",
  "once_cell",
 ]
 
@@ -3700,7 +3768,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d5a0cf4bb6cbce4c29756270d189a5e400ac05e91192161d83a0bcb6e68492e8"
 dependencies = [
  "bytemuck",
- "font-types 0.12.6",
+ "font-types 0.12.7",
  "once_cell",
 ]
 
@@ -3724,9 +3792,9 @@ dependencies = [
 
 [[package]]
 name = "redox_syscall"
-version = "0.9.4"
+version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "737970939a87c6fa31e7acad13307bccbb017a073b695b6089a2c484f929e20e"
+checksum = "580c875845b41ecb1564ad1ae4703044cef774145e3d7a94dc2b3fa7c97868fd"
 dependencies = [
  "bitflags 2.13.2",
 ]
@@ -3871,9 +3939,9 @@ dependencies = [
 
 [[package]]
 name = "rustls"
-version = "0.23.45"
+version = "0.23.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d41d731c7d2f962d1ccc364cec258de3c0e93b38c2fb3ba97ac74513048d634"
+checksum = "48e13bd8c0e9365c43cfa5c9e8f9ad49d3c8444926c9aac819e0e4dc503c8fdf"
 dependencies = [
  "log",
  "once_cell",
@@ -3895,9 +3963,9 @@ dependencies = [
 
 [[package]]
 name = "rustls-webpki"
-version = "0.103.15"
+version = "0.103.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3c3cf1d8b1e7d4927e2d154c3fcb02979afb9939629c62cd9048d4f07b60ac2"
+checksum = "4443b1b6d39d7c663139942cc4558262562d2c84123bb6282ef177009ca8b281"
 dependencies = [
  "ring",
  "rustls-pki-types",
@@ -3982,6 +4050,17 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
+[[package]]
+name = "sctk-adwaita"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6277f0217056f77f1d8f49f2950ac6c278c0d607c45f5ee99328d792ede24ec"
+dependencies = [
+ "log",
+ "smithay-client-toolkit 0.19.2",
+ "tiny-skia 0.11.4",
+]
+
 [[package]]
 name = "self_cell"
 version = "1.3.0"
@@ -4021,14 +4100,14 @@ checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.6",
+ "syn 3.0.9",
 ]
 
 [[package]]
 name = "serde_json"
-version = "1.0.151"
+version = "1.0.154"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14"
+checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6"
 dependencies = [
  "itoa",
  "memchr",
@@ -4045,7 +4124,7 @@ checksum = "8d3b1629de253c70a0508c3899572da79ca359fdab27c7920ff00406df418906"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.6",
+ "syn 3.0.9",
 ]
 
 [[package]]
@@ -4179,9 +4258,9 @@ dependencies = [
 
 [[package]]
 name = "smallvec"
-version = "1.16.2"
+version = "1.16.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9395f0f0eee849a9b707b2f06bb92a6a422090e2123bb2ef8e87a0e61892a8e"
+checksum = "5b3dc8af474f516a851ff4bd12db780f948b9250ad37211e4eec0bccea54e01b"
 dependencies = [
  "serde",
 ]
@@ -4345,9 +4424,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "3.0.6"
+version = "3.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee"
+checksum = "d78c8dee4c7bf0e14673097256fed6142ce9d3b85a408189d07482442145823b"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -4362,7 +4441,7 @@ checksum = "901704edd0dfe137f1987838ee4f259e4e063c31371bdb423f7ae38ec6f77f02"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.6",
+ "syn 3.0.9",
 ]
 
 [[package]]
@@ -4424,7 +4503,7 @@ checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.6",
+ "syn 3.0.9",
 ]
 
 [[package]]
@@ -4441,6 +4520,20 @@ dependencies = [
  "zune-jpeg",
 ]
 
+[[package]]
+name = "tiny-skia"
+version = "0.11.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83d13394d44dae3207b52a326c0c85a8bf87f1541f23b0d143811088497b09ab"
+dependencies = [
+ "arrayref",
+ "arrayvec",
+ "bytemuck",
+ "cfg-if",
+ "log",
+ "tiny-skia-path 0.11.4",
+]
+
 [[package]]
 name = "tiny-skia"
 version = "0.12.0"
@@ -4453,7 +4546,18 @@ dependencies = [
  "cfg-if",
  "log",
  "png",
- "tiny-skia-path",
+ "tiny-skia-path 0.12.0",
+]
+
+[[package]]
+name = "tiny-skia-path"
+version = "0.11.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c9e7fc0c2e86a30b117d0462aa261b72b7a99b7ebd7deb3a14ceda95c5bdc93"
+dependencies = [
+ "arrayref",
+ "bytemuck",
+ "strict-num",
 ]
 
 [[package]]
@@ -4485,9 +4589,9 @@ checksum = "fd3ca314f692efd6c868f8408f53fe444634a845f96c028b97d35f6a1f79f0ee"
 
 [[package]]
 name = "tokio"
-version = "1.53.2"
+version = "1.54.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e95f91fcc7a621e8b030f6aa23c71fe9838ae2fb4d8118b75602a328f5144044"
+checksum = "a0c168a474b95bfecfe908a65d4bdffc523144b649a74c09c286afb35d53e0bc"
 dependencies = [
  "pin-project-lite",
 ]
@@ -4575,6 +4679,17 @@ dependencies = [
  "once_cell",
 ]
 
+[[package]]
+name = "tree_magic_mini"
+version = "3.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8765b90061cba6c22b5831f675da109ae5561588290f9fa2317adab2714d5a6"
+dependencies = [
+ "memchr",
+ "nom",
+ "petgraph",
+]
+
 [[package]]
 name = "ttf-parser"
 version = "0.25.1"
@@ -4595,7 +4710,7 @@ dependencies = [
  "http",
  "httparse",
  "log",
- "rand 0.10.3",
+ "rand",
  "sha1",
  "thiserror 2.0.21",
 ]
@@ -4658,9 +4773,9 @@ checksum = "0b993bddc193ae5bd0d623b49ec06ac3e9312875fdae725a975c51db1cc1677f"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.26"
+version = "1.0.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954"
+checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563"
 
 [[package]]
 name = "unicode-properties"
@@ -4731,7 +4846,7 @@ dependencies = [
  "skrifa 0.44.0",
  "strict-num",
  "svgtypes",
- "tiny-skia-path",
+ "tiny-skia-path 0.12.0",
  "unicode-bidi",
  "unicode-script",
  "unicode-vo",
@@ -4752,9 +4867,9 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
 [[package]]
 name = "uuid"
-version = "1.27.0"
+version = "1.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97277d36b9c3ace13e58fa6e753f8b0bbbf302a18dd193240d70f9e29681059a"
+checksum = "7cc1186384beb7dd8eedea376413fd654937285ea6c9cfbb928dc3043ea4b606"
 dependencies = [
  "js-sys",
  "serde_core",
@@ -4871,7 +4986,7 @@ dependencies = [
  "bumpalo",
  "proc-macro2",
  "quote",
- "syn 3.0.6",
+ "syn 3.0.9",
  "wasm-bindgen-shared",
 ]
 
@@ -4886,12 +5001,12 @@ dependencies = [
 
 [[package]]
 name = "wasm-encoder"
-version = "0.261.0"
+version = "0.262.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2608e8bb6d67fd68f5a8d0eb1363d6e7bcbc1f8ded5a0bd3a1e382462b876b22"
+checksum = "4495a6f85dd94c411c749303efcbc5defade0b0cbdbc0541495241ab917a9b5a"
 dependencies = [
  "leb128fmt",
- "wasmparser 0.261.0",
+ "wasmparser 0.262.0",
 ]
 
 [[package]]
@@ -4946,9 +5061,9 @@ dependencies = [
 
 [[package]]
 name = "wasmparser"
-version = "0.261.0"
+version = "0.262.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f20f20e44f7e8aeb6744823ea9d869ede51e51be4fdaedede2852282e54d2d8"
+checksum = "974d643b125b272607e2fff8012ea14a8328acd7621e4bafa7afb32500052b1b"
 dependencies = [
  "bitflags 2.13.2",
  "indexmap",
@@ -4957,9 +5072,9 @@ dependencies = [
 
 [[package]]
 name = "wast"
-version = "261.0.0"
+version = "262.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "776443145731a4062e5b0d392892a2005909b6ab72d9fdc3cad53dd1a714e44a"
+checksum = "30612a0c29249b5f185888a107e8a519d920226b7d07f9d351fd094e9f75eb23"
 dependencies = [
  "bumpalo",
  "leb128fmt",
@@ -4970,9 +5085,9 @@ dependencies = [
 
 [[package]]
 name = "wat"
-version = "1.261.0"
+version = "1.262.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7b4d1a49ea73a8f3326e74e3a05db667001b16bd1035ed3356fc1a0ed05ca7f"
+checksum = "e228027f2b07bbaf946980ebbe2437fca73be6f54c40c2a8d4f42f277075f8d1"
 dependencies = [
  "wast",
 ]
@@ -5150,9 +5265,9 @@ dependencies = [
 
 [[package]]
 name = "webpki-roots"
-version = "1.0.9"
+version = "1.0.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7dcd9d09a39985f5344844e66b0c530a33843579125f23e21e9f0f220850f22a"
+checksum = "1c1c8e20c8a38fc7d65abfe74eb7280e4aa667e8eec8bc84996d2874810748d9"
 dependencies = [
  "rustls-pki-types",
 ]
@@ -5483,7 +5598,7 @@ version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
 dependencies = [
- "windows-targets 0.52.6",
+ "windows-targets",
 ]
 
 [[package]]
@@ -5492,16 +5607,7 @@ version = "0.59.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
 dependencies = [
- "windows-targets 0.52.6",
-]
-
-[[package]]
-name = "windows-sys"
-version = "0.60.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
-dependencies = [
- "windows-targets 0.53.5",
+ "windows-targets",
 ]
 
 [[package]]
@@ -5519,31 +5625,14 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
 dependencies = [
- "windows_aarch64_gnullvm 0.52.6",
- "windows_aarch64_msvc 0.52.6",
- "windows_i686_gnu 0.52.6",
- "windows_i686_gnullvm 0.52.6",
- "windows_i686_msvc 0.52.6",
- "windows_x86_64_gnu 0.52.6",
- "windows_x86_64_gnullvm 0.52.6",
- "windows_x86_64_msvc 0.52.6",
-]
-
-[[package]]
-name = "windows-targets"
-version = "0.53.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
-dependencies = [
- "windows-link",
- "windows_aarch64_gnullvm 0.53.1",
- "windows_aarch64_msvc 0.53.1",
- "windows_i686_gnu 0.53.1",
- "windows_i686_gnullvm 0.53.1",
- "windows_i686_msvc 0.53.1",
- "windows_x86_64_gnu 0.53.1",
- "windows_x86_64_gnullvm 0.53.1",
- "windows_x86_64_msvc 0.53.1",
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
 ]
 
 [[package]]
@@ -5561,96 +5650,48 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
-
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
-
 [[package]]
 name = "windows_i686_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
 
-[[package]]
-name = "windows_i686_gnu"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
-
 [[package]]
 name = "windows_i686_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 
-[[package]]
-name = "windows_i686_gnullvm"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
-
 [[package]]
 name = "windows_i686_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 
-[[package]]
-name = "windows_i686_msvc"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
-
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
-
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
-
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
-
 [[package]]
 name = "winit"
 version = "0.30.13"
@@ -5684,6 +5725,7 @@ dependencies = [
  "raw-window-handle",
  "redox_syscall 0.4.1",
  "rustix 0.38.44",
+ "sctk-adwaita",
  "smithay-client-toolkit 0.19.2",
  "smol_str",
  "tracing",
@@ -5713,9 +5755,9 @@ dependencies = [
 
 [[package]]
 name = "winresource"
-version = "0.1.31"
+version = "0.1.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0986a8b1d586b7d3e4fe3d9ea39fb451ae22869dcea4aa109d287a374d866087"
+checksum = "a2bc6d36480b829272a5bdabf08e6dca8004761c1da7e35efef800540c66221b"
 dependencies = [
  "toml",
  "version_check",
@@ -5727,6 +5769,24 @@ version = "0.57.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"
 
+[[package]]
+name = "wl-clipboard-rs"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d7888ccd4896447b2d14d3a9350a85df2aeb6f181e2e7a31349d104ac46cac1"
+dependencies = [
+ "libc",
+ "log",
+ "os_pipe",
+ "rustix 1.1.5",
+ "thiserror 2.0.21",
+ "tree_magic_mini",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-protocols",
+ "wayland-protocols-wlr",
+]
+
 [[package]]
 name = "write-fonts"
 version = "0.48.1"
@@ -5823,7 +5883,7 @@ checksum = "9440ea3e5aeabb0ac63af70daf835274065238cdd0cec83418f417eae38bacee"
 
 [[package]]
 name = "xtask"
-version = "0.6.0"
+version = "0.10.0"
 dependencies = [
  "figcraft-engine",
  "serde_json",
@@ -5848,7 +5908,7 @@ checksum = "ec8ebde2db3681e8c9980cc27822030e68752690ddfa9473e739aeb4dbde6d71"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.6",
+ "syn 3.0.9",
  "synstructure",
 ]
 
@@ -5920,7 +5980,7 @@ dependencies = [
  "proc-macro-crate",
  "proc-macro2",
  "quote",
- "syn 3.0.6",
+ "syn 3.0.9",
  "zbus_names",
  "zvariant",
  "zvariant_utils",
@@ -5928,9 +5988,9 @@ dependencies = [
 
 [[package]]
 name = "zbus_names"
-version = "4.3.4"
+version = "4.3.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8bf88b4a3ff53e883001e0e0115b297a9d53c31b9c1edd2bfdd853e3428624e"
+checksum = "812a12be4ead7a59e18ea8f047d08add0066b73bc62fc1467066a2472ae088dd"
 dependencies = [
  "serde",
  "winnow",
@@ -5960,18 +6020,18 @@ dependencies = [
 
 [[package]]
 name = "zerocopy"
-version = "0.8.62"
+version = "0.8.63"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86502bf56ac7c77571a32e2647bb2a15894565e981fb2a48d7bde2d91c965a9d"
+checksum = "e5fe1f8f1b06191a00962174c61aa5005e0bb391a6d80d07e24d115c01a92ed8"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.62"
+version = "0.8.63"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5457206954b06561e2608c7e19cf58b1926586d999c246eebe4502f7e2039d1a"
+checksum = "863ad3ac83293fb4d740aedbfdc9240dd8d1a50c1099acd76ce80ce7c7230c7f"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -5995,7 +6055,7 @@ checksum = "f75b4683f6c7f45248d4d64056a24298c6281e0993356d7d1b4a1a962ef10d4a"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.6",
+ "syn 3.0.9",
  "synstructure",
 ]
 
@@ -6035,23 +6095,21 @@ checksum = "34df6fc39dbd26ddc9c10e6a2984476e13acce22e64e4487636ef494369225da"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.6",
+ "syn 3.0.9",
 ]
 
 [[package]]
 name = "zip"
-version = "2.4.2"
+version = "2.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fabe6324e908f85a1c52063ce7aa26b68dcb7eb6dbc83a2d148403c9bc3eba50"
+checksum = "1dcb24d0152526ae49b9b96c1dcf71850ca1e0b882e4e28ed898a93c41334744"
 dependencies = [
  "arbitrary",
  "crc32fast",
  "crossbeam-utils",
- "displaydoc",
  "flate2",
  "indexmap",
  "memchr",
- "thiserror 2.0.21",
  "zopfli",
 ]
 
@@ -6069,9 +6127,9 @@ checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"
 
 [[package]]
 name = "zopfli"
-version = "0.8.3"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f05cd8797d63865425ff89b5c4a48804f35ba0ce8d125800027ad6017d2b5249"
+checksum = "aaf7fc5d30c28483d93805c4a5e12b05bbb52407fa67c5f8bd552374cd01fb11"
 dependencies = [
  "bumpalo",
  "crc32fast",
@@ -6096,9 +6154,9 @@ dependencies = [
 
 [[package]]
 name = "zvariant"
-version = "5.15.0"
+version = "5.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1d34c27cc6cdd1f458427519dd6b8612f7b7e3f7b9a0b2355d041dda9869147"
+checksum = "80bf6d6cd6a4b601acb64cfb8284cdc643fcfa75ef26ae3c46ec8aa4e8a1fbb7"
 dependencies = [
  "endi",
  "enumflags2",
@@ -6111,14 +6169,14 @@ dependencies = [
 
 [[package]]
 name = "zvariant_derive"
-version = "5.15.0"
+version = "5.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "864155e69b4352db0c7f374917bf45d1e0c8d17659c8b3dbf9795f3673f8c497"
+checksum = "ef2672456ba1cb54b5eaec136e63135b3c7495fb938e53b28a62e633496d486d"
 dependencies = [
  "proc-macro-crate",
  "proc-macro2",
  "quote",
- "syn 3.0.6",
+ "syn 3.0.9",
  "zvariant_utils",
 ]
 
@@ -6131,6 +6189,6 @@ dependencies = [
  "proc-macro2",
  "quote",
  "serde",
- "syn 3.0.6",
+ "syn 3.0.9",
  "winnow",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 8f125ac3e..90297f296 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -6,7 +6,7 @@ exclude = ["plugins"]
 # default-members = ["crates/*", "apps/figcraft", "apps/figcraft-cli", "xtask"]
 
 [workspace.package]
-version = "0.6.0"
+version = "0.10.0"
 edition = "2024"
 license = "MIT OR Apache-2.0"
 rust-version = "1.95"
@@ -32,6 +32,12 @@ figcraft-mcp = { path = "crates/mcp" }
 figcraft-collab-net = { path = "crates/collab-net" }
 figcraft-plugin = { path = "crates/plugin" }
 
+# Which paths stored in a document may be followed (craft-libs).
+craft-docpath = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "82a24b006eefa036b43c09a67fb9a3fbd17ffe63" }
+# Who draws the window frame on Linux — the compositor or the app — so every Craft app shows the
+# same native titlebar per desktop (craft-libs). The `egui` feature adds `decorate`/`decorations`.
+craft-window = { git = "https://github.com/storytold/craft-libs", rev = "1f805378d454dac48b5c214029d254055fdf961b", features = ["egui"] }
+
 # foundation
 kurbo = { version = "0.13", features = ["serde"] }
 thiserror = "2"
@@ -39,6 +45,8 @@ serde = { version = "1", features = ["derive", "rc"] }
 serde_json = { version = "1", features = ["float_roundtrip"] }
 regex = "1.13"
 log = "0.4"
+# All date/time conversion goes through chrono (no hand-rolled calendar code beyond the 400-year range extension; AGENTS.md).
+chrono = { version = "0.4.45", default-features = false, features = ["std"] }
 proptest = "1"
 imbl = { version = "7", features = ["serde"] }
 postcard = { version = "1", default-features = false, features = ["alloc"] }
@@ -95,11 +103,15 @@ todo = "deny"
 unimplemented = "deny"
 unreachable = "deny"
 
-[profile.dev.package."*"]
-opt-level = 2
-
+# Workspace crates keep file:line in panic backtraces; dependencies carry no debug info. Both make
+# the test build faster and the target dir smaller.
 [profile.dev]
 opt-level = 1
+debug = "line-tables-only"
+
+[profile.dev.package."*"]
+opt-level = 2
+debug = false
 
 [profile.release]
 lto = "thin"
diff --git a/NOTICE b/NOTICE
index 9aaba825b..a0baaa279 100644
--- a/NOTICE
+++ b/NOTICE
@@ -20,3 +20,34 @@ licence texts.
 Rust crate dependencies keep their own licenses (MIT, Apache-2.0, BSD, ISC, Zlib, OFL for egui's
 default fonts, CDLA-Permissive-2.0 for the root certificate list webpki-roots compiles in, and
 similar permissive licenses); see each crate's metadata.
+
+Linux Wayland window decorations
+-------------------------------
+sctk-adwaita 0.10.1 (https://github.com/PolyMeilex/sctk-adwaita,
+commit d5f343c45c04d4a026db57f76760819b7325db00) is used by winit on Linux
+for vector window controls. Its title-font features are disabled: no Cantarell
+font is embedded by this dependency and no font file is added to this repo.
+
+sctk-adwaita's MIT licence:
+
+MIT License
+
+Copyright (c) 2022 Bartłomiej Maryńczak
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/README.md b/README.md
index 0910bf9e7..ebbf7fa03 100644
--- a/README.md
+++ b/README.md
@@ -7,10 +7,14 @@
   </a>
 </p>
 
+<p align="center">
+  <img src="assets/app-icon/hicolor/256x256/apps/ai.storyteller.figcraft.png" width="128" height="128" alt="FigCraft icon: an engraved chameleon on a mint-green tile">
+</p>
+
 <h1 align="center">FigCraft</h1>
 
 <p align="center">
-  <b>Interface design; an open-source, clean-room reimplementation of Figma, rebuilt in pure Rust.</b><br>
+  <b>Interface design and prototyping: open source, collaborative and built in pure Rust.</b><br>
   Frames, auto layout, components and variants, vector networks, styles, variables and prototypes,<br>
   in a native app that opens instantly and works offline. Open source, and yours.
 </p>
@@ -20,6 +24,9 @@
   <img alt="macOS · Windows · Linux · FreeBSD · Web" src="https://img.shields.io/badge/macOS%20%C2%B7%20Windows%20%C2%B7%20Linux%20%C2%B7%20FreeBSD%20%C2%B7%20Web-native-0EA5C6?style=flat-square">
   <img alt="License: MIT OR Apache-2.0" src="https://img.shields.io/badge/license-MIT%20%2F%20Apache--2.0-3a3a3a?style=flat-square">
   <img alt="Status: early alpha" src="https://img.shields.io/badge/status-early%20alpha-d69e2e?style=flat-square">
+  <br>
+  <a href="https://sonarcloud.io/project/overview?id=storytold_figcraft"><img alt="Scanned by SonarCloud" src="https://img.shields.io/badge/Scanned_by-SonarCloud-4b9fd5?style=flat-square&logo=sonarqubecloud&logoColor=white"></a>
+  <a href="https://coderabbit.ai"><img alt="Reviewed by CodeRabbit" src="https://img.shields.io/coderabbit/prs/github/storytold/figcraft?style=flat-square&label=Reviewed%20by%20CodeRabbit&logo=coderabbit"></a>
 </p>
 
 <p align="center">
@@ -62,7 +69,7 @@
   <tr>
     <td width="25%" valign="top">
       <h3>🎛️ Familiar by design</h3>
-      The toolbar, layers panel, Design panel, menus and shortcuts sit where your hands expect them. If you know Figma, you already know FigCraft.
+      The toolbar, layers panel, Design panel, menus and shortcuts sit right where your hands expect them.
     </td>
     <td width="25%" valign="top">
       <h3>⚡ Native and fast</h3>
@@ -227,8 +234,8 @@ The desktop app also offers a loopback-only control channel (`figcraft --control
 - **Its own renderer:** tiny-skia on every core for the canvas and exports, with layer blending, effects and masks; booleans from linesweeper, geometry from kurbo, text from skrifa and HarfRust.
 - **Runs in the browser:** the whole engine and UI compile to WebAssembly.
 - **Accessible:** screen readers get names, roles, values and states for the tools, layer rows, fields, dropdowns, tabs and menus (AccessKit on desktop), F6 moves the keyboard between the toolbar, layers, canvas and properties (Tab within them, Escape back to the canvas), the system's reduce-motion setting is honoured, and panel text meets WCAG AA contrast in both themes.
-- **Languages:** English, Russian and Turkish (reviewed by native speakers), and Spanish, French, German, Brazilian Portuguese, Japanese, Korean, Simplified Chinese, Czech and Indonesian drafts, picked in Preferences or taken from the system or browser and switched live; adding a language is one catalog file ([`docs/translating.md`](docs/translating.md)).
-- **Plugins:** sandboxed WebAssembly plugins (a metered, pure-Rust interpreter with a memory cap and no file or network access, in the browser too) that act through the same commands, each run one undo step, within the permissions their manifest asks for. A Rust SDK and two example plugins are in [`plugins/`](plugins); see [`docs/plugins.md`](docs/plugins.md).
+- **Languages:** English, Russian and Turkish (reviewed by native speakers), and Spanish, French, German, Brazilian Portuguese, Japanese, Korean, Simplified Chinese, Czech, Indonesian and Georgian drafts, picked in Preferences or taken from the system or browser and switched live; adding a language is one catalog file ([`docs/translating.md`](docs/translating.md)).
+- **Plugins:** sandboxed WebAssembly plugins (a metered, pure-Rust interpreter with a memory cap and no file or network access, in the browser too) that act through the same commands, each run one undo step, within the permissions their manifest asks for. A Rust SDK and three example plugins are in [`plugins/`](plugins); see [`docs/plugins.md`](docs/plugins.md).
 - **Live sessions (preview):** share the open file from the app (Share ▸ Start sharing: online through a server, or on your local network), give the others the short join code it shows (or the invite link), and edit it together: everyone's changes sync live, with cursors, selections, avatars and follow, and undo takes back only your own changes. Others join from the desktop app (invite links open it) or from the browser build. See [`docs/collab-protocol.md`](docs/collab-protocol.md).
 - **A server of your own (preview):** `figcraft-server` keeps a team's files, publishes them from the app (File ▸ Publish to server…, or Share ▸ Online with your server in Preferences) and hands out share links and join codes that let people edit or only view; files survive restarts and apps reconnect where they were. No accounts yet: links are the access. Releases ship it for Linux, and the desktop app joins over `wss://`; [hosting it on a rented Linux server](docs/server.md#deploy-on-a-linux-server) takes a systemd unit and Caddy or nginx (or Docker). See [`docs/server.md`](docs/server.md).
 - **Never crashes:** no `unwrap`, `expect` or `panic` in shipped code, enforced by clippy; commands run behind a guard so a bug fails one action, not your session.
@@ -262,7 +269,7 @@ New contributors and AI agents: start with [`AGENTS.md`](AGENTS.md), then [`docs
 Installers for macOS (universal, signed and notarized), Windows (x64, x86 and arm64), Linux (AppImage, `.deb`, `.rpm`, Flatpak and tarball), FreeBSD and the web are attached to each [GitHub release](https://github.com/storytold/figcraft/releases). Maintainers: [`docs/releasing.md`](docs/releasing.md) explains how releases are built, signed and published.
 
 > [!IMPORTANT]
-> **Status:** FigCraft is in **alpha**: about 49% of the way to replacing Figma for real work, by our own estimate. Nearly all of Figma's main menu is wired ([`docs/parity-checklist.md`](docs/parity-checklist.md)) and the core editor works end to end, but FigCraft opens `.fig` files only best effort, has only a first preview of multiplayer (live sessions hosted from the app or a self-hosted server, with per-person undo and share links to edit or to view; no accounts, teams or cloud yet), runs its own WebAssembly plugins rather than Figma's, and hasn't been checked against real Figma documents. The honest, area-by-area picture is in the [roadmap](ROADMAP.md) and [`docs/target-app-parity.md`](docs/target-app-parity.md). Expect rough edges and please file issues, or tell us what broke on [Discord](https://discord.gg/artcraft).
+> **Status:** FigCraft is in **alpha**: about 49% of the way to replacing proprietary tools for real work, by our own estimate. Nearly all tracked interface design actions in the menu checklist are wired ([`docs/parity-checklist.md`](docs/parity-checklist.md)) and the core editor works end to end, but FigCraft opens `.fig` files only best effort, has only a first preview of multiplayer (live sessions hosted from the app or a self-hosted server, with per-person undo and share links to edit or to view; no accounts, teams or cloud yet), runs its own WebAssembly plugins, and hasn't been checked against real design documents. The honest, area-by-area picture is in the [roadmap](ROADMAP.md) and [`docs/target-app-parity.md`](docs/target-app-parity.md). Expect rough edges and please file issues, or tell us what broke on [Discord](https://discord.gg/artcraft).
 
 ## Privacy and online sharing
 
@@ -348,8 +355,6 @@ ArtCraft Team and are not covered by this license. They may be used only unmodif
 part of this repository and FigCraft, under [`docs/brand/LICENSE-brand.txt`](docs/brand/LICENSE-brand.txt).
 Forks and modified versions must remove them.
 
-<sub>Figma is a trademark of Figma, Inc. FigCraft is an independent, open-source project and is not affiliated with, sponsored by or endorsed by Figma, Inc.; the name is used only to describe the workflows FigCraft is compatible with.</sub>
-
 <p align="center">
   <a href="https://getartcraft.com/"><img alt="ArtCraft" src="https://raw.githubusercontent.com/storytold/vectorcraft/main/docs/brand/artcraft-mark.png" width="28"></a><br>
   <sub>Made by the <a href="https://getartcraft.com/">ArtCraft</a> team and community.</sub>
diff --git a/ROADMAP.md b/ROADMAP.md
index bff59ddd5..d32eb906c 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -2,7 +2,7 @@
 
 **Stage: alpha** · next: beta, ~26 points and ~162–292 h away (one Opus 5.5 agent; ~33–67 h wall-clock with 5 agents)
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-15 · **Change:** minor (bounded canvas pan overscan; files dropped anywhere on the window open from the home screen or import onto the canvas; Typography spacing icons support scrubbing (#373); system theme on first run; recent files as cards with thumbnails on the home screen; community fixes: lost images reported on loading (#207), SVG import budgets (#190), Leptos code (#223), full screen (#227), server snapshots readable again (#188), owner-only preferences (#200), ruzstd 0.9.1 (#182), layer cycle repair (#205), batch rollback, Direct3D 12 on Windows, plugin metering (#192); vector edit mode regions: hover hatch, selection and drag; SVG/PDF exports refuse over-depth documents (#208); bounded MCP/control framing, connections and queues (#201); plugin log limits (#191); live-session revert guard (#198); attached MCP no longer replays after a lost reply (#194); repeat command recursion fix; the Layout panel's constrain-proportions link scales the other side, #220; core editor leftovers: component playground, auto gap handles, variables inside styles, inner shadows and background blur on groups, command-made text readable on dark pages, a one-step frame/group convert, delays on mouse triggers and manual overlay offsets, wrapped-line alignment; `.fig` export: instance sizes, variables with modes, shared styles, variable-width strokes; starter templates, a Templates tab and Getting started tips on the home screen; your online files; everyday editing partials: number fields, outline options, Hide when publishing, cursors, panel widths, dark pages; sharing with a join code; text box sizes measured against documents re-saved by other software; live sessions per document; .fig export checked by opening written files in other software; a public figcraft-server: open hosting, owner tokens, per-address limits, idle expiry, moderation, install.sh; experimental .fig export; keyboard shortcut parity suite and bindings; Simplified Chinese draft catalog; Latin American Spanish overlay; prototyping tail: gamepad triggers, widgets in prototypes, mode lookups; plugin directory on figcraft-server; Japanese and Korean draft catalogs and CJK UI fonts; plugin widgets and the plugin panel tail; French, German and Brazilian Portuguese draft catalogs; cursor chat and spotlight in live sessions; layers and assets panels behaviour suite and fixes; vector multi-edit and edit tail; dev resources links; extended collections tail; branch version history and finer list merges; headline percentages recomputed from the area table: feature breadth ~84%, core ~94%, mainstream ~50%; text lists, hanging punctuation and decoration styles; comments and version history behaviour suite and fixes; canvas navigation, guides and grids behaviour suite and fixes; export and inspect behaviour suite and fixes; .fig import: editable vector networks and more layer kinds; shapes and vector behaviour suite and fixes; paint and effects behaviour suite and fixes; frames, groups, sections and masks behaviour suite and fixes; styles and variables behaviour suite and fixes; prototyping behaviour suite and fixes; components behaviour suite and fixes; embedded image colour profiles; layers panel keyboard: F2 rename, Shift+F10 context menu, keyboard box selection, 10k-layer QA; per-side stroke weight variables; text behaviour suite: CJK line breaking, metrics, vertical trim; selection and transform behaviour suite and fixes; `.fig` import, best effort; Windows QA pass with eight fixes; auto layout behaviour suite and fixes; Display P3: gamut warning and soft-proof (true P3 blocked upstream); several windows; localization layer with a draft Spanish catalog; hosting figcraft-server: wss in the desktop app, server releases, deployment guide; plugin panels and settings; canvas fixes: boolean hit testing on the result, group drags, frame outlines and slices; code connect; stretch and scatter brushes, pen pressure; text on a path and pattern fills; team libraries on the server and swap library; branches: create, update from main, review and merge; animated GIF fills and TIFF images; Open recent, outlines for the selection and mask outlines: menu breadth 100%; extended collections, variables import/export, gradient stop and variant bindings; feature breadth ~80%; ready ~49%) · **Target:** Figma Design (desktop app 126.10.7)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-22 · **Change:** minor (boards: a board area row and progress entry; `fill`/`stroke` props accept `"none"` and `null` as no paint (#1036); community batch #753: Selection colors, smart-selection spacing, a Present tab; language table re-measured from the catalogs; community fixes from #524 up (55 PRs: `.fig` import fidelity, paste from other apps, the Actions palette, editor fixes, server limits) and a boolean-op crash guard; number variables in the text content picker (#629); frames and sections convert into each other (#719); bounded canvas pan overscan; community fixes from #478 up and a control-channel fix (#589); bounded canvas pan overscan; Typography spacing icons support scrubbing (#373); font scans skip named pipes; system theme on first run; recent files as cards with thumbnails on the home screen; community fixes: lost images reported on loading (#207), SVG import budgets (#190), Leptos code (#223), full screen (#227), server snapshots readable again (#188), owner-only preferences (#200), ruzstd 0.9.1 (#182), layer cycle repair (#205), batch rollback, Direct3D 12 on Windows, plugin metering (#192); vector edit mode regions: hover hatch, selection and drag; SVG/PDF exports refuse over-depth documents (#208); bounded MCP/control framing, connections and queues (#201); plugin log limits (#191); live-session revert guard (#198); attached MCP no longer replays after a lost reply (#194); repeat command recursion fix; the Layout panel's constrain-proportions link scales the other side, #220; core editor leftovers: component playground, auto gap handles, variables inside styles, inner shadows and background blur on groups, command-made text readable on dark pages, a one-step frame/group convert, delays on mouse triggers and manual overlay offsets, wrapped-line alignment; `.fig` export: instance sizes, variables with modes, shared styles, variable-width strokes; starter templates, a Templates tab and Getting started tips on the home screen; your online files; everyday editing partials: number fields, outline options, Hide when publishing, cursors, panel widths, dark pages; sharing with a join code; text box sizes measured against documents re-saved by other software; live sessions per document; .fig export checked by opening written files in other software; a public figcraft-server: open hosting, owner tokens, per-address limits, idle expiry, moderation, install.sh; experimental .fig export; keyboard shortcut parity suite and bindings; Simplified Chinese draft catalog; Latin American Spanish overlay; prototyping tail: gamepad triggers, widgets in prototypes, mode lookups; plugin directory on figcraft-server; Japanese and Korean draft catalogs and CJK UI fonts; plugin widgets and the plugin panel tail; French, German and Brazilian Portuguese draft catalogs; cursor chat and spotlight in live sessions; layers and assets panels behaviour suite and fixes; vector multi-edit and edit tail; dev resources links; extended collections tail; branch version history and finer list merges; headline percentages recomputed from the area table: feature breadth ~84%, core ~94%, mainstream ~50%; text lists, hanging punctuation and decoration styles; comments and version history behaviour suite and fixes; canvas navigation, guides and grids behaviour suite and fixes; export and inspect behaviour suite and fixes; .fig import: editable vector networks and more layer kinds; shapes and vector behaviour suite and fixes; paint and effects behaviour suite and fixes; frames, groups, sections and masks behaviour suite and fixes; styles and variables behaviour suite and fixes; prototyping behaviour suite and fixes; components behaviour suite and fixes; embedded image colour profiles; layers panel keyboard: F2 rename, Shift+F10 context menu, keyboard box selection, 10k-layer QA; per-side stroke weight variables; text behaviour suite: CJK line breaking, metrics, vertical trim; selection and transform behaviour suite and fixes; `.fig` import, best effort; Windows QA pass with eight fixes; auto layout behaviour suite and fixes; Display P3: gamut warning and soft-proof (true P3 blocked upstream); several windows; localization layer with a draft Spanish catalog; hosting figcraft-server: wss in the desktop app, server releases, deployment guide; plugin panels and settings; canvas fixes: boolean hit testing on the result, group drags, frame outlines and slices; code connect; stretch and scatter brushes, pen pressure; text on a path and pattern fills; team libraries on the server and swap library; branches: create, update from main, review and merge; animated GIF fills and TIFF images; Open recent, outlines for the selection and mask outlines: menu breadth 100%; extended collections, variables import/export, gradient stop and variant bindings; feature breadth ~80%; ready ~49%) · **Target:** Figma Design (desktop app 126.10.7)
 
 FigCraft is a clean-room, open-source, pure-Rust reimplementation of the Figma design workflow,
 native on macOS, Windows, Linux and FreeBSD and in the browser, fully drivable by agents through
@@ -13,7 +13,7 @@ start with [`docs/gaps.md`](docs/gaps.md).
 
 | | Value | Kind |
 |---|---|---|
-| Menu/command breadth | **100%** (211 / 211) | measured, [`docs/parity-checklist.md`](docs/parity-checklist.md) (`cargo xtask parity`) |
+| Menu/command breadth | **100%** (212 / 212) | measured, [`docs/parity-checklist.md`](docs/parity-checklist.md) (`cargo xtask parity`) |
 | Feature breadth | **~85%** (core editor ~94%) | estimated, [`docs/target-app-parity.md`](docs/target-app-parity.md) |
 | Ready for real work | **~53%** | estimated, same doc (written dimension weights and scores) |
 | Essentials user | **~59%** | estimated: core features 77.8% × 0.92 launch/stability × 0.94 discoverability × 0.88 opening files people send ([method](docs/target-app-parity.md#essentials-user)) |
@@ -50,7 +50,7 @@ against real Figma documents. Ready-for-real-work is ~53%, inside alpha's ~40–
 ~75% **and** reliable `.fig` import: the `.fig` import's tail (5–10 h), a real-file corpus with measured
 fidelity (15–30 h), the interaction pass (25–40 h of the 40–60), core depth to ~80% (40–75 h),
 basic multiplayer on the landed core (30–55 h), stability and platform QA (20–40 h), a partial GPU path (15–30 h);
-native speakers' reviews of the six language drafts need people.
+native speakers' reviews of the nine language drafts need people.
 
 ## By dimension
 
@@ -63,7 +63,7 @@ native speakers' reviews of the six language drafts need people.
 | Stability | 55% | 20–40 | [gaps](docs/gaps.md) |
 | Performance | 60% | 30–60 | [hardware-parity](docs/hardware-parity.md) |
 | Hardware | 60% | 10–21 | [hardware-parity](docs/hardware-parity.md) |
-| Localization | 39% (layer; English; Spanish with a Latin American overlay, French, German, Brazilian Portuguese, Japanese, Korean, Simplified Chinese drafts; CJK UI fonts) | 29–51 | [localization-parity](docs/localization-parity.md) |
+| Localization | 39% (layer; English; Russian and Turkish reviewed by native speakers; Spanish with a Latin American overlay, French, German, Brazilian Portuguese, Japanese, Korean, Simplified Chinese, Indonesian and Czech drafts; CJK UI fonts) | 29–51 | [localization-parity](docs/localization-parity.md) |
 | Platforms | 75% | 10–20 | [hardware-parity](docs/hardware-parity.md) |
 | Ecosystem / plugins | 38% (own WASM plugins with panels, settings and widgets; a self-hosted plugin directory) | 8–26 | [gaps](docs/gaps.md) |
 | AI features | 0% | 30–60 | [gaps](docs/gaps.md) |
@@ -86,38 +86,39 @@ native speakers' reviews of the six language drafts need people.
 | Styles & variables | 95% | 76% | 2–4 | [components-parity](docs/components-parity.md) |
 | Prototyping | 92% | 74% | 2–5 | [prototyping-parity](docs/prototyping-parity.md) |
 | Import/export | 86% | 58% | 5–10 | [file-format-parity](docs/file-format-parity.md) |
-| Dev Mode / inspect | 96% | 72% | 0–1 | [dev-mode-parity](docs/dev-mode-parity.md) |
+| Dev Mode / inspect | 97% | 76% | 2–4 | [dev-mode-parity](docs/dev-mode-parity.md) |
 | Comments, versions, misc | 87% | 63% | 1–3 | [collaboration-parity](docs/collaboration-parity.md) |
 | Multiplayer & sharing | 17% | 5% | 42–84 | [collaboration-parity](docs/collaboration-parity.md) |
 | Plugins & widgets | 60% | 35% | 8–26 | [plugins](docs/plugins.md) |
 | Team libraries | 70% | 40% | 4–8 | [components-parity](docs/components-parity.md) |
 | Figma Draw extras | 88% | 60% | 1–3 | [gaps](docs/gaps.md) |
 | AI features | 0% | 0% | 30–60 | [gaps](docs/gaps.md) |
+| Boards (whiteboarding; not in the weighted numbers) | ~35% | ~20% | 30–60 | [boards-parity](docs/boards-parity.md) |
 
 ## Languages
 
 | Language | Code | Strings | Status |
 |---|---|---|---|
 | English | en | 100% | full |
-| Simplified Chinese | zh-Hans | 100% | draft (needs native review) |
-| Spanish | es, es-419 | 100% (es-419: an overlay of 98 entries) | draft (needs native review) |
+| Simplified Chinese | zh-Hans | 95% | draft (needs native review) |
+| Spanish | es, es-419 | 100% (es-419: an overlay of 101 entries) | draft (needs native review) |
 | Hindi | hi | 0% | none |
 | Arabic | ar | 0% | none |
-| French | fr | 100% | draft (needs native review) |
-| Portuguese (Brazil) | pt-BR | 100% | draft (needs native review) |
-| Indonesian | id | 0% | none |
-| Japanese | ja | 100% | draft (needs native review) |
-| German | de | 100% | draft (needs native review) |
-| Korean | ko | 100% | draft (needs native review) |
+| French | fr | 95% | draft (needs native review) |
+| Portuguese (Brazil) | pt-BR | 95% | draft (needs native review) |
+| Indonesian | id | 99% | draft (needs native review) |
+| Japanese | ja | 99% | draft (needs native review) |
+| German | de | 96% | draft (needs native review) |
+| Korean | ko | 95% | draft (needs native review) |
 | Vietnamese | vi | 0% | none |
 
-Also shipped: Swedish (`sv`: every UI string, 120 of 588 command labels and menu wordings; native review welcome). Figma ships English, Japanese, Korean, French, German, Spanish and Portuguese
+Percentages measured 2026-10-17 over 2,272 entries (strings added since a draft show English). Also shipped: Russian (`ru`, 99%, reviewed by VanTan), Swedish (`sv`, 99.6%, command labels since 2026-10-17; native review welcome), Turkish (`tr`, 99%) and Czech (`cs`, 99%, draft). Figma ships English, Japanese, Korean, French, German, Spanish and Portuguese
 (Brazil); FigCraft has the localization layer, English and Spanish (Spain and Latin America),
-French, German, Brazilian Portuguese, Japanese, Korean and Simplified Chinese drafts (Preferences ▸
+French, German, Brazilian Portuguese, Japanese, Korean, Simplified Chinese and Indonesian drafts (Preferences ▸
 Language; Traditional Chinese has no catalog; CJK UI
 text uses an installed CJK font, loaded only when needed; adding a language:
 [`docs/translating.md`](docs/translating.md)). Document text in any script (bidi, Arabic shaping,
-IME) already works. Detail: [`docs/localization-parity.md`](docs/localization-parity.md).
+IME) already works (macOS IME composition fixed for #747, not yet checked on a Mac). Detail: [`docs/localization-parity.md`](docs/localization-parity.md).
 
 ## Upcoming
 
@@ -126,11 +127,25 @@ Ranked; detail and milestones in [`docs/roadmap.md`](docs/roadmap.md).
 1. `.fig` import's tail: fixes from real files, connector labels, table cells, filled areas with their own fills (the best-effort import, editable vector networks, the other layer kinds and variable prototype actions landed 2026-10-11): 5–10 h; then checking the rest of the experimental `.fig` export (landed 2026-10-12; written files open and draw in other software) on effects, images, prototypes and real files: 5–15 h.
 2. Real-file corpus and measured fidelity: 15–30 h.
 3. Tool-by-tool interaction pass against Figma: 40–60 h.
-4. Languages: native reviews of the es, fr, de, pt-BR, ja and ko drafts (people), Latin American Spanish (1–2 h), then Simplified Chinese (3–5 h).
+4. Languages: native reviews of the es (with es-419), fr, de, pt-BR, ja, ko, zh-Hans, id and cs drafts (people), the entries added since each catalog was written, then Hindi, Vietnamese and Arabic ([localization-parity](docs/localization-parity.md)).
 5. Multiplayer (M9): accounts and teams on top of the live sessions and the standalone server (transport, hosting, invite links that open the app, document sync, presence with remote text carets, cursor chat and spotlight, per-user undo, reconnect with offline edits, collision-free ids for styles, variables and comments, the browser client, `figcraft-server` with persistence and share links to edit or view, team libraries on the server landed): 42–84 h.
 
 ## Progress log
 
+- **2026-10-24** · Boards (M12): File ▸ New board makes a board, a file kind of its own saved in `.figcraft` and carried to people joining a live session. Sticky notes (8 colours, text that shrinks as the note grows, the author's name, Shift+Cmd/Ctrl+Enter for the next one), shapes with text (7 outlines), connectors that re-route when what they join moves (computed in the engine's normalize pass, so local edits, undo and others' edits agree), marker, highlighter and eraser, stamps with the placer's name on hover; a board toolbar, a contextual bar over the selection and the Design panel hidden until asked for; prototyping and Dev Mode refuse on boards. Design files and boards have their own marks (a pen nib, a note) on tabs, the home screen and the Open files list. Checked in the app, with two app instances in one live session, and through MCP; the web build compiles ([boards-parity](docs/boards-parity.md)).
+- **2026-10-15** · Auto-save (M1, #305): Preferences ▸ Save files automatically (`pref.autoSave`, off by default, desktop only) saves each open file that has a path 3 s after its last change, never during a gesture, a live text preview or while a version is shown; the file is encoded off the UI thread, a failed save says why and is tried again a minute later. Numbers unchanged.
+- **2026-10-15** · A text box by dragging (M1, #363): a drag with the Text tool makes a fixed-size text box the size of the drag; a click still makes auto-width text. Numbers unchanged.
+- **2026-10-15** · Batch step references (M0.9, #400): a `command.batch` step can use the id an earlier step made (`{"$step": n}`, a reserved key), so a nested tree takes one call and one undo step. Numbers unchanged.
+- **2026-10-15** · Removing someone from a live session (M9, #338): the host or the file's owner removes a person from the avatar's menu or with `collab.removePerson`; they keep their copy and can't rejoin while the session runs. Numbers unchanged.
+- **2026-10-15** · Languages (M10, #257, #263, #469, #477, #288): Russian (one/few/many plurals) and Turkish catalogs reviewed by native speakers, Czech and Indonesian drafts, the Japanese draft completed; Preferences ▸ Language lists 12 languages and Latin American Spanish. Numbers unchanged.
+- **2026-10-15** · Zoom previews (M8, #312): when renders from scratch are slow, a new zoom shows the whole view coarsely first, then refines it. Numbers unchanged.
+- **2026-10-15** · Web clipboard (M1, #375): copy and paste in the browser go through the system clipboard. Numbers unchanged.
+- **2026-10-15** · Alt-drag copies snap to their original and Duplicate (Cmd+D) repeats the last copy's offset (M1, #283). Numbers unchanged.
+- **2026-10-22** · `fill` and `stroke` props accept `"none"` and `null` (M1, #1036): `node.create`, `node.set` and the other prop appliers map them to an empty fills/strokes list, as `fills: []` already did, so an outline-only shape is one call (agents write `"none"` for no paint; the empty-list form was undocumented). The parameter docs (`KEYS`, shown by `list_commands` and the CLI) and `docs/mcp.md` say so, and the error message names the accepted forms. `fill_none_tests` covers create, set, undo, text and the error. Numbers unchanged.
+- **2026-10-17** · Control channel while the window is minimised (M8, #720): a minimised or covered window answers every request that acts on the app's state (edits, `ui.inspect`, `ui.pointer`, `ui.key`, `ui.type`, `ui.set`, `app.quit`…) without drawing, and what needs a drawn frame (`ui.screenshot`, `ui.input`, `window.new`) is an error at once; before, those waited up to 60 s and held up every later request on the connection (an attached agent's `inspect_ui` or window screenshot stalled until the window came back). Measured on Windows 11, minimised: requests ~100 ms each (eframe wakes a minimised window at most ten times a second; ~2 ms on screen), a window screenshot fails in ~100 ms instead of 60 s, idle CPU 0. Numbers unchanged.
+- **2026-10-17** · Number variables on text content (M3, #629): the Typography section's variable picker also lists number variables for a text layer's content, as the engine already accepted (the text shows the number, e.g. 42.5, and follows the variable). Other text fields keep their own types. Numbers unchanged.
+- **2026-10-17** · Frames and sections convert into each other (M1, #719): `object.convertToSection` turns a frame on the page or in a section into a section in place (same box, name, fill and layers, which stay where they are; what only a frame has goes: auto layout, clipping, layout grids, guides, scrolling), and `object.convertToFrame` now also turns a section into a frame that keeps its fill and doesn't clip, so the look stays. Nested frames, instances, main components and sections holding sections are refused with the reason; one undo step each. Both are in the canvas context menu (Convert to section / Convert to frame) and in Spanish. Numbers unchanged.
+- **2026-10-15** · Dev Mode tail (M6, gap 16): generated layer trees start with the import lines of the connected components they call, once each per language; Compare changes takes any saved version as the before; a behaviour suite made the Dev Mode canvas inspect-only (no moving, resizing, drawing or editing; menus and shortcuts refuse design edits with a note), added Changed to the ready list and refused statuses on layers inside frames; read-only plugins show their panels from the Inspect tab. Dev Mode 97% / 76%.
 - **2026-10-14** · Corner handles win over the corner-radius handles (M1, #292): a press on the inner half of a corner handle's square picked the radius handle 10 px in, so the drag neither resized nor (dragging outward) rounded anything. Inside the drawn square the corner now resizes both sides (in ratio with Shift or the link); further in the radius handle still answers. Regression test in the transform behaviour suite. Numbers unchanged.
 - **2026-10-14** · Home screen recent files as cards (M7): each card shows the picture its file carries on its first page's colour, the file's icon, name and "Edited ... ago"; sort by name, creation or last change either way; a table view; a click selects, a double-click or Enter opens, arrow keys move; Open, Show in folder and Remove from recents on right-click. Numbers unchanged.
 - **2026-10-13** · Vector edit mode regions (M4): with the Move tool, the filled area under the pointer is hatched with "/" lines in the selection colour, clipped by the area's own fill rule so holes stay clear; the hatch goes near points (3.5 px) and segments (2 px), and its spacing follows octave folding (8 px at every power-of-two zoom), fixed to the shape. A click selects the area with its points (they move with it but keep the unselected look), Shift adds or removes one, a press on a selected area drags the whole selection as one undo step, and a click on an empty spot clears the areas and stays in edit mode. `vector.edit.select {regions}` and `vector.edit.state` (`regions`, `regionVertices`, `regionHover`); `vector_regions_tests` and `regions_tests`. Numbers unchanged.
@@ -313,9 +328,74 @@ Ranked; detail and milestones in [`docs/roadmap.md`](docs/roadmap.md).
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-24 | minor | Boards (M12): a file kind of its own (`file.newBoard`, saved in `.figcraft`, carried to live-session joiners) with sticky notes, shapes with text, connectors that re-route when what they join moves (an engine recompute, the same for local edits, undo and others' edits), marker, highlighter and eraser, stamps with the placer's name, a board toolbar and a contextual bar; prototyping and Dev Mode refuse on boards; design files and boards have their own marks on tabs and file rows. Boards row added outside the weighted numbers; headline numbers unchanged at this rounding |
+| 2026-10-15 | minor | Auto-save (#305, #296): Preferences ▸ Save files automatically (`pref.autoSave`, off by default; desktop only, the browser has no files to save to) saves each open file that has a path 3 s after its last change, so steady editing doesn't save every few seconds, and never during a gesture, a live text preview or while a version is shown. The file is encoded on a thread of its own and written as of that moment (edits made meanwhile stay unsaved); a failed save says why in a toast and is tried again a minute later, and version history checkpoints keep coming with it on. Numbers unchanged |
+| 2026-10-15 | minor | A text box by dragging (#363, #360): a drag with the Text tool makes a fixed-size text box the size of the drag (at least one line tall); a click, or a drag shorter than the drag threshold, still makes auto-width text. Numbers unchanged |
+| 2026-10-15 | minor | Batch step references (#400): inside `command.batch` (MCP `batch`), `{"$step": n}` anywhere in a step's params stands for the `id` step n returned (`{"$step": n, "field": …}` for another field; `$step` is a reserved key), so a frame with its children takes one batch and one undo step; a malformed reference fails the batch, which rolls back, and a nested batch keeps references to its own steps. Numbers unchanged |
+| 2026-10-15 | minor | Removing someone from a live session (#338): right-click a person's avatar ▸ Remove *name* from session, or `collab.removePerson {client}`, when you host the session or own the file on a server; the session ends for them (they keep their copy), the code or link they hold no longer gets them back in while it runs, and everyone else stays. Numbers unchanged |
+| 2026-10-15 | minor | Pages list (#272, #258): a long pages list scrolls in its own area, so the layers below stay in view; page and layer drops count only inside the list's visible rows. Numbers unchanged |
+| 2026-10-15 | minor | Variables export in the browser (#368): Export… ▸ Variables JSON / CSS custom properties did nothing in the web build and now arrives as a download; importing there still needs a file picker. Numbers unchanged |
+| 2026-10-15 | minor | Font picker keys (#352, #345): Up and Down step through the font families from the current one, keeping the highlight in view and previewing it on the canvas; Enter applies it, Escape leaves the text as it was. Numbers unchanged |
+| 2026-10-15 | minor | Leaving Design ends the pen path (#308, #307): switching to Prototype or Inspect while the Pen draws ends the path and goes back to Move (pressing Design again keeps drawing), and a click on the toolbar no longer reaches the canvas under it. Numbers unchanged |
+| 2026-10-15 | minor | Vector edit mode keeps the canvas still (#322): the edit mode hints in the Design panel wrap, so entering edit mode and picking a region no longer shift the canvas by about 25 points in the middle of the click (which dragged the region picked). Numbers unchanged |
+| 2026-10-15 | minor | Drop shadows under a background blur (#317, #255): a layer with both casts its shadows from what it paints (a translucent fill casts a lighter shadow than an opaque one) and reads the backdrop only after drawing them, so a shadow shown behind transparent areas is seen through the blur. Numbers unchanged |
+| 2026-10-15 | minor | When the window can't open (#306, #261): Windows release builds have no console, so a graphics failure at start quit without a word; the error is now logged and shown in a message box in the interface language, with what to try (unset `WGPU_BACKEND`, update the driver, OpenGL) and where to report it, skipped with `--control`. Numbers unchanged |
+| 2026-10-15 | minor | Crashes on Windows (#271, #314, #337; #224 and two more): a text field focused before it was drawn aborted the screen-reader layer; double-clicking a page, creating a variable collection and renaming a style folder no longer close the app. Numbers unchanged |
+| 2026-10-15 | minor | Deeply nested layers (#330, #210): one depth guard (256) on the three recursive layout paths, so a deep file can't run the layout out of stack. Numbers unchanged |
+| 2026-10-15 | minor | Image memory budgets (#326; #203, #189): decoded images and a file's images have budgets; the decode cache evicts its least recently used entries. Numbers unchanged |
+| 2026-10-15 | minor | macOS file dialogs (#253, #250) no longer re-enter the event loop; a dialog's result goes to the file and window it was opened for, and dialogs are parented to the main window. Numbers unchanged |
+| 2026-10-15 | minor | Recovery copies (#297, #303, #331, #336; #202, #185, #187): a copy counts only after its write succeeds and a failed one is retried; saves and closes wait for the write in flight; copies keep version history and branches; a recovered copy stays until this run has its own. Numbers unchanged |
+| 2026-10-15 | minor | Text edits (#280, #278) no longer roll back earlier changes; a drag released off the canvas ends at the pointer's last canvas position. Numbers unchanged |
+| 2026-10-15 | minor | Rollback (#282, #301; #196): a failed command rolls back during a drag or other gesture too; a failed batch keeps the redo steps. Numbers unchanged |
+| 2026-10-15 | minor | Atomic save and export (#284): staging files are uniquely named and created exclusively, so a file or link already at the old fixed staging name is never written through, and two writers of one file no longer share one. Numbers unchanged |
+| 2026-10-15 | minor | Alt-drag copies (#283) snap to their original, and Duplicate (Cmd+D) then repeats the last copy's offset. Numbers unchanged |
+| 2026-10-15 | minor | The pen (#277) shows its Bezier handles while a point is dragged out. Numbers unchanged |
+| 2026-10-15 | minor | Corner handles (#293, #292): a press on a corner handle resizes instead of picking the corner-radius handle. Numbers unchanged |
+| 2026-10-15 | minor | New text (#372, #362) takes a readable colour from the frame it is drawn in, not only the page (text drawn in a white frame on a dark page was white). Numbers unchanged |
+| 2026-10-15 | minor | Outline stroke (#386) works on every selected layer. Numbers unchanged |
+| 2026-10-15 | minor | Send to back (#444) counts per parent when the selection spans frames. Numbers unchanged |
+| 2026-10-15 | minor | Align buttons (#276) are off when the selection has nothing to align to. Numbers unchanged |
+| 2026-10-15 | minor | Gradient type icons (#275) show their gradient. Numbers unchanged |
+| 2026-10-15 | minor | Corner resize cursors (#388) stay diagonal at any proportions; the text selection highlight (#390) stays inside the box on the last line. Numbers unchanged |
+| 2026-10-15 | minor | New pages (#311, #295) take the current page's background; the theme still decides a new file's page. Numbers unchanged |
+| 2026-10-15 | minor | A slice's export preview (#265) shows the content under it. Numbers unchanged |
+| 2026-10-15 | minor | SVG export (#327, #325) keeps a nested frame's fill and stroke inside its parent's clip. Numbers unchanged |
+| 2026-10-15 | minor | Home screen (#318, #324): recent files notice files deleted while it is open; a long path no longer draws over the file name. Numbers unchanged |
+| 2026-10-15 | minor | The Small caps sample in Type settings (#355) draws from capitals, no longer a box where the UI font lacks the small-capital letter. Numbers unchanged |
+| 2026-10-15 | minor | Web clipboard (#375): copy and paste in the browser go through the system clipboard, so a paste after a copy brings the copied layers instead of whatever text the clipboard held. Numbers unchanged |
+| 2026-10-15 | minor | Zoom previews (#312): when renders from scratch are slow, a new zoom first shows the whole view coarsely instead of the page colour, then the refined image; images of another file or page never show. Numbers unchanged |
+| 2026-10-15 | minor | Hidden windows (#313, #332; #269): a minimised or covered window answers control and MCP requests (commands, inspection, `ui.render`) at once, each window on its own; screenshots and input still wait for it to be on screen. Numbers unchanged |
+| 2026-10-15 | minor | Server (#340, #302): a compaction cut short closes the file instead of confirming lost edits (#183); each team library version is kept in its own file (#206). Numbers unchanged |
+| 2026-10-15 | minor | Counters (#343, #344, #353; #309): collab sequence numbers, layer name counters and opacity digits can't overflow. Numbers unchanged |
+| 2026-10-15 | minor | Commands refuse bad indexes and ids (#475, #384, #310): `page.select` and `doc.switch`, `effect.set` and `export.update` / `export.remove`, `page.move` with a non-page id. Numbers unchanged |
+| 2026-10-15 | minor | Find and replace (#358, #361) changes every occurrence, case-insensitively, also when the replacement contains the search text. Numbers unchanged |
+| 2026-10-15 | minor | The gradient shorthand (#254, #252) is read by the engine, so the CLI, control channel and MCP share it. Numbers unchanged |
+| 2026-10-15 | minor | .fig import (#279, #281): resized instances lay out their layers by their constraints (#266); explicit variable modes whose collection is named by its asset key, as library collections are, come across (#267). Numbers unchanged |
+| 2026-10-15 | minor | Colour emoji (#300, #268) draw from their own colour tables (sbix and CBDT/EBDT bitmap strikes, COLR v0 layers), a colour face tried first; COLR v1 still draws outlines. Numbers unchanged |
+| 2026-10-15 | minor | macOS (#290, #289): `.figcraft` files open from Finder, Open With and the Dock. Numbers unchanged |
+| 2026-10-15 | minor | Windows (#294, #291): the first preferred language alone picks the UI language. Numbers unchanged |
+| 2026-10-15 | minor | Unix font discovery (#474) follows `XDG_DATA_HOME`. Numbers unchanged |
+| 2026-10-15 | minor | Linux packaging (#346, #328): the window id matches the desktop entry (FreeBSD keeps its class); the RPM requires glibc 2.35. Numbers unchanged |
+| 2026-10-15 | minor | Tests (#472, #471, #339): the rename shortcut test, the hanging punctuation test and the font-scanning tests no longer depend on the platform, font or test order. Numbers unchanged |
+| 2026-10-15 | minor | Languages (#257, #263, #469, #477, #288): Russian (with one/few/many plural forms) and Turkish catalogs, reviewed by native speakers; Czech and Indonesian drafts; the Japanese draft completed. 2,177 entries now (1,587 UI strings, 559 command labels, 31 menu wordings); strings added since a catalog was written read English there. Localization 39% and 29–51 h unchanged at this rounding (Indonesian is now a draft, while the five older drafts lack 88 newer entries) |
+| 2026-10-22 | minor | Type settings keeps its width (#1029): in languages whose labels run past the 110 px label column (French "Retrait de paragraphe", "Espacement de liste"), the List spacing, Paragraph indent, Max lines and decoration rows were wider than the popover, which then widened every frame while open. Those fields now take the width left after their label; English is unchanged. Regression test in `type_settings_tests`. Numbers unchanged. |
+| 2026-10-22 | minor | `fill`/`stroke` props accept `"none"` (either case) and `null` as no paint (M1, #1036): mapped to an empty fills/strokes list, as `fills: []` already did (undocumented), so an outline-only shape is one call; `KEYS` and `docs/mcp.md` document it, the error names the accepted forms, `fill_none_tests` covers create, set, undo, text and the error. Numbers unchanged |
+| 2026-10-20 | minor | A document dropped on the canvas opens (#916): a `.figcraft`, `.fig` or file JSON dropped on the canvas opens as a file of its own, as on the home screen, in the browser too; it used to add its pages to the file in front. Images and SVG still import at the drop point, File ▸ Import still adds pages, and dragging only documents over the canvas says "Drop to open" (not in the browser, which names no file until the drop). Numbers unchanged |
+| 2026-10-20 | minor | Duplicating a main component makes an instance (#892): Duplicate and Alt-drag copied a main component as a second main; within its file the copy is now an instance of it, as Copy then Paste already was (a variant duplicated in its set stays a variant). Numbers unchanged. |
+| 2026-10-20 | minor | Readable disabled and selected text (#890): the dim text colour (disabled buttons, placeholders, hints) is at least 3:1 against panels, fields and selected rows in both themes (it was 2.1:1 in the light theme), a disabled button is grey with that text instead of fading to 40%, and selected text (renaming a page or layer, any text box) takes the theme's readable green on the highlight (1.4:1 in the dark theme before, now 4.2:1 or more); checked with the colour contrast helper (`theme::tests`). Numbers unchanged |
+| 2026-10-20 | minor | Layer data reads back (#879): `node.get` (the command, the control method and MCP `get_node`) and `document.inspect` report a layer's or page's `pluginData` as `{key: value}` when it has any, so a tool that keeps state in a file with `node.set {props: {pluginData}}` can read it on its next run (`plugin_data_tests`). Numbers unchanged |
+| 2026-10-20 | minor | Measuring while nudging (#894): with Alt held over another layer, the arrows nudge the selection (Shift: the big step) and the distances follow every nudge (Alt+arrows used to do nothing); while measuring, the selection's handles and size label hide and both layers keep their outlines (`measure_nudge_tests`). Numbers unchanged |
+| 2026-10-20 | minor | Release fonts (#885): the web release embeds craft-fonts again (Inter), so the browser version draws text and lists fonts; it had none since releases moved to the shared workflow. The craft-fonts pin goes back to the commit with the Latin manifest (the Georgian change had moved it to one without Inter, which would have failed the next release). Numbers unchanged. |
+| 2026-10-17 | minor | Community batch #753 (10 PRs): Selection colors for mixed selections (#403); smart-selection spacing fields and canvas handles (#402); a Present tab with device and scale controls (#537); adding auto layout to an empty frame keeps its size (#369); `node.set` applies auto layout keys to frames only and warns about font styles a family lacks (#603); canvas images on whole device pixels (#359); Adwaita window controls on Wayland without server decorations (#592, not run on GNOME or KDE by the maintainers); the keyboard shortcuts panel closes on the home screen (#548); macOS paste modifiers in tests (#750); credits column tests (#347). `cargo xtask parity` re-run: 212 / 212 menu items (100%; the catalog gained View ▸ Full screen with #227 on 2026-10-14), 561 commands. Language table re-measured from the catalogs (2,272 entries): the drafts read 95–99% (strings added since 2026-10-12 show English), Indonesian has a draft (99%; it read none), and Russian, Swedish (its command labels from #599), Turkish and Czech are listed with their counts. Per-area parity rows for the day's landings in `docs/gaps.md`, `target-app-parity.md` and the area docs. Numbers unchanged |
+| 2026-10-17 | minor | Control channel while the window is minimised (M8, #720): a minimised or covered window answers every request that acts on the app's state (edits, `ui.inspect`, `ui.pointer`, `ui.key`, `ui.type`, `ui.set`, `app.quit`…) without drawing, and what needs a drawn frame (`ui.screenshot`, `ui.input`, `window.new`) is an error at once; before, those waited up to 60 s and held up every later request on the connection (an attached agent's `inspect_ui` or window screenshot stalled until the window came back). Measured on Windows 11, minimised: requests ~100 ms each (eframe wakes a minimised window at most ten times a second; ~2 ms on screen), a window screenshot fails in ~100 ms instead of 60 s, idle CPU 0. Numbers unchanged. |
+| 2026-10-17 | minor | Community fixes from #524 up (batches #727, #728, #733, #735, #736 and #729; 55 PRs) and a crash guard. `.fig` import: explicit instance identity, overrides by key, text style precedence, grid track sizes, slot content, connector labels, skip ink, paragraph options and hanging lists, list start numbers, vertical trim, per-point stroke joins, text on a path, image adjustments and embedded images; large files open within budgets from the file's own size; an import report after opening; imported bytes stay out of the command journal. Files and paste: save a copy as `.fig`; Cmd/Ctrl+V pastes images copied in other apps and layers copied from another design app (`edit.pasteDesignLayers`); paste over and paste properties; clipboard reads on Linux and the BSDs time out after 2 s. Editor: live font preview on hover; Shift+I and Resources open Assets; Shift-drag moves the selection; thin strokes take a nearby double-click; dropped points merge; Flatten keeps open paths; the Actions palette gets tabs, ranked search, a keyboard highlight and recents; the colour picker opens on a new fill or stroke; text strokes follow their alignment; selection highlights after line breaks; a draggable pages/layers divider; variant properties reorder by drag; submenus keep their hover with a safe triangle; menu actions that need a value ask for it; File ▸ Rename edits the name in place. Engine: bad paint indexes, non-finite geometry and pages in copy/cut are refused; a param naming a layer says so when it isn't one; a CLI script is one undo step and resolves `$step`. Server and collaboration: message limits follow `max_file_mb` (client capped at 1 GiB); a damaged generation field no longer drops flushed edits; the web build joins a session from a `#join=` link. Also Swedish command labels, Nix CI through the shared workflow, paint bounds once per render, and a guard that turns a panic inside the boolean-op library into bad input (the stroke draws unclipped). Numbers unchanged. |
+| 2026-10-17 | minor | Number variables on text content (M3, #629): the Typography section's variable picker also lists number variables for a text layer's content, as the engine already accepted (the text shows the number, e.g. 42.5, and follows the variable). Other text fields keep their own types. Numbers unchanged. |
+| 2026-10-17 | minor | Frames and sections convert into each other (M1, #719): `object.convertToSection` turns a frame on the page or in a section into a section in place (same box, name, fill and layers, which stay where they are; what only a frame has goes: auto layout, clipping, layout grids, guides, scrolling), and `object.convertToFrame` now also turns a section into a frame that keeps its fill and doesn't clip, so the look stays. Nested frames, instances, main components and sections holding sections are refused with the reason; one undo step each. Both are in the canvas context menu (Convert to section / Convert to frame) and in Spanish. Numbers unchanged. |
+| 2026-10-16 | minor | Community fixes from #478 up (batches #591, #598, #602; 69 PRs) and a control-channel fix: a line that isn't JSON now ends a `--control` connection, so a web page can't drive the app through a browser request (#589). Highlights: page copies keep navigation, flows, prototype settings and guides; Find and Replace keeps line endings and case-insensitive matches; text hyperlinks survive import and export; recent colours record only what was picked; MCP screenshots respect `maxSize`; Swedish catalog (UI strings), Czech plurals; bounded canvas overscan while panning; Korean fallback at the run's weight; many vector-edit, guide, page and .fig round-trip fixes. Numbers unchanged |
 | 2026-10-15 | minor | Drop files anywhere to open them (M7): dragging files over the window shows a "Drop to open" (home) or "Drop to import" (canvas) overlay. On the home screen each supported file opens as a document of its own and other files are turned away with a toast; on the canvas the files import at the drop point. Both wait behind a small card that is on screen before a large file blocks the window. A canvas import stays with the document and page that received the drop even if the tab or page changes meanwhile, and is cancelled with a message if that document or page is gone. Numbers unchanged. |
 | 2026-10-15 | minor | M7: system font discovery skips entries observed as non-regular files before opening them, avoiding the reproduced named-pipe stall. Regular-file symlinks remain supported; directory depth, font limits and priorities are unchanged. Numbers unchanged. |
 | 2026-10-15 | minor | Canvas retains a bounded margin while panning so newly exposed strips can reuse the previous render. Numbers unchanged. |
+| 2026-10-15 | minor | Dev Mode tail (M6, gap 16): import lines for connected components inside generated layer trees (definitions, slots and swapped-in instances too); `dev.compare {version}` and the compare view's Compare with menu compare with any saved version; behaviour suite (5 tests; 4 failed before the fixes): an inspect-only Dev Mode canvas with menus, shortcuts, nudges, opacity keys and paste refusing design edits, toolbar drawing tools returning to the design, Changed in the ready list (`inspect.readyForDev {status: changed}`), statuses only on sections and top-level frames; read-only plugins' panels from the Inspect tab. Dev Mode 96%/72% → 97%/76%, 0–1 h → 2–4 h (measurements kept on the canvas and a read-only layers panel counted as missing); header totals not recomputed |
 | 2026-10-15 | minor | Typography spacing icons scrub with the shared number-field gesture, modifier rates and one Undo step per drag (#373). Units and selected-character targeting are preserved. Numbers unchanged. |
 | 2026-10-14 | minor | System theme on first run (M7): preferences without a theme default to System; the first frame reads the OS appearance directly, including when returning from a manual theme. Saved Light/Dark choices stay explicit; unavailable OS appearance falls back to Light. Numbers unchanged. |
 | 2026-10-14 | minor | Home screen recent files as cards (M7): each card shows the picture its file carries on its first page's colour, the file's icon, name and "Edited ... ago"; sort by name, creation or last change either way; a table view; a click selects, a double-click or Enter opens, arrow keys move; Open, Show in folder and Remove from recents on right-click. Numbers unchanged. |
diff --git a/apps/figcraft-cli/src/args.rs b/apps/figcraft-cli/src/args.rs
index 372082c24..3fe17e802 100644
--- a/apps/figcraft-cli/src/args.rs
+++ b/apps/figcraft-cli/src/args.rs
@@ -1,5 +1,6 @@
 //! Minimal std-only argument parsing: positionals, `--key value` / `--key=value` / `-o value`
-//! options, and boolean `--flag`s. Unknown options are usage errors.
+//! options (given again: the last counts, or all with [`Args::values`]), and boolean `--flag`s.
+//! Unknown options are usage errors; `--help` or `-h` is [`CliError::Help`].
 
 use std::collections::BTreeMap;
 
@@ -8,13 +9,15 @@ use crate::{CliError, CliResult};
 #[derive(Debug, Default)]
 pub struct Args {
     pub positional: Vec<String>,
-    values: BTreeMap<String, String>,
+    values: BTreeMap<String, Vec<String>>,
     flags: Vec<String>,
 }
 
 impl Args {
     pub fn parse(argv: &[String], valued: &[&str], flags: &[&str]) -> CliResult<Self> {
         let mut a = Args::default();
+        // The first bad option, reported once the rest of the line is checked for `--help`.
+        let mut bad: Option<CliError> = None;
         let mut it = argv.iter();
         while let Some(arg) = it.next() {
             let name = if let Some(n) = arg.strip_prefix("--") {
@@ -29,23 +32,36 @@ impl Args {
                 Some((n, v)) => (n, Some(v.to_string())),
                 None => (name, None),
             };
+            // `--help` / `-h` anywhere among the options (not as an option's value) asks for help.
+            if inline.is_none() && matches!(name, "help" | "h") {
+                return Err(CliError::Help);
+            }
             if valued.contains(&name) {
-                let v = match inline {
-                    Some(v) => v,
-                    None => it.next().cloned().ok_or_else(|| CliError::Usage(format!("`{arg}` needs a value")))?,
-                };
-                a.values.insert(name.to_string(), v);
+                match inline.or_else(|| it.next().cloned()) {
+                    Some(v) => a.values.entry(name.to_string()).or_default().push(v),
+                    None => {
+                        bad.get_or_insert(CliError::Usage(format!("`{arg}` needs a value")));
+                    }
+                }
             } else if flags.contains(&name) && inline.is_none() {
                 a.flags.push(name.to_string());
             } else {
-                return Err(CliError::Usage(format!("unknown option `{arg}`")));
+                bad.get_or_insert(CliError::Usage(format!("unknown option `{arg}`")));
             }
         }
-        Ok(a)
+        match bad {
+            Some(e) => Err(e),
+            None => Ok(a),
+        }
     }
 
     pub fn value(&self, k: &str) -> Option<String> {
-        self.values.get(k).cloned()
+        self.values.get(k).and_then(|v| v.last()).cloned()
+    }
+
+    /// Every value of an option that may be given more than once, in order.
+    pub fn values(&self, k: &str) -> &[String] {
+        self.values.get(k).map_or(&[], Vec::as_slice)
     }
 
     pub fn flag(&self, k: &str) -> bool {
@@ -62,9 +78,9 @@ impl Args {
     /// PDF print options: `--bleed LENGTH` (points, or "3mm", "0.125in"), `--crop-marks`,
     /// `--bleed-marks`, `--cmyk`.
     pub fn print(&self) -> CliResult<figcraft_doc::PrintSettings> {
-        let bleed = match self.values.get("bleed") {
+        let bleed = match self.value("bleed") {
             None => 0.0,
-            Some(s) => figcraft_doc::PrintSettings::parse_length(s)
+            Some(s) => figcraft_doc::PrintSettings::parse_length(&s)
                 .filter(|b| *b <= figcraft_doc::PrintSettings::MAX_BLEED)
                 .ok_or_else(|| CliError::Usage(format!("--bleed takes points or a length like 3mm or 0.125in (up to 2in), got `{s}`")))?,
         };
@@ -72,7 +88,7 @@ impl Args {
     }
 
     pub fn scale(&self) -> CliResult<f64> {
-        match self.values.get("scale") {
+        match self.value("scale") {
             None => Ok(1.0),
             Some(s) => s
                 .trim_end_matches('x')
@@ -85,7 +101,7 @@ impl Args {
 
     /// A comma-separated list of whole numbers (`--layers 1000,10_000`).
     pub fn usizes(&self, k: &str, default: &[usize]) -> CliResult<Vec<usize>> {
-        match self.values.get(k) {
+        match self.value(k) {
             None => Ok(default.to_vec()),
             Some(s) => s
                 .split(',')
@@ -110,6 +126,10 @@ mod tests {
         assert_eq!(a.value("o").as_deref(), Some("out"));
         assert_eq!(a.scale().unwrap(), 2.0);
         assert!(a.flag("json"));
+        let a = Args::parse(&v(&["--root", "a", "--root=b"]), &["root"], &[]).unwrap();
+        assert_eq!(a.values("root"), ["a", "b"]);
+        assert_eq!(a.value("root").as_deref(), Some("b"));
+        assert!(a.values("none").is_empty());
     }
 
     #[test]
@@ -125,4 +145,18 @@ mod tests {
         let a = Args::parse(&v(&["-5"]), &[], &[]).unwrap();
         assert_eq!(a.positional, ["-5"]);
     }
+
+    #[test]
+    fn help_is_asked_for_anywhere_but_as_a_value() {
+        // Also after a bad option: help wins over the usage error (#1161 review).
+        for argv in
+            [&["--help"][..], &["-h"], &["in.figcraft", "-o", "out", "--help"], &["--json", "-h"], &["--bogus", "--help"], &["--json=1", "-h"]]
+        {
+            assert!(matches!(Args::parse(&v(argv), &["o"], &["json"]), Err(CliError::Help)), "{argv:?}");
+        }
+        let a = Args::parse(&v(&["--filter", "--help", "-o", "-h"]), &["filter", "o"], &[]).unwrap();
+        assert_eq!((a.value("filter").as_deref(), a.value("o").as_deref()), (Some("--help"), Some("-h")));
+        // `--help=x` is no request for help, just an unknown option.
+        assert!(matches!(Args::parse(&v(&["--help=x"]), &[], &[]), Err(CliError::Usage(_))));
+    }
 }
diff --git a/apps/figcraft-cli/src/files.rs b/apps/figcraft-cli/src/files.rs
index 4fb485e10..b37780637 100644
--- a/apps/figcraft-cli/src/files.rs
+++ b/apps/figcraft-cli/src/files.rs
@@ -29,9 +29,20 @@ fn image_format(e: &str) -> Option<ExportFormat> {
     }
 }
 
+/// Writes through [`figcraft_engine::file_access`] when automation roots are in force, so a
+/// confined run can only write inside a write root (#833).
+///
+/// Unconfined it writes with `std::fs::write`, as it always did. `file_access::write` stages the
+/// bytes and renames them into place, which **replaces** a symbolic link at `path` instead of
+/// writing through it to its target -- a change of behaviour for anyone whose output path is a
+/// link, and nothing to do with confinement. Inside a root the staged write is the right one:
+/// `Roots::check` has already refused a link that leads out of the root.
 fn write(path: &str, bytes: &[u8]) -> CliResult<()> {
     if let Some(dir) = Path::new(path).parent().filter(|d| !d.as_os_str().is_empty()) {
-        std::fs::create_dir_all(dir).map_err(|e| CliError::Failed(format!("{}: {e}", dir.display())))?;
+        figcraft_engine::file_access::create_dir_all(dir).map_err(|e| CliError::Failed(e.to_string()))?;
+    }
+    if figcraft_engine::file_access::current().is_some() {
+        return figcraft_engine::file_access::write(path, bytes).map_err(|e| CliError::Failed(e.to_string()));
     }
     std::fs::write(path, bytes).map_err(|e| CliError::Failed(format!("{path}: {e}")))
 }
@@ -155,6 +166,7 @@ pub fn info(path: &str, as_json: bool) -> CliResult<ExitCode> {
             Some(json!({"id": p, "name": pn.name, "nodes": nodes, "topLevel": pn.children.len(), "frames": frames}))
         })
         .collect();
+    let missing = figcraft_engine::fonts::missing(&doc);
     let v = json!({
         "file": path,
         "name": doc.name,
@@ -164,6 +176,7 @@ pub fn info(path: &str, as_json: bool) -> CliResult<ExitCode> {
         "variables": doc.variables.variables.len(),
         "images": doc.images.len(),
         "notes": notes,
+        "missingFonts": missing.iter().map(|m| json!({"family": m.family, "layers": m.layers})).collect::<Vec<_>>(),
     });
     if as_json {
         println!("{}", serde_json::to_string_pretty(&v).unwrap_or_default());
@@ -187,12 +200,18 @@ pub fn info(path: &str, as_json: bool) -> CliResult<ExitCode> {
             println!("  {} {} \"{}\" {}×{}", f["id"], f["type"].as_str().unwrap_or(""), f["name"].as_str().unwrap_or(""), f["width"], f["height"]);
         }
     }
+    for m in &missing {
+        let layers = if m.layers == 1 { "text layer" } else { "text layers" };
+        println!("missing font \"{}\": {} {layers} (drawn in a fallback font)", m.family, m.layers);
+    }
     Ok(ExitCode::SUCCESS)
 }
 
+/// The file name a layer exports to: the app's rule ([`figcraft_engine::cmd::file::safe_file_name`],
+/// so `/` becomes `_` too), without leading or trailing spaces and dots, at most 100 characters.
 fn sanitize(name: &str) -> String {
-    let s: String = name.chars().map(|c| if c.is_alphanumeric() || matches!(c, '-' | '_' | ' ' | '.') { c } else { '_' }).collect();
-    let s = s.trim().trim_matches('.').to_string();
+    let s = figcraft_engine::cmd::file::safe_file_name(name);
+    let s = s.trim_matches(|c: char| c == '.' || c.is_whitespace()).to_string();
     if s.is_empty() { "layer".into() } else { s.chars().take(100).collect() }
 }
 
@@ -238,7 +257,7 @@ pub fn export(file: &str, out: &str, t: &Target) -> CliResult<ExitCode> {
         println!("{out}");
         return Ok(ExitCode::SUCCESS);
     }
-    std::fs::create_dir_all(out).map_err(|e| CliError::Failed(format!("{out}: {e}")))?;
+    figcraft_engine::file_access::create_dir_all(out).map_err(|e| CliError::Failed(e.to_string()))?;
     let ids = match target {
         Some(t) => vec![t],
         None => {
@@ -323,7 +342,8 @@ pub fn parse_script(text: &str) -> Result<Vec<(String, Value)>, String> {
 }
 
 pub fn run_script(script: &str, input: Option<&str>, out: Option<&str>) -> CliResult<ExitCode> {
-    let text = std::fs::read_to_string(script).map_err(|e| CliError::Failed(format!("{script}: {e}")))?;
+    let bytes = figcraft_engine::file_access::read(script).map_err(|e| CliError::Failed(e.to_string()))?;
+    let text = String::from_utf8(bytes).map_err(|_| CliError::Failed(format!("{script}: not UTF-8")))?;
     let steps = parse_script(&text).map_err(|e| CliError::Failed(format!("{script}: {e}")))?;
     let mut s = match input {
         Some(path) => {
@@ -333,17 +353,32 @@ pub fn run_script(script: &str, input: Option<&str>, out: Option<&str>) -> CliRe
         }
         None => Session::new(),
     };
-    for (i, (cmd, params)) in steps.iter().enumerate() {
-        let r = s.execute(cmd, params);
-        s.ui_requests.clear();
-        match r {
-            Ok(v) => println!("{}", json!({"step": i, "command": cmd, "ok": true, "result": v})),
-            Err(e) => {
-                println!("{}", json!({"step": i, "command": cmd, "ok": false, "error": e.to_string()}));
-                eprintln!("error: step {i} ({cmd}) failed: {e}");
-                return Ok(ExitCode::from(1));
-            }
+    // One undo step and all-or-nothing, the way the same commands behave through `command.batch`
+    // (MCP, the control channel, plugins): `{"$step": n}` resolves against the steps before it, and
+    // a step that fails takes the whole script back instead of leaving the earlier steps applied.
+    // The result lines are held back until the script is through, so none of them reports work that
+    // was rolled back.
+    let mut results: Vec<Value> = Vec::with_capacity(steps.len());
+    let mut failed_at = 0;
+    let outcome = s.grouped(&format!("run {script}"), |s| {
+        for (i, (cmd, params)) in steps.iter().enumerate() {
+            failed_at = i;
+            let v = s.batch_step(&results, i, cmd, params)?;
+            s.ui_requests.clear();
+            results.push(v);
         }
+        Ok(())
+    });
+    if let Err(e) = outcome {
+        let cmd = steps.get(failed_at).map_or("", |(cmd, _)| cmd.as_str());
+        let i = failed_at;
+        println!("{}", json!({"step": i, "command": cmd, "ok": false, "error": e.to_string(), "rolledBack": true}));
+        eprintln!("error: step {i} ({cmd}) failed: {e}");
+        eprintln!("the script's document changes were rolled back");
+        return Ok(ExitCode::from(1));
+    }
+    for (i, ((cmd, _), v)) in steps.iter().zip(&results).enumerate() {
+        println!("{}", json!({"step": i, "command": cmd, "ok": true, "result": v}));
     }
     if let Some(out) = out {
         let ds = s.ds().map_err(|e| CliError::Failed(e.to_string()))?;
@@ -378,6 +413,13 @@ mod tests {
         assert_eq!(sanitize("Home / Hero"), "Home _ Hero");
         assert_eq!(sanitize("../.."), "_");
         assert_eq!(sanitize(""), "layer");
+        // The same characters the app's export keeps (#1154): only what file systems refuse goes.
+        assert_eq!(sanitize("Homepage - desktop (live + verbeteringen)"), "Homepage - desktop (live + verbeteringen)");
+        assert_eq!(sanitize("Q&A, 50% #1 [v2] {x} ~é"), "Q&A, 50% #1 [v2] {x} ~é");
+        assert_eq!(sanitize("a\\b:c*d?e\"f<g>h|i\tj"), "a_b_c_d_e_f_g_h_i_j");
+        assert_eq!(sanitize(" .hidden. "), "hidden");
+        assert_eq!(sanitize(" . .name. . "), "name", "spaces and dots at the edges, mixed");
+        assert_eq!(sanitize(&"x".repeat(300)).chars().count(), 100);
     }
 
     #[test]
@@ -422,4 +464,62 @@ mod tests {
         assert_eq!(std::fs::read_dir(&dir).unwrap().count(), 2);
         std::fs::remove_dir_all(dir).unwrap();
     }
+
+    fn temp_dir(tag: &str) -> std::path::PathBuf {
+        let stamp = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos();
+        let dir = std::env::temp_dir().join(format!("figcraft-cli-{tag}-{}-{stamp}", std::process::id()));
+        std::fs::create_dir(&dir).unwrap();
+        dir
+    }
+
+    /// A script resolves `{"$step": n}` like the same commands through `command.batch`. Each step
+    /// used to run on its own, so the reference reached `parent` unresolved, `node.create` read it
+    /// as "no parent" and the layer landed on the page — with every step reporting success.
+    #[test]
+    fn a_script_puts_a_layer_in_a_layer_an_earlier_step_made() {
+        let dir = temp_dir("run-step");
+        let script = dir.join("script.json");
+        std::fs::write(
+            &script,
+            r#"[
+                {"command": "node.create", "params": {"type": "frame", "name": "Card", "x": 0, "y": 0, "width": 200, "height": 100}},
+                {"command": "node.create", "params": {"type": "rectangle", "name": "child", "parent": {"$step": 0}, "x": 10, "y": 10, "width": 20, "height": 20}}
+            ]"#,
+        )
+        .unwrap();
+        let out = dir.join("out.figcraft");
+        run_script(script.to_str().unwrap(), None, Some(out.to_str().unwrap())).unwrap();
+
+        let mut s = Session::empty();
+        s.execute("file.open", &json!({"path": out.to_str().unwrap()})).unwrap();
+        let doc = s.doc().unwrap();
+        let page = s.page().unwrap();
+        let top = doc.node(page).unwrap().children.clone();
+        assert_eq!(top.len(), 1, "only the frame is top level, not the rectangle too");
+        assert_eq!(doc.node(top[0]).unwrap().name, "Card");
+        let inner = doc.node(top[0]).unwrap().children.clone();
+        assert_eq!(inner.len(), 1, "the rectangle went inside the frame");
+        assert_eq!(doc.node(inner[0]).unwrap().name, "child");
+        std::fs::remove_dir_all(dir).unwrap();
+    }
+
+    /// A step that fails takes the whole script back: nothing is written, and the failure says so.
+    #[test]
+    fn a_failed_step_leaves_no_output() {
+        let dir = temp_dir("run-rollback");
+        let script = dir.join("script.json");
+        std::fs::write(
+            &script,
+            r#"[
+                {"command": "node.create", "params": {"type": "frame", "name": "Card", "x": 0, "y": 0, "width": 200, "height": 100}},
+                {"command": "node.set", "params": {"ids": [99999], "props": {"name": "nope"}}}
+            ]"#,
+        )
+        .unwrap();
+        let out = dir.join("out.figcraft");
+        // The failure is the script's, not the call's: the CLI reports it and exits non-zero.
+        run_script(script.to_str().unwrap(), None, Some(out.to_str().unwrap())).unwrap();
+        assert!(!out.exists(), "a script that failed writes nothing");
+        std::fs::remove_dir_all(dir).unwrap();
+    }
 }
diff --git a/apps/figcraft-cli/src/main.rs b/apps/figcraft-cli/src/main.rs
index 590b50f14..666276731 100644
--- a/apps/figcraft-cli/src/main.rs
+++ b/apps/figcraft-cli/src/main.rs
@@ -22,11 +22,12 @@ USAGE:
   figcraft-cli convert <in> <out>
   figcraft-cli render <file> -o <out.png> [--scale N] [--page NAME]
   figcraft-cli run <script.json|script.jsonl> [--in <file>] [--out <file>]
+  (info, export, convert, render and run also take --automation-read-root DIR / --automation-write-root DIR)
   figcraft-cli commands [--json] [--filter TEXT]
-  figcraft-cli mcp [--attach PORT]
+  figcraft-cli mcp [--attach PORT] [--automation-read-root DIR]... [--automation-write-root DIR]...
   figcraft-cli plugin publish <folder> --server ws://host:port/[?key=KEY]
   figcraft-cli perf [--layers N[,N...]] [--instances N[,N...]]
-  figcraft-cli help | --help | --version
+  figcraft-cli help | --help | --version   (a subcommand followed by --help or -h prints this too)
 
 Every subcommand takes --no-system-fonts (or set FIGCRAFT_NO_SYSTEM_FONTS=1): text uses only the
 fonts built into FigCraft, for renders that match on every machine. Otherwise installed fonts are
@@ -42,12 +43,42 @@ crop and bleed marks, CMYK colour). `run` executes a JSON array (or JSON lines)
 `plugin publish` sends a plugin folder (figcraft-plugin.json, its module, an optional assets/ folder)
 to a figcraft-server's plugin directory as a new version; the server's key comes from the address or
 the FIGCRAFT_SERVER_KEY environment variable (which keeps it out of the shell history).
+`--automation-read-root DIR` / `--automation-write-root DIR` (each may be repeated; the folders
+must exist) confine the files a subcommand touches: reads only inside a read or write root, writes
+only inside a write root, everything else refused -- so giving no write root denies writing
+altogether. They reach the headless side only: `mcp` takes them to confine the agent's commands,
+and `info`, `export`, `convert`, `render` and `run` to confine that one run; without them a
+subcommand reads and writes as the user who started it, as before. A `mcp --attach` server is
+confined by the app it attaches to, not by flags passed to the CLI: start that app with
+`figcraft --control PORT` and the same roots (`--attach` refuses them).
 See docs/cli.md and docs/mcp.md.";
 
+/// The automation roots a file subcommand was given, if any. Omitting both leaves the run
+/// unconfined, as before; giving either confines every file the subcommand touches (#833).
+const ROOT_FLAGS: [&str; 2] = ["automation-read-root", "automation-write-root"];
+
+fn roots_of(a: &Args) -> CliResult<Option<figcraft_engine::file_access::Roots>> {
+    let (read, write) = (a.values("automation-read-root"), a.values("automation-write-root"));
+    if read.is_empty() && write.is_empty() {
+        return Ok(None);
+    }
+    Ok(Some(figcraft_engine::file_access::Roots::new(read, write).map_err(CliError::Failed)?))
+}
+
+/// Runs `f` confined to the roots `a` carries.
+fn confined<R>(a: &Args, f: impl FnOnce() -> CliResult<R>) -> CliResult<R> {
+    let roots = roots_of(a)?.map(std::sync::Arc::new);
+    figcraft_engine::file_access::confined(roots.as_ref(), f)
+}
+
 fn main() -> ExitCode {
     let argv: Vec<String> = std::env::args().skip(1).collect();
     match run(&argv) {
         Ok(code) => code,
+        Err(CliError::Help) => {
+            println!("{USAGE}");
+            ExitCode::SUCCESS
+        }
         Err(CliError::Usage(msg)) => {
             eprintln!("error: {msg}\n\n{USAGE}");
             ExitCode::from(2)
@@ -61,6 +92,8 @@ fn main() -> ExitCode {
 
 #[derive(Debug)]
 pub enum CliError {
+    /// `--help` or `-h` after a subcommand: usage on stdout, exit code 0.
+    Help,
     /// Bad arguments: usage is printed, exit code 2.
     Usage(String),
     /// The operation failed: exit code 1.
@@ -94,35 +127,38 @@ fn run(argv: &[String]) -> CliResult<ExitCode> {
             Ok(ExitCode::SUCCESS)
         }
         "info" => {
-            let a = Args::parse(rest, &[], &["json"])?;
+            let a = Args::parse(rest, &ROOT_FLAGS, &["json"])?;
             let file = a.one_positional("info <file>")?;
-            files::info(&file, a.flag("json"))
+            confined(&a, || files::info(&file, a.flag("json")))
         }
         "export" => {
-            let a = Args::parse(rest, &["format", "scale", "page", "node", "o", "out", "bleed"], &["crop-marks", "bleed-marks", "cmyk"])?;
+            let valued = [&["format", "scale", "page", "node", "o", "out", "bleed"][..], &ROOT_FLAGS[..]].concat();
+            let a = Args::parse(rest, &valued, &["crop-marks", "bleed-marks", "cmyk"])?;
             let file = a.one_positional("export <file> -o <out>")?;
             let out = a.value("o").or_else(|| a.value("out")).ok_or_else(|| CliError::Usage("export needs -o <out>".into()))?;
             let target =
                 files::Target { format: a.value("format"), scale: a.scale()?, page: a.value("page"), node: a.value("node"), print: a.print()? };
-            files::export(&file, &out, &target)
+            confined(&a, || files::export(&file, &out, &target))
         }
         "convert" => {
-            let a = Args::parse(rest, &[], &[])?;
+            let a = Args::parse(rest, &ROOT_FLAGS, &[])?;
             match a.positional.as_slice() {
-                [i, o] => files::convert(i, o),
+                [i, o] => confined(&a, || files::convert(i, o)),
                 _ => Err(CliError::Usage("convert <in> <out>".into())),
             }
         }
         "render" => {
-            let a = Args::parse(rest, &["o", "out", "scale", "page"], &[])?;
+            let valued = [&["o", "out", "scale", "page"][..], &ROOT_FLAGS[..]].concat();
+            let a = Args::parse(rest, &valued, &[])?;
             let file = a.one_positional("render <file> -o <out.png>")?;
             let out = a.value("o").or_else(|| a.value("out")).ok_or_else(|| CliError::Usage("render needs -o <out.png>".into()))?;
-            files::render(&file, &out, a.scale()?, a.value("page").as_deref())
+            confined(&a, || files::render(&file, &out, a.scale()?, a.value("page").as_deref()))
         }
         "run" => {
-            let a = Args::parse(rest, &["in", "out"], &[])?;
+            let valued = [&["in", "out"][..], &ROOT_FLAGS[..]].concat();
+            let a = Args::parse(rest, &valued, &[])?;
             let script = a.one_positional("run <script.json|.jsonl>")?;
-            files::run_script(&script, a.value("in").as_deref(), a.value("out").as_deref())
+            confined(&a, || files::run_script(&script, a.value("in").as_deref(), a.value("out").as_deref()))
         }
         "commands" => {
             let a = Args::parse(rest, &["filter"], &["json"])?;
@@ -133,11 +169,20 @@ fn run(argv: &[String]) -> CliResult<ExitCode> {
             Ok(ExitCode::SUCCESS)
         }
         "mcp" => {
-            let a = Args::parse(rest, &["attach"], &[])?;
+            let valued = [&["attach"][..], &ROOT_FLAGS[..]].concat();
+            let a = Args::parse(rest, &valued, &[])?;
             if !a.positional.is_empty() {
                 return Err(CliError::Usage("mcp takes no positional arguments".into()));
             }
-            mcp(a.value("attach").as_deref())
+            let attach = a.value("attach");
+            // The app runs the commands: only its own roots can confine them.
+            if attach.is_some() && ROOT_FLAGS.iter().any(|f| !a.values(f).is_empty()) {
+                return Err(CliError::Usage(
+                    "--attach can't take automation roots: start the app with them instead (`figcraft --control PORT --automation-read-root DIR ...`)"
+                        .into(),
+                ));
+            }
+            mcp(attach.as_deref(), roots_of(&a)?)
         }
         "plugin" => {
             let a = Args::parse(rest, &["server"], &[])?;
@@ -205,7 +250,7 @@ fn publish_plugin(folder: &str, server: &str) -> CliResult<ExitCode> {
     Ok(ExitCode::SUCCESS)
 }
 
-fn mcp(attach: Option<&str>) -> CliResult<ExitCode> {
+fn mcp(attach: Option<&str>, roots: Option<figcraft_engine::file_access::Roots>) -> CliResult<ExitCode> {
     let backend: Box<dyn figcraft_mcp::Backend> = match attach {
         Some(p) => {
             let addr = if p.contains(':') {
@@ -220,7 +265,10 @@ fn mcp(attach: Option<&str>) -> CliResult<ExitCode> {
         None => Box::new(figcraft_mcp::Headless::new()),
     };
     eprintln!("figcraft MCP server ({}) on stdio", backend.describe());
-    let mut server = figcraft_mcp::Server::new(backend);
+    if let Some(r) = &roots {
+        eprintln!("file access confined to {}", r.to_json());
+    }
+    let mut server = figcraft_mcp::Server::new(backend).with_roots(roots);
     let stdin = std::io::stdin();
     let stdout = std::io::stdout();
     server.serve(stdin.lock(), stdout.lock()).map_err(|e| format!("stdio: {e}"))?;
diff --git a/apps/figcraft-cli/tests/cli.rs b/apps/figcraft-cli/tests/cli.rs
deleted file mode 100644
index 9dd522031..000000000
--- a/apps/figcraft-cli/tests/cli.rs
+++ /dev/null
@@ -1,128 +0,0 @@
-//! The binary end to end.
-#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
-
-use std::io::Write;
-use std::process::{Command, Stdio};
-
-fn bin() -> Command {
-    Command::new(env!("CARGO_BIN_EXE_figcraft-cli"))
-}
-
-fn tmp(name: &str) -> std::path::PathBuf {
-    let d = std::env::temp_dir().join(format!("figcraft-cli-test-{}-{name}", std::process::id()));
-    std::fs::create_dir_all(&d).unwrap();
-    d
-}
-
-#[test]
-fn bad_arguments_exit_2_without_panicking() {
-    for args in [
-        &[][..],
-        &["bogus"],
-        &["export"],
-        &["export", "x.figcraft"],
-        &["info", "--nope"],
-        &["render", "a", "-o"],
-        &["perf", "--shapes", "lots"],
-        &["mcp", "--attach", "notaport"],
-        &["convert", "a"],
-    ] {
-        let out = bin().args(args).output().unwrap();
-        assert_eq!(out.status.code(), Some(2), "{args:?}: {}", String::from_utf8_lossy(&out.stderr));
-        let err = String::from_utf8_lossy(&out.stderr);
-        assert!(err.contains("USAGE"), "{args:?}");
-        assert!(!err.contains("panicked"));
-    }
-    let out = bin().args(["info", "/no/such/file.figcraft"]).output().unwrap();
-    assert_eq!(out.status.code(), Some(1));
-}
-
-#[test]
-fn run_export_info_convert() {
-    let d = tmp("run");
-    let script = d.join("s.jsonl");
-    std::fs::write(&script, "{\"command\":\"frame.create\",\"params\":{\"x\":0,\"y\":0,\"width\":100,\"height\":50,\"name\":\"A\",\"props\":{\"fill\":\"#ff0000\"}}}\n{\"command\":\"frame.create\",\"params\":{\"x\":200,\"y\":0,\"width\":30,\"height\":30,\"name\":\"B\"}}\n").unwrap();
-    let file = d.join("doc.figcraft");
-    let out = bin().arg("run").arg(&script).arg("--out").arg(&file).output().unwrap();
-    assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
-    let lines: Vec<serde_json::Value> = String::from_utf8_lossy(&out.stdout).lines().map(|l| serde_json::from_str(l).unwrap()).collect();
-    assert_eq!(lines.len(), 2);
-    assert!(lines.iter().all(|l| l["ok"] == true));
-
-    let info = bin().args(["info", "--json"]).arg(&file).output().unwrap();
-    let v: serde_json::Value = serde_json::from_slice(&info.stdout).unwrap();
-    assert_eq!(v["pages"][0]["frames"].as_array().unwrap().len(), 2);
-
-    let dir = d.join("png");
-    assert!(bin().arg("export").arg(&file).arg("-o").arg(&dir).args(["--scale", "2"]).status().unwrap().success());
-    let a = std::fs::read(dir.join("A.png")).unwrap();
-    assert_eq!(&a[16..24], &[0, 0, 0, 200, 0, 0, 0, 100]);
-    assert!(dir.join("B.png").exists());
-
-    let svg = d.join("b.svg");
-    assert!(bin().arg("export").arg(&file).arg("-o").arg(&svg).args(["--node", "B"]).status().unwrap().success());
-    assert!(std::fs::read_to_string(&svg).unwrap().contains("<svg"));
-
-    let json = d.join("doc.json");
-    assert!(bin().arg("convert").arg(&file).arg(&json).status().unwrap().success());
-    let png = d.join("doc.png");
-    assert!(bin().arg("convert").arg(&json).arg(&png).status().unwrap().success());
-    assert!(std::fs::read(&png).unwrap().starts_with(b"\x89PNG"));
-
-    // A failing step: nonzero exit, error line printed.
-    let bad = d.join("bad.json");
-    std::fs::write(&bad, r#"[{"command":"select.all"},{"command":"nope"}]"#).unwrap();
-    let out = bin().arg("run").arg(&bad).output().unwrap();
-    assert_eq!(out.status.code(), Some(1));
-    assert!(String::from_utf8_lossy(&out.stdout).contains("\"ok\":false"));
-    std::fs::remove_dir_all(&d).ok();
-}
-
-#[test]
-fn run_takes_the_documented_gradient_shorthand() {
-    // #252: only MCP used to accept it; `run` said "`fills` must be paints or colours".
-    let d = tmp("gradient");
-    let script = d.join("s.json");
-    std::fs::write(
-        &script,
-        r##"[{"command":"shape.rectangle","params":{"x":0,"y":0,"width":200,"height":100}},
-            {"command":"node.set","params":{"ids":[2],"fills":[{"type":"linearGradient","stops":["#ff0000","#0000ff"],"from":[0,0.5],"to":[1,0.5]}]}}]"##,
-    )
-    .unwrap();
-    let file = d.join("g.figcraft");
-    let out = bin().arg("run").arg(&script).arg("--out").arg(&file).output().unwrap();
-    assert!(out.status.success(), "{}{}", String::from_utf8_lossy(&out.stdout), String::from_utf8_lossy(&out.stderr));
-    let json = d.join("g.json");
-    assert!(bin().arg("convert").arg(&file).arg(&json).status().unwrap().success());
-    let doc = std::fs::read_to_string(&json).unwrap();
-    assert!(doc.contains("\"kind\":\"linear\"") || doc.contains("\"kind\": \"linear\""), "{doc}");
-    std::fs::remove_dir_all(&d).ok();
-}
-
-#[test]
-fn mcp_over_stdio() {
-    let mut child = bin().arg("mcp").stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::null()).spawn().unwrap();
-    {
-        let stdin = child.stdin.as_mut().unwrap();
-        writeln!(stdin, r#"{{"jsonrpc":"2.0","id":1,"method":"initialize","params":{{"protocolVersion":"2025-06-18"}}}}"#).unwrap();
-        writeln!(stdin, r#"{{"jsonrpc":"2.0","method":"notifications/initialized"}}"#).unwrap();
-        writeln!(stdin, "garbage").unwrap();
-        writeln!(stdin, r#"{{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{{"name":"create_node","arguments":{{"type":"ellipse"}}}}}}"#)
-            .unwrap();
-    }
-    drop(child.stdin.take());
-    let out = child.wait_with_output().unwrap();
-    assert!(out.status.success());
-    let lines: Vec<serde_json::Value> = String::from_utf8_lossy(&out.stdout).lines().map(|l| serde_json::from_str(l).unwrap()).collect();
-    assert_eq!(lines.len(), 3);
-    assert_eq!(lines[0]["result"]["protocolVersion"], "2025-06-18");
-    assert_eq!(lines[1]["error"]["code"], -32700);
-    assert_eq!(lines[2]["result"]["isError"], false);
-}
-
-#[test]
-fn commands_json_lists_everything() {
-    let out = bin().args(["commands", "--json"]).output().unwrap();
-    let v: serde_json::Value = serde_json::from_slice(&out.stdout).unwrap();
-    assert!(v.as_array().unwrap().len() > 200);
-}
diff --git a/apps/figcraft-cli/tests/it/cli.rs b/apps/figcraft-cli/tests/it/cli.rs
new file mode 100644
index 000000000..b1aeb54a9
--- /dev/null
+++ b/apps/figcraft-cli/tests/it/cli.rs
@@ -0,0 +1,326 @@
+//! The binary end to end.
+
+use std::io::Write;
+use std::process::{Command, Stdio};
+
+fn bin() -> Command {
+    Command::new(env!("CARGO_BIN_EXE_figcraft-cli"))
+}
+
+fn tmp(name: &str) -> std::path::PathBuf {
+    let d = std::env::temp_dir().join(format!("figcraft-cli-test-{}-{name}", std::process::id()));
+    std::fs::create_dir_all(&d).unwrap();
+    d
+}
+
+#[test]
+fn bad_arguments_exit_2_without_panicking() {
+    for args in [
+        &[][..],
+        &["bogus"],
+        &["export"],
+        &["export", "x.figcraft"],
+        &["info", "--nope"],
+        &["render", "a", "-o"],
+        &["perf", "--shapes", "lots"],
+        &["mcp", "--attach", "notaport"],
+        // An attached app confines itself: roots go to `figcraft --control`.
+        &["mcp", "--attach", "7979", "--automation-read-root", "."],
+        &["mcp", "--automation-write-root"],
+        &["convert", "a"],
+    ] {
+        let out = bin().args(args).output().unwrap();
+        assert_eq!(out.status.code(), Some(2), "{args:?}: {}", String::from_utf8_lossy(&out.stderr));
+        let err = String::from_utf8_lossy(&out.stderr);
+        assert!(err.contains("USAGE"), "{args:?}");
+        assert!(!err.contains("panicked"));
+    }
+    let out = bin().args(["info", "/no/such/file.figcraft"]).output().unwrap();
+    assert_eq!(out.status.code(), Some(1));
+}
+
+/// `--help` / `-h` after a subcommand prints the usage on stdout and exits 0, as it does first
+/// (#1155), whatever else is on the line; nothing runs.
+#[test]
+fn help_after_a_subcommand_prints_the_usage() {
+    for args in [
+        &["--help"][..],
+        &["-h"],
+        &["help"],
+        &["mcp", "--help"],
+        &["mcp", "-h"],
+        &["info", "--help"],
+        &["export", "--help"],
+        &["export", "x.figcraft", "-o", "out", "--help"],
+        &["convert", "-h"],
+        &["render", "--help"],
+        &["run", "--help"],
+        &["commands", "--help"],
+        &["plugin", "publish", "--help"],
+        &["perf", "--help"],
+        &["mcp", "--attach", "notaport", "--help"],
+        &["mcp", "--bogus", "--help"],
+    ] {
+        let out = bin().args(args).stdin(Stdio::null()).output().unwrap();
+        assert_eq!(out.status.code(), Some(0), "{args:?}: {}", String::from_utf8_lossy(&out.stderr));
+        let text = String::from_utf8_lossy(&out.stdout);
+        assert!(text.contains("USAGE") && text.contains("figcraft-cli mcp"), "{args:?}: {text}");
+        assert!(out.stderr.is_empty(), "{args:?}: nothing on stderr, got {}", String::from_utf8_lossy(&out.stderr));
+    }
+    // A value that happens to be `-h` is still a value, not a request for help.
+    let out = bin().args(["commands", "--filter", "--help"]).output().unwrap();
+    assert_eq!(out.status.code(), Some(0));
+    assert!(!String::from_utf8_lossy(&out.stdout).contains("USAGE"), "--filter took `--help` as its text");
+}
+
+#[test]
+fn run_export_info_convert() {
+    let d = tmp("run");
+    let script = d.join("s.jsonl");
+    std::fs::write(&script, "{\"command\":\"frame.create\",\"params\":{\"x\":0,\"y\":0,\"width\":100,\"height\":50,\"name\":\"A\",\"props\":{\"fill\":\"#ff0000\"}}}\n{\"command\":\"frame.create\",\"params\":{\"x\":200,\"y\":0,\"width\":30,\"height\":30,\"name\":\"B\"}}\n").unwrap();
+    let file = d.join("doc.figcraft");
+    let out = bin().arg("run").arg(&script).arg("--out").arg(&file).output().unwrap();
+    assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
+    let lines: Vec<serde_json::Value> = String::from_utf8_lossy(&out.stdout).lines().map(|l| serde_json::from_str(l).unwrap()).collect();
+    assert_eq!(lines.len(), 2);
+    assert!(lines.iter().all(|l| l["ok"] == true));
+
+    let info = bin().args(["info", "--json"]).arg(&file).output().unwrap();
+    let v: serde_json::Value = serde_json::from_slice(&info.stdout).unwrap();
+    assert_eq!(v["pages"][0]["frames"].as_array().unwrap().len(), 2);
+
+    let dir = d.join("png");
+    assert!(bin().arg("export").arg(&file).arg("-o").arg(&dir).args(["--scale", "2"]).status().unwrap().success());
+    let a = std::fs::read(dir.join("A.png")).unwrap();
+    assert_eq!(&a[16..24], &[0, 0, 0, 200, 0, 0, 0, 100]);
+    assert!(dir.join("B.png").exists());
+
+    let svg = d.join("b.svg");
+    assert!(bin().arg("export").arg(&file).arg("-o").arg(&svg).args(["--node", "B"]).status().unwrap().success());
+    assert!(std::fs::read_to_string(&svg).unwrap().contains("<svg"));
+
+    let json = d.join("doc.json");
+    assert!(bin().arg("convert").arg(&file).arg(&json).status().unwrap().success());
+    let png = d.join("doc.png");
+    assert!(bin().arg("convert").arg(&json).arg(&png).status().unwrap().success());
+    assert!(std::fs::read(&png).unwrap().starts_with(b"\x89PNG"));
+
+    // A failing step: nonzero exit, error line printed.
+    let bad = d.join("bad.json");
+    std::fs::write(&bad, r#"[{"command":"select.all"},{"command":"nope"}]"#).unwrap();
+    let out = bin().arg("run").arg(&bad).output().unwrap();
+    assert_eq!(out.status.code(), Some(1));
+    assert!(String::from_utf8_lossy(&out.stdout).contains("\"ok\":false"));
+    std::fs::remove_dir_all(&d).ok();
+}
+
+/// `export` into a folder names the files as the app's export does (#1154): brackets, `+`, `&`,
+/// `%`, `#` and commas stay, what file systems refuse becomes `_`.
+#[test]
+fn export_file_names_keep_what_the_app_keeps() {
+    let d = tmp("names");
+    let script = d.join("s.json");
+    let names = ["Homepage - desktop (live + verbeteringen)", "Q&A, 50% #1 [v2]", "a:b*c?d|e"];
+    let steps: Vec<serde_json::Value> = names
+        .iter()
+        .enumerate()
+        .map(|(i, n)| serde_json::json!({"command": "frame.create", "params": {"x": i * 200, "y": 0, "width": 20, "height": 20, "name": n}}))
+        .collect();
+    std::fs::write(&script, serde_json::to_string(&steps).unwrap()).unwrap();
+    let file = d.join("doc.figcraft");
+    assert!(bin().arg("run").arg(&script).arg("--out").arg(&file).output().unwrap().status.success());
+    let dir = d.join("out");
+    let out = bin().arg("export").arg(&file).arg("-o").arg(&dir).output().unwrap();
+    assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
+    for want in ["Homepage - desktop (live + verbeteringen).png", "Q&A, 50% #1 [v2].png", "a_b_c_d_e.png"] {
+        assert!(dir.join(want).is_file(), "{want} in {:?}", std::fs::read_dir(&dir).unwrap().flatten().map(|e| e.file_name()).collect::<Vec<_>>());
+    }
+    std::fs::remove_dir_all(&d).ok();
+}
+
+#[test]
+fn run_takes_the_documented_gradient_shorthand() {
+    // #252: only MCP used to accept it; `run` said "`fills` must be paints or colours".
+    let d = tmp("gradient");
+    let script = d.join("s.json");
+    std::fs::write(
+        &script,
+        r##"[{"command":"shape.rectangle","params":{"x":0,"y":0,"width":200,"height":100}},
+            {"command":"node.set","params":{"ids":[2],"fills":[{"type":"linearGradient","stops":["#ff0000","#0000ff"],"from":[0,0.5],"to":[1,0.5]}]}}]"##,
+    )
+    .unwrap();
+    let file = d.join("g.figcraft");
+    let out = bin().arg("run").arg(&script).arg("--out").arg(&file).output().unwrap();
+    assert!(out.status.success(), "{}{}", String::from_utf8_lossy(&out.stdout), String::from_utf8_lossy(&out.stderr));
+    let json = d.join("g.json");
+    assert!(bin().arg("convert").arg(&file).arg(&json).status().unwrap().success());
+    let doc = std::fs::read_to_string(&json).unwrap();
+    assert!(doc.contains("\"kind\":\"linear\"") || doc.contains("\"kind\": \"linear\""), "{doc}");
+    std::fs::remove_dir_all(&d).ok();
+}
+
+#[test]
+fn mcp_over_stdio() {
+    let mut child = bin().arg("mcp").stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::null()).spawn().unwrap();
+    {
+        let stdin = child.stdin.as_mut().unwrap();
+        writeln!(stdin, r#"{{"jsonrpc":"2.0","id":1,"method":"initialize","params":{{"protocolVersion":"2025-06-18"}}}}"#).unwrap();
+        writeln!(stdin, r#"{{"jsonrpc":"2.0","method":"notifications/initialized"}}"#).unwrap();
+        writeln!(stdin, "garbage").unwrap();
+        writeln!(stdin, r#"{{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{{"name":"create_node","arguments":{{"type":"ellipse"}}}}}}"#)
+            .unwrap();
+    }
+    drop(child.stdin.take());
+    let out = child.wait_with_output().unwrap();
+    assert!(out.status.success());
+    let lines: Vec<serde_json::Value> = String::from_utf8_lossy(&out.stdout).lines().map(|l| serde_json::from_str(l).unwrap()).collect();
+    assert_eq!(lines.len(), 3);
+    assert_eq!(lines[0]["result"]["protocolVersion"], "2025-06-18");
+    assert_eq!(lines[1]["error"]["code"], -32700);
+    assert_eq!(lines[2]["result"]["isError"], false);
+}
+
+#[test]
+fn mcp_over_stdio_confined_to_automation_roots() {
+    let d = tmp("roots");
+    for sub in ["in", "out", "outside"] {
+        std::fs::create_dir_all(d.join(sub)).unwrap();
+    }
+    let p = |rel: &str| d.join(rel).to_string_lossy().into_owned();
+    // A root that isn't a folder stops the server before it serves.
+    let out = bin().args(["mcp", "--automation-read-root", &p("missing")]).output().unwrap();
+    assert_eq!(out.status.code(), Some(1));
+    assert!(String::from_utf8_lossy(&out.stderr).contains("--automation-read-root"));
+    let mut child = bin()
+        .args(["mcp", "--automation-read-root", &p("in"), "--automation-write-root", &p("out")])
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::null())
+        .spawn()
+        .unwrap();
+    {
+        let stdin = child.stdin.as_mut().unwrap();
+        let call = |id: u32, tool: &str, args: serde_json::Value| {
+            serde_json::json!({"jsonrpc": "2.0", "id": id, "method": "tools/call", "params": {"name": tool, "arguments": args}}).to_string()
+        };
+        writeln!(stdin, r#"{{"jsonrpc":"2.0","id":1,"method":"initialize","params":{{"protocolVersion":"2025-06-18"}}}}"#).unwrap();
+        writeln!(stdin, "{}", call(2, "create_node", serde_json::json!({"type": "ellipse"}))).unwrap();
+        writeln!(stdin, "{}", call(3, "save_file", serde_json::json!({"path": p("outside/a.figcraft")}))).unwrap();
+        writeln!(stdin, "{}", call(4, "save_file", serde_json::json!({"path": p("out/a.figcraft")}))).unwrap();
+        writeln!(stdin, "{}", call(5, "open_file", serde_json::json!({"path": p("outside/a.figcraft")}))).unwrap();
+        writeln!(stdin, "{}", call(6, "open_file", serde_json::json!({"path": p("out/a.figcraft")}))).unwrap();
+    }
+    drop(child.stdin.take());
+    let out = child.wait_with_output().unwrap();
+    assert!(out.status.success());
+    let lines: Vec<serde_json::Value> = String::from_utf8_lossy(&out.stdout).lines().map(|l| serde_json::from_str(l).unwrap()).collect();
+    assert_eq!(lines.len(), 6);
+    assert!(lines[0]["result"]["instructions"].as_str().unwrap().contains("only these folders may be read"));
+    let error = |i: usize| lines[i]["result"]["isError"] == true;
+    assert!(!error(1) && error(2) && !error(3) && error(4) && !error(5), "{lines:?}");
+    assert!(lines[2]["result"]["content"][0]["text"].as_str().unwrap().contains("automation path rejected"));
+    assert!(d.join("out/a.figcraft").is_file() && !d.join("outside/a.figcraft").exists());
+    let _ = std::fs::remove_dir_all(&d);
+}
+
+#[test]
+fn commands_json_lists_everything() {
+    let out = bin().args(["commands", "--json"]).output().unwrap();
+    let v: serde_json::Value = serde_json::from_slice(&out.stdout).unwrap();
+    assert!(v.as_array().unwrap().len() > 200);
+}
+
+/// The automation roots confine the file subcommands too, not just `mcp` (#833): a read outside a
+/// root, and a write outside a write root, are refused and leave no file behind. Without the flags
+/// the same commands behave as they always did.
+#[test]
+fn file_subcommands_are_confined_to_automation_roots() {
+    let d = tmp("file-roots");
+    let _ = std::fs::remove_dir_all(&d);
+    for sub in ["in", "out"] {
+        std::fs::create_dir_all(d.join(sub)).unwrap();
+    }
+    let p = |rel: &str| d.join(rel).to_string_lossy().into_owned();
+    let out_of = |o: &std::process::Output| String::from_utf8_lossy(&o.stderr).into_owned();
+
+    // A document to work on, made unconfined.
+    std::fs::write(d.join("in/make.json"), br#"[{"command":"shape.rectangle","params":{"x":0,"y":0,"width":40,"height":20}}]"#).unwrap();
+    let made = bin().args(["run", &p("in/make.json"), "--out", &p("in/doc.figcraft")]).output().unwrap();
+    assert!(made.status.success(), "{}", out_of(&made));
+
+    // Inside the roots: renders as usual.
+    let ok = bin()
+        .args(["render", &p("in/doc.figcraft"), "-o", &p("out/ok.png"), "--automation-read-root", &p("in"), "--automation-write-root", &p("out")])
+        .output()
+        .unwrap();
+    assert!(ok.status.success(), "{}", out_of(&ok));
+    assert!(d.join("out/ok.png").is_file());
+
+    // A write outside the write root is refused, and nothing is written.
+    let escaped = d.join("escaped.png");
+    let refused = bin()
+        .args([
+            "render",
+            &p("in/doc.figcraft"),
+            "-o",
+            &escaped.to_string_lossy(),
+            "--automation-read-root",
+            &p("in"),
+            "--automation-write-root",
+            &p("out"),
+        ])
+        .output()
+        .unwrap();
+    assert!(!refused.status.success());
+    assert!(out_of(&refused).contains("may be written"), "{}", out_of(&refused));
+    assert!(!escaped.exists(), "the refused render wrote a file anyway");
+
+    // No write root at all: writing is refused outright, reading still works.
+    let no_write = bin().args(["render", &p("in/doc.figcraft"), "-o", &p("out/no.png"), "--automation-read-root", &p("in")]).output().unwrap();
+    assert!(!no_write.status.success());
+    assert!(out_of(&no_write).contains("no folder may be written"), "{}", out_of(&no_write));
+
+    // A read outside every root is refused: `info` on the document with only `out` readable.
+    let read_refused = bin().args(["info", &p("in/doc.figcraft"), "--automation-read-root", &p("out")]).output().unwrap();
+    assert!(!read_refused.status.success());
+    assert!(out_of(&read_refused).contains("may be read"), "{}", out_of(&read_refused));
+
+    // `convert` and `run` take them as well, and a root that is not a folder is refused.
+    let missing = bin().args(["convert", &p("in/doc.figcraft"), &p("out/c.svg"), "--automation-read-root", &p("missing")]).output().unwrap();
+    assert!(!missing.status.success());
+    assert!(out_of(&missing).contains("automation-read-root"), "{}", out_of(&missing));
+
+    // Unconfined, the same render still writes wherever it is told.
+    let plain = bin().args(["render", &p("in/doc.figcraft"), "-o", &escaped.to_string_lossy()]).output().unwrap();
+    assert!(plain.status.success(), "{}", out_of(&plain));
+    assert!(escaped.is_file());
+    let _ = std::fs::remove_dir_all(&d);
+}
+
+/// An output path that is a symbolic link is written through, to its target, as `std::fs::write`
+/// always did. Routing the CLI's writes through `file_access` for #833 would otherwise have
+/// replaced the link with a regular file, because that write stages the bytes and renames them
+/// into place.
+#[cfg(unix)]
+#[test]
+fn an_unconfined_write_follows_a_symbolic_link() {
+    let d = tmp("symlink-out");
+    let _ = std::fs::remove_dir_all(&d);
+    std::fs::create_dir_all(d.join("real")).unwrap();
+    let p = |rel: &str| d.join(rel).to_string_lossy().into_owned();
+    std::fs::write(d.join("in.json"), br#"[{"command":"shape.rectangle","params":{"x":0,"y":0,"width":40,"height":20}}]"#).unwrap();
+    let made = bin().args(["run", &p("in.json"), "--out", &p("doc.figcraft")]).output().unwrap();
+    assert!(made.status.success(), "{}", String::from_utf8_lossy(&made.stderr));
+
+    let target = d.join("real/target.png");
+    std::fs::write(&target, b"placeholder").unwrap();
+    let link = d.join("link.png");
+    std::os::unix::fs::symlink(&target, &link).unwrap();
+
+    let out = bin().args(["render", &p("doc.figcraft"), "-o", &link.to_string_lossy()]).output().unwrap();
+    assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
+    assert!(std::fs::symlink_metadata(&link).unwrap().file_type().is_symlink(), "the link is still a link");
+    let written = std::fs::read(&target).unwrap();
+    assert!(written.starts_with(b"\x89PNG"), "the target holds the render, not the placeholder");
+    let _ = std::fs::remove_dir_all(&d);
+}
diff --git a/apps/figcraft-cli/tests/export_depth.rs b/apps/figcraft-cli/tests/it/export_depth.rs
similarity index 97%
rename from apps/figcraft-cli/tests/export_depth.rs
rename to apps/figcraft-cli/tests/it/export_depth.rs
index d8b3ef36e..37350c1ed 100644
--- a/apps/figcraft-cli/tests/export_depth.rs
+++ b/apps/figcraft-cli/tests/it/export_depth.rs
@@ -1,5 +1,4 @@
 //! Depth refusal through the actual CLI, including its exit status and destination writes.
-#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
 
 use figcraft_doc::color::{Color, Paint};
 use figcraft_doc::{Document, NodeKind};
diff --git a/apps/figcraft-cli/tests/fonts.rs b/apps/figcraft-cli/tests/it/fonts.rs
similarity index 63%
rename from apps/figcraft-cli/tests/fonts.rs
rename to apps/figcraft-cli/tests/it/fonts.rs
index c5901ac50..a48056bdb 100644
--- a/apps/figcraft-cli/tests/fonts.rs
+++ b/apps/figcraft-cli/tests/it/fonts.rs
@@ -1,6 +1,5 @@
 //! Headless runs lay text out with the installed fonts, like the desktop app, unless
 //! `--no-system-fonts` or `FIGCRAFT_NO_SYSTEM_FONTS=1` opts out.
-#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
 
 use std::process::Command;
 
@@ -45,3 +44,25 @@ fn headless_runs_resolve_installed_families_unless_opted_out() {
     assert_eq!(run_one("face", face.clone(), &[], false)["family"], json!(installed), "text uses the installed family");
     assert_ne!(run_one("face", face, &["--no-system-fonts"], false)["family"], json!(installed), "opted out, it falls back");
 }
+
+#[test]
+fn info_lists_the_fonts_a_file_uses_that_are_missing() {
+    let d = std::env::temp_dir().join(format!("figcraft-cli-missing-{}", std::process::id()));
+    std::fs::create_dir_all(&d).unwrap();
+    let (script, file) = (d.join("make.json"), d.join("doc.figcraft"));
+    let text =
+        |family: &str| json!({"command": "text.create", "params": {"text": "Hamburgefonstiv", "x": 0, "y": 0, "props": {"fontFamily": family}}});
+    std::fs::write(&script, json!([text("FigCraft Missing CLI"), text("FigCraft Missing CLI")]).to_string()).unwrap();
+    let cli = || Command::new(env!("CARGO_BIN_EXE_figcraft-cli"));
+    let made = cli().arg("run").arg(&script).arg("--out").arg(&file).output().unwrap();
+    assert!(made.status.success(), "{}", String::from_utf8_lossy(&made.stderr));
+
+    let out = cli().arg("info").arg(&file).arg("--json").output().unwrap();
+    assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
+    let v: Value = serde_json::from_slice(&out.stdout).unwrap();
+    assert_eq!(v["missingFonts"], json!([{"family": "FigCraft Missing CLI", "layers": 2}]));
+
+    let out = cli().arg("info").arg(&file).output().unwrap();
+    let shown = String::from_utf8_lossy(&out.stdout);
+    assert!(shown.contains("missing font \"FigCraft Missing CLI\": 2 text layers"), "{shown}");
+}
diff --git a/apps/figcraft-cli/tests/it/main.rs b/apps/figcraft-cli/tests/it/main.rs
new file mode 100644
index 000000000..ae4b0488f
--- /dev/null
+++ b/apps/figcraft-cli/tests/it/main.rs
@@ -0,0 +1,12 @@
+//! The crate's integration tests, built as one test binary.
+
+#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+mod cli;
+#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+mod export_depth;
+#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+mod fonts;
+#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+mod pdf;
+#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+mod pdf_print;
diff --git a/apps/figcraft-cli/tests/pdf.rs b/apps/figcraft-cli/tests/it/pdf.rs
similarity index 97%
rename from apps/figcraft-cli/tests/pdf.rs
rename to apps/figcraft-cli/tests/it/pdf.rs
index 28d5ca6cf..185d5b608 100644
--- a/apps/figcraft-cli/tests/pdf.rs
+++ b/apps/figcraft-cli/tests/it/pdf.rs
@@ -1,5 +1,4 @@
 //! `figcraft-cli export --format pdf` and `convert … .pdf` end to end.
-#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
 
 use std::process::Command;
 
diff --git a/apps/figcraft-cli/tests/pdf_print.rs b/apps/figcraft-cli/tests/it/pdf_print.rs
similarity index 97%
rename from apps/figcraft-cli/tests/pdf_print.rs
rename to apps/figcraft-cli/tests/it/pdf_print.rs
index b2ce3c9af..f12725ed6 100644
--- a/apps/figcraft-cli/tests/pdf_print.rs
+++ b/apps/figcraft-cli/tests/it/pdf_print.rs
@@ -1,5 +1,4 @@
 //! `figcraft-cli export` with PDF print options: bleed, marks, CMYK; bad lengths are usage errors.
-#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
 
 use std::process::Command;
 
diff --git a/apps/figcraft-server/src/config.rs b/apps/figcraft-server/src/config.rs
index bd587b767..d5f4f761e 100644
--- a/apps/figcraft-server/src/config.rs
+++ b/apps/figcraft-server/src/config.rs
@@ -135,9 +135,23 @@ impl Config {
     /// abuse contact, or one whose clients would all count as its proxy).
     pub fn warnings(&self) -> Vec<String> {
         let mut out = Vec::new();
+        let client_max = NetLimits::default().max_server_message >> 20;
+        if usize::try_from(self.file_mb()).is_ok_and(|mb| mb >= client_max) {
+            out.push(format!(
+                "max_file_mb is {}: the app opens files of up to {} MiB, so a file that large can't be opened",
+                self.file_mb(),
+                client_max - 1
+            ));
+        }
         if !self.open_publish {
             return out;
         }
+        if self.file_mb() > 64 {
+            out.push(format!(
+                "open_publish is on with max_file_mb = {}: anyone may send messages that large, and the memory set aside for reading and queueing them grows to eight times it; keep it at 64 or less on a public server",
+                self.file_mb()
+            ));
+        }
         if self.operator_contact.trim().is_empty() {
             out.push("open_publish is on but operator_contact is empty: people can't reach you about abuse; set it (and terms_url)".into());
         }
@@ -168,7 +182,7 @@ impl Config {
             return Err("`idle_days` must be from 0 to 3650".into());
         }
         let terms = self.terms_url.trim();
-        if !terms.is_empty() && !(terms.starts_with("https://") || terms.starts_with("http://")) || terms.contains(char::is_whitespace) {
+        if !(terms.is_empty() || terms.starts_with("https://") || terms.starts_with("http://")) || terms.contains(char::is_whitespace) {
             return Err("`terms_url` must be a web address (https://…)".into());
         }
         if self.operator_contact.chars().count() > 120 || self.operator_contact.chars().any(char::is_control) || terms.len() > 500 {
@@ -253,8 +267,9 @@ impl Config {
         }
     }
 
-    /// Largest message a client may send when open to the public: a whole file (or plugin bundle)
-    /// and a margin, not the core's 64 MiB.
+    /// Largest message a client may send: a whole file (or plugin bundle) and a margin. Open to the
+    /// public this is also the cap (strangers' files stay small); a private server never goes below
+    /// the core's 64 MiB, and a `max_file_mb` above it raises the cap with it.
     fn open_message(&self) -> usize {
         usize::try_from(self.file_mb().max(self.max_plugin_mb).saturating_add(1).saturating_mul(1 << 20)).unwrap_or(usize::MAX)
     }
@@ -265,9 +280,9 @@ impl Config {
     fn core(&self) -> figcraft_collab::Limits {
         let base = figcraft_collab::Limits { max_peers: self.max_people, ..figcraft_collab::Limits::default() };
         if !self.open_publish {
-            return base;
+            return figcraft_collab::Limits { max_message_bytes: base.max_message_bytes.max(self.open_message()), ..base };
         }
-        let max = self.open_message().min(base.max_message_bytes);
+        let max = self.open_message();
         let file = usize::try_from(self.file_mb().saturating_mul(1 << 20)).unwrap_or(usize::MAX);
         figcraft_collab::Limits { max_message_bytes: max, max_log_bytes: (file / 4).max(256 << 10), ..base }
     }
@@ -279,21 +294,24 @@ impl Config {
     pub fn net(&self) -> NetLimits {
         let base = NetLimits { max_connections: self.max_connections, trusted_proxy: self.proxy().ok().flatten(), ..NetLimits::default() };
         if !self.open_publish {
-            return base;
+            let max = base.max_client_message.max(self.open_message());
+            return NetLimits { max_client_message: max, max_queued_bytes: base.max_queued_bytes.max(max.saturating_add(1 << 20)), ..base };
         }
-        let max = self.open_message().min(base.max_client_message);
+        let max = self.open_message();
         // Shared budgets: one block of addresses (an IPv4 address, an IPv6 /48) gets at most an
-        // eighth of each, and its biggest consumers are dropped first.
-        let (queued, reading) = (256usize << 20, 192usize << 20);
+        // eighth of each, and its biggest consumers are dropped first. Each still fits one whole
+        // message, or a file as large as `max_file_mb` could never arrive.
+        let one = max.saturating_add(1 << 20);
+        let (queued, reading) = ((256usize << 20).max(one.saturating_mul(8)), (192usize << 20).max(one.saturating_mul(8)));
         NetLimits {
             max_per_address: self.max_connections_per_ip,
             max_client_message: max,
-            max_queued_bytes: max.saturating_add(1 << 20),
+            max_queued_bytes: one,
             max_queued_block: queued / 8,
             max_queued_total: queued,
-            max_reading_block: max.saturating_add(1 << 20).min(reading / 8),
+            max_reading_block: one.min(reading / 8),
             max_reading_total: reading,
-            max_in_flight: 128 << 20,
+            max_in_flight: (128usize << 20).max(one),
             reserve_for_sessions: self.max_connections / 8,
             request_idle: std::time::Duration::from_secs(20),
             ..base
diff --git a/apps/figcraft-server/src/disk.rs b/apps/figcraft-server/src/disk.rs
index f58f25b21..af6e0f990 100644
--- a/apps/figcraft-server/src/disk.rs
+++ b/apps/figcraft-server/src/disk.rs
@@ -8,8 +8,10 @@
 //!   length (u32 LE), CRC-32 (u32 LE), one [`Journal`] entry in the wire encoding.
 //!
 //! Compaction writes the next generation's snapshot, then an empty log of that generation. A log
-//! whose generation isn't the snapshot's is from before a compaction that was cut short: what it
-//! holds is in the snapshot already. A log ends at its first damaged record (a write cut short).
+//! whose generation isn't the snapshot's is usually from before a compaction that was cut short
+//! (what it holds is in the snapshot already), but no checksum covers either generation, so the
+//! store replays such a log anyway and reports any change the snapshot lacked. A log ends at its
+//! first damaged record (a write cut short).
 
 use std::fs::{self, File};
 use std::io::{self, Read, Write};
diff --git a/apps/figcraft-server/src/hardening_tests.rs b/apps/figcraft-server/src/hardening_tests.rs
index 086539cae..92b177105 100644
--- a/apps/figcraft-server/src/hardening_tests.rs
+++ b/apps/figcraft-server/src/hardening_tests.rs
@@ -838,3 +838,25 @@ fn a_library_publish_that_fails_keeps_serving_the_old_version() {
     assert_eq!(served(fetch(&mut store)), (2, v2));
     assert!(!files.join(crate::store::library_name(1)).exists(), "the old version is deleted");
 }
+
+#[test]
+fn a_library_publish_cannot_claim_the_highest_version() {
+    let dir = TempDir::new("libmax");
+    let mut store = Store::open(dir.path(), config(dir.path()).store()).unwrap();
+    let (file, ..) = store.publish("Library", &snapshot("Library")).unwrap();
+    let mut s = Session::new();
+    let f = s.execute("frame.create", &json!({"x": 0, "y": 0, "width": 50, "height": 20, "name": "Button"})).unwrap()["id"].as_u64().unwrap();
+    s.execute("component.create", &json!({"ids": [f]})).unwrap();
+    s.execute("library.publish", &json!({})).unwrap();
+    let mut lib = s.doc().unwrap().published.clone().unwrap().as_ref().clone();
+    let mut archive = |version: u64| {
+        lib.manifest.version = version;
+        figcraft_engine::library_server::archive(&lib).unwrap()
+    };
+    let high = 1u64 << 32;
+    assert!(store.publish_library(&file.id, &archive(u64::MAX)).is_err(), "a first publish can't claim the highest version");
+    assert_eq!(store.publish_library(&file.id, &archive(high)).unwrap(), high, "the highest accepted first version goes in");
+    assert_eq!(store.publish_library(&file.id, &archive(high + 1)).unwrap(), high + 1, "and a newer one still follows it");
+    assert!(store.publish_library(&file.id, &archive(u64::MAX)).is_err(), "a jump to the highest version is refused");
+    assert_eq!(store.publish_library(&file.id, &archive(high + 2)).unwrap(), high + 2, "later versions still go in");
+}
diff --git a/apps/figcraft-server/src/public_tests.rs b/apps/figcraft-server/src/public_tests.rs
index fea2667e9..dc86d1232 100644
--- a/apps/figcraft-server/src/public_tests.rs
+++ b/apps/figcraft-server/src/public_tests.rs
@@ -164,6 +164,64 @@ fn caps_per_address_and_for_everyone() {
     assert_eq!(store.publish_open(ip("198.51.100.8"), "No", &snapshot("No")).unwrap_err(), KEY_ONLY);
 }
 
+#[test]
+fn caps_per_address_count_the_wider_ipv6_blocks() {
+    let dir = TempDir::new("block-caps");
+    let mut c = open(dir.path());
+    c.max_files_per_ip = 1;
+    c.publishes_per_hour = 1000;
+    let mut store = Store::open(dir.path(), c.store()).unwrap();
+    // A /48 keeps 4 times one address's files: /64s in different /56s of it.
+    for i in 0..4 {
+        store.publish_open(ip(&format!("2001:db8:1:{:x}::1", i << 8)), "One", &snapshot("One")).unwrap();
+    }
+    let e = store.publish_open(ip("2001:db8:1:400::1"), "Five", &snapshot("Five")).unwrap_err();
+    assert!(e.contains("files on this server already"), "{e}");
+    // A /56 keeps twice one address's files.
+    store.publish_open(ip("2001:db8:2:1::1"), "One", &snapshot("One")).unwrap();
+    store.publish_open(ip("2001:db8:2:2::1"), "Two", &snapshot("Two")).unwrap();
+    let e = store.publish_open(ip("2001:db8:2:3::1"), "Three", &snapshot("Three")).unwrap_err();
+    assert!(e.contains("files on this server already"), "{e}");
+    drop(store);
+    // Bytes: one address keeps one file's worth, so a /48 keeps 4 files.
+    let probe = TempDir::new("block-caps-probe");
+    let mut p = Store::open(probe.path(), open(probe.path()).store()).unwrap();
+    let size = p.publish_open(ip("203.0.113.1"), "One", &snapshot("One")).unwrap().0.bytes;
+    let dir = TempDir::new("block-caps-bytes");
+    let mut s = open(dir.path()).store();
+    s.hosting.max_files_per_ip = 100;
+    s.hosting.max_bytes_per_ip = size;
+    let mut store = Store::open(dir.path(), s).unwrap();
+    for i in 0..4 {
+        store.publish_open(ip(&format!("2001:db8:3:{:x}::1", i << 8)), "One", &snapshot("One")).unwrap();
+    }
+    let e = store.publish_open(ip("2001:db8:3:400::1"), "One", &snapshot("One")).unwrap_err();
+    assert!(e.contains("MiB it may keep"), "{e}");
+}
+
+#[test]
+fn edits_count_the_wider_ipv6_blocks_too() {
+    use figcraft_collab_net::hub::Backend;
+    let probe = TempDir::new("block-room-probe");
+    let mut p = Store::open(probe.path(), open(probe.path()).store()).unwrap();
+    let size = p.publish_open(ip("203.0.113.1"), "One", &snapshot("One")).unwrap().0.bytes;
+    let dir = TempDir::new("block-room");
+    let mut s = open(dir.path()).store();
+    s.hosting.max_files_per_ip = 100;
+    // One address keeps 2.25 files' worth, so its /56 keeps 4.5.
+    s.hosting.max_bytes_per_ip = size * 2 + size / 4;
+    let mut store = Store::open(dir.path(), s).unwrap();
+    let mut ids = Vec::new();
+    for i in 0..4 {
+        ids.push(store.publish_open(ip(&format!("2001:db8:4:{i:x}::1")), "One", &snapshot("One")).unwrap().0.id);
+    }
+    let server = Backend::open(&mut store, &ids[0]).unwrap();
+    // Its own /64 has room for this, but its /56 doesn't.
+    let e = Backend::room(&mut store, &ids[0], &server, (size * 3 / 4) as usize).unwrap_err();
+    assert!(e.contains("have reached their"), "{e}");
+    Backend::room(&mut store, &ids[0], &server, (size / 4) as usize).unwrap();
+}
+
 #[test]
 fn idle_files_published_without_the_key_expire() {
     let dir = TempDir::new("expiry");
@@ -196,6 +254,22 @@ fn idle_files_published_without_the_key_expire() {
     assert!(store.listing(&|_| None).iter().all(|r| r.info.id != fresh.id));
 }
 
+#[test]
+fn offline_commands_do_not_sweep_idle_files() {
+    let dir = TempDir::new("offline-sweep");
+    let mut c = open(dir.path());
+    c.idle_days = 30.0;
+    let mut store = Store::open(dir.path(), c.store()).unwrap();
+    let (public, ..) = store.publish_open(ip("203.0.113.9"), "Public", &snapshot("Public")).unwrap();
+    store.age(&public.id, 31 * 86_400);
+    drop(store);
+    let store = Store::try_open(dir.path(), c.store()).unwrap().unwrap();
+    drop(store);
+    assert!(dir.path().join("files").join(&public.id).exists(), "a command deleted an idle file");
+    let _serving = Store::open(dir.path(), c.store()).unwrap();
+    assert!(!dir.path().join("files").join(&public.id).exists());
+}
+
 #[test]
 fn rate_limits_and_blocks_refuse_with_a_reason() {
     let dir = TempDir::new("limits");
@@ -413,7 +487,7 @@ fn open_mode_has_safe_defaults_and_warns_the_operator() {
     assert_eq!(open.net().request_idle, Duration::from_secs(20), "idle one-shot requests go quickly");
     assert_eq!(open.net().reserve_for_sessions, 512 / 8);
     assert_eq!(open.net().max_client_message, 17 << 20);
-    assert_eq!(private.net().max_client_message, NetLimits::default().max_client_message, "unchanged when private");
+    assert_eq!(private.net().max_client_message, 65 << 20, "private: a 64 MiB file and a margin");
     let w = open.warnings().join("\n");
     assert!(w.contains("operator_contact is empty") && w.contains("trusted_proxy"), "{w}");
     let set = Config { operator_contact: "abuse@example.com".into(), trusted_proxy: Some("127.0.0.1".into()), max_file_mb: Some(8), ..open };
@@ -493,3 +567,34 @@ fn open_connections_never_reach_what_needs_the_key() {
     assert!(!format!("{info:?}").contains(&k));
     server.stop();
 }
+
+#[test]
+fn files_above_64_mib_fit_every_limit() {
+    // `max_file_mb` may go up to 4096: every cap a whole file's message meets on its way in must
+    // follow it, or the upload is dropped by the transport before the server can say why.
+    for open_publish in [false, true] {
+        let cfg = Config { open_publish, max_file_mb: Some(256), public_url: Some("wss://figcraft.example.com/".into()), ..Config::default() };
+        let (net, core, file) = (cfg.net(), cfg.store().core, 256usize << 20);
+        assert!(net.max_client_message > file, "open={open_publish}: {}", net.max_client_message);
+        assert!(net.max_queued_bytes > file && net.max_reading_block > file && net.max_in_flight > file, "open={open_publish}: {net:?}");
+        assert!(net.max_reading_total >= net.max_reading_block && net.max_queued_total >= net.max_queued_block);
+        assert!(core.max_message_bytes > file, "open={open_publish}: {}", core.max_message_bytes);
+    }
+    // A client takes such a file too, but caps what any server may make it buffer at 1 GiB.
+    assert_eq!(NetLimits::default().max_server_message, 1 << 30);
+}
+
+#[test]
+fn large_files_warn_the_operator() {
+    let public_url = Some("wss://figcraft.example.com/".into());
+    let warns = |open_publish, mb| {
+        Config { open_publish, max_file_mb: Some(mb), public_url: public_url.clone(), ..Config::default() }.warnings().join(
+            "
+",
+        )
+    };
+    assert!(!warns(true, 64).contains("max_file_mb"), "{}", warns(true, 64));
+    assert!(warns(true, 65).contains("open_publish is on with max_file_mb = 65"), "{}", warns(true, 65));
+    assert!(!warns(false, 1023).contains("max_file_mb"), "{}", warns(false, 1023));
+    assert!(warns(false, 1024).contains("can't be opened"), "{}", warns(false, 1024));
+}
diff --git a/apps/figcraft-server/src/server_tests.rs b/apps/figcraft-server/src/server_tests.rs
index 153bb5ab6..f60150da9 100644
--- a/apps/figcraft-server/src/server_tests.rs
+++ b/apps/figcraft-server/src/server_tests.rs
@@ -261,7 +261,9 @@ fn fuzzed_frames_dont_hurt_the_server() {
                 break;
             }
         }
-        let _ = ws.read();
+        // read() returns Result<Message>, not a lock guard; the fuzz loop ends here on purpose and
+        // the close frame from the server is not interesting.
+        let _ = ws.read(); // NOSONAR
     }
     // Still serving, the file intact.
     let mut b = join(&p.edit, "Bo");
diff --git a/apps/figcraft-server/src/store.rs b/apps/figcraft-server/src/store.rs
index 538adefff..a60d482d0 100644
--- a/apps/figcraft-server/src/store.rs
+++ b/apps/figcraft-server/src/store.rs
@@ -42,7 +42,7 @@ use figcraft_collab::message::{
     PluginReply, PluginReq, ReportInfo, Usage,
 };
 use figcraft_collab::{Change, Replica, Server, same_secret};
-use figcraft_collab_net::hub::{Admission, Backend, Closing, Handled, OpenFile, ip_key};
+use figcraft_collab_net::hub::{Admission, Backend, Closing, Handled, OpenFile, ip_blocks, ip_key};
 use figcraft_collab_net::token;
 use serde::{Deserialize, Serialize};
 use sha2::{Digest, Sha256};
@@ -291,7 +291,17 @@ fn valid_id(s: &str) -> bool {
 
 /// A name others may see: trimmed, no control characters, at most 256 characters.
 fn clean_name(s: &str) -> String {
-    s.trim().chars().filter(|c| !c.is_control()).take(256).collect()
+    s.trim().chars().filter(|c| !c.is_control() && !is_bidi_control(*c)).take(256).collect()
+}
+
+/// A report's reason: trimmed, control and bidi characters turned into spaces, at most `MAX_REASON` characters.
+fn clean_reason(s: &str) -> String {
+    s.trim().chars().map(|c| if c.is_control() || is_bidi_control(c) { ' ' } else { c }).take(MAX_REASON).collect()
+}
+
+/// Bidirectional format characters, which could reorder what a terminal shows.
+fn is_bidi_control(c: char) -> bool {
+    matches!(c, '\u{61C}' | '\u{200E}' | '\u{200F}' | '\u{202A}'..='\u{202E}' | '\u{2066}'..='\u{2069}')
 }
 
 /// Take the data directory's lock: `None` when someone else holds it.
@@ -302,6 +312,10 @@ pub fn lock(root: &Path) -> Result<Option<File>, String> {
     #[cfg(unix)]
     std::os::unix::fs::DirBuilderExt::mode(&mut dirs, 0o700);
     dirs.create(root).map_err(|e| format!("can't create the data directory {}: {e}", root.display()))?;
+    // `DirBuilder` only applies the mode to directories it creates; tighten an existing one too.
+    #[cfg(unix)]
+    fs::set_permissions(root, std::os::unix::fs::PermissionsExt::from_mode(0o700))
+        .map_err(|e| format!("can't restrict the data directory {}: {e}", root.display()))?;
     let f = OpenOptions::new()
         .create(true)
         .truncate(false)
@@ -334,16 +348,27 @@ fn write_key(root: &Path) -> Result<String, String> {
     Ok(key)
 }
 
+/// The highest version a file's first library publish may claim. Publishing counts up by one (a
+/// library carried over from another server keeps its number), so no real history gets near it.
+/// Later publishes may go one past the version on the server, so there is always a next one.
+const MAX_FIRST_LIBRARY_VERSION: u64 = 1 << 32;
+
 impl Store {
     /// Use the data directory `root` (made if missing). Fails when another server or command holds
     /// it. Files that can't be read are skipped and listed in [`problems`](Self::problems).
     pub fn open(root: &Path, cfg: StoreConfig) -> Result<Store, String> {
-        Self::try_open(root, cfg)?.ok_or_else(|| format!("another figcraft-server (or a command) is using {}", root.display()))
+        let mut store = Self::try_open(root, cfg)?.ok_or_else(|| format!("another figcraft-server (or a command) is using {}", root.display()))?;
+        store.sweep();
+        Ok(store)
     }
 
-    /// [`open`](Self::open), or `None` when someone else holds the directory.
+    /// [`open`](Self::open) without the expiry sweep (for commands that only look or edit), or
+    /// `None` when someone else holds the directory.
     pub fn try_open(root: &Path, cfg: StoreConfig) -> Result<Option<Store>, String> {
         let Some(lock) = lock(root)? else { return Ok(None) };
+        for name in [KEY, BLOCKED, REPORTS] {
+            let _ = fs::remove_file(disk::temp_of(&root.join(name)));
+        }
         let key = load_key(root)?;
         let dir = root.join(FILES);
         fs::create_dir_all(&dir).map_err(|e| format!("can't create {}: {e}", dir.display()))?;
@@ -374,7 +399,6 @@ impl Store {
         store.scan(&dir);
         store.blocked = store.read_list::<String>(BLOCKED).iter().filter_map(|s| s.parse().ok()).map(ip_key).collect();
         store.reports = store.read_list(REPORTS);
-        store.sweep();
         Ok(Some(store))
     }
 
@@ -425,12 +449,20 @@ impl Store {
     /// A file folder's description and links, after checking its snapshot and log. Leftover
     /// temporary files (writes cut short) are removed.
     fn check(&self, path: &Path) -> Result<Entry, String> {
-        for name in [SNAPSHOT, LOG, META, LINKS] {
+        for name in [SNAPSHOT, LOG, META, LINKS, USAGE] {
             let tmp = disk::temp_of(&path.join(name));
             if tmp.exists() {
                 let _ = fs::remove_file(&tmp);
             }
         }
+        if let Ok(entries) = fs::read_dir(path) {
+            for e in entries.flatten() {
+                let name = e.file_name().to_string_lossy().into_owned();
+                if name.starts_with("library-") && name.ends_with(".bin.tmp") {
+                    let _ = fs::remove_file(e.path());
+                }
+            }
+        }
         let meta: Meta = serde_json::from_slice(&disk::read_capped(&path.join(META), 1 << 20)?).map_err(|e| format!("{META} is damaged ({e})"))?;
         let links: Vec<Link> =
             serde_json::from_slice(&disk::read_capped(&path.join(LINKS), 16 << 20)?).map_err(|e| format!("{LINKS} is damaged ({e})"))?;
@@ -440,7 +472,7 @@ impl Store {
             && let Ok(log) = disk::read_log(&bytes)
             && log.generation != generation
         {
-            log::info!("file at {}: its log predates the last compaction; it is ignored", path.display());
+            log::info!("file at {}: its log isn't of its snapshot's generation; it is replayed over it when the file opens", path.display());
         }
         let bytes = [SNAPSHOT, LOG].iter().filter_map(|n| fs::metadata(path.join(n)).ok()).map(|m| m.len()).sum();
         Ok(Entry { meta, links, log: None, bytes, forced: 0 })
@@ -514,6 +546,34 @@ impl Store {
         self.keep(name, snapshot, None, &|_| Ok(())).map(|(info, edit, view, _)| (info, edit, view))
     }
 
+    /// For each block the address `ip` counts in ([`ip_blocks`]), how many times one address's
+    /// caps it gets, and the files and bytes kept by the files published from addresses in it. An
+    /// address that doesn't parse counts as itself only, ×1, by its exact text.
+    fn per_block(&self, ip: &str) -> Vec<(u32, usize, u64)> {
+        let blocks_of = |text: &str| text.parse::<IpAddr>().map(|a| ip_blocks(ip_key(a))).unwrap_or_default();
+        let kept: Vec<(&str, Vec<_>, u64)> = self
+            .files
+            .iter()
+            .filter_map(|(id, e)| {
+                let from = e.meta.ip.as_deref()?;
+                Some((from, blocks_of(from).into_iter().map(|(b, _)| b).collect(), self.bytes(id)))
+            })
+            .collect();
+        let sum = |mine: &mut dyn Iterator<Item = &(&str, Vec<_>, u64)>| mine.fold((0, 0u64), |(f, b), (_, _, n)| (f + 1, b.saturating_add(*n)));
+        let blocks = blocks_of(ip);
+        if blocks.is_empty() {
+            let (files, bytes) = sum(&mut kept.iter().filter(|(from, _, _)| *from == ip));
+            return vec![(1, files, bytes)];
+        }
+        blocks
+            .into_iter()
+            .map(|(block, times)| {
+                let (files, bytes) = sum(&mut kept.iter().filter(|(_, blocks, _)| blocks.contains(&block)));
+                (times, files, bytes)
+            })
+            .collect()
+    }
+
     /// Keep a document published without the key from `ip`, within the caps on what one address
     /// and everyone may keep: the file, its links and its owner token.
     pub fn publish_open(&mut self, ip: IpAddr, name: &str, snapshot: &[Change]) -> Result<(FileInfo, NewLink, NewLink, String), String> {
@@ -525,19 +585,21 @@ impl Store {
         if !self.abuse.allow(ip, Action::Publish, Instant::now()) {
             return Err("too many files published from your address lately: try again in an hour".into());
         }
-        let ip_text = ip.to_string();
-        let mine: Vec<&String> = self.files.iter().filter(|(_, e)| e.meta.ip.as_deref() == Some(ip_text.as_str())).map(|(id, _)| id).collect();
-        if mine.len() >= max_files {
-            return Err(format!(
-                "your address keeps {} files on this server already, the most it may: remove one (with its owner token) or wait until one expires",
-                mine.len()
-            ));
+        let blocks = self.per_block(&ip.to_string());
+        for &(times, files, _) in &blocks {
+            if files >= max_files.saturating_mul(times as usize) {
+                return Err(format!(
+                    "your address keeps {files} files on this server already, the most it may: remove one (with its owner token) or wait until one expires"
+                ));
+            }
         }
-        let used_ip: u64 = mine.iter().map(|id| self.bytes(id)).sum();
         let used_all: u64 = self.files.keys().map(|id| self.bytes(id)).sum();
         let fits = |n: u64| {
-            if used_ip.saturating_add(n) > max_ip {
-                return Err(format!("your address's files would take more than the {} MiB it may keep here: remove one first", max_ip >> 20));
+            for &(times, _, used) in &blocks {
+                let cap = max_ip.saturating_mul(u64::from(times));
+                if used.saturating_add(n) > cap {
+                    return Err(format!("your address's files would take more than the {} MiB it may keep here: remove one first", cap >> 20));
+                }
             }
             if used_all.saturating_add(n) > max_all {
                 return Err("this server is full: it takes no more files for now (try again later, or another server)".into());
@@ -748,7 +810,7 @@ impl Store {
 
     /// Keep a report about `file` (from someone who joined it with `link`, at `ip`).
     pub fn keep_report(&mut self, file: &str, link: Option<&str>, ip: IpAddr, reason: &str) -> Result<(), String> {
-        let reason: String = reason.trim().chars().map(|c| if c.is_control() { ' ' } else { c }).take(MAX_REASON).collect();
+        let reason = clean_reason(reason);
         if reason.is_empty() {
             return Err("say what is wrong with the file".into());
         }
@@ -973,6 +1035,12 @@ impl Store {
             if m.version <= old.version {
                 return Err(format!("version {} is on the server already: publish again to follow it", old.version));
             }
+            // A jump would let a client use up the numbers and leave no newer version to publish.
+            if m.version > old.version.saturating_add(1) {
+                return Err(format!("version {} is too high: the next one after {} is {}", m.version, old.version, old.version.saturating_add(1)));
+            }
+        } else if m.version > MAX_FIRST_LIBRARY_VERSION {
+            return Err(format!("version {} is too high: a first publish goes up to {MAX_FIRST_LIBRARY_VERSION}", m.version));
         }
         // Each version has a file of its own, written before the description names it: a failed
         // description write or a crash in between leaves the previous version served whole, never
@@ -1090,9 +1158,11 @@ impl Store {
         let h = &self.cfg.hosting;
         let Some(ip) = self.files.get(file).filter(|e| e.meta.owner.is_some()).and_then(|e| e.meta.ip.clone()) else { return Ok(()) };
         let (max_ip, max_all) = (h.max_bytes_per_ip, h.max_total_bytes);
-        let used_ip: u64 = self.files.iter().filter(|(_, e)| e.meta.ip.as_deref() == Some(ip.as_str())).map(|(id, _)| self.bytes(id)).sum();
-        if used_ip.saturating_add(n) > max_ip {
-            return Err(format!("the files published from this file's address have reached their {} MiB: that change wasn't kept", max_ip >> 20));
+        for (times, _, used) in self.per_block(&ip) {
+            let cap = max_ip.saturating_mul(u64::from(times));
+            if used.saturating_add(n) > cap {
+                return Err(format!("the files published from this file's address have reached their {} MiB: that change wasn't kept", cap >> 20));
+            }
         }
         let used_all: u64 = self.files.keys().map(|id| self.bytes(id)).sum();
         if used_all.saturating_add(n) > max_all {
@@ -1110,7 +1180,24 @@ impl Store {
         let mut issues = Vec::new();
         let mut fresh_log = true;
         let mut kept = 0;
-        match disk::read_capped(&dir.join(LOG), self.cfg.max_file_bytes).and_then(|b| disk::read_log(&b)) {
+        let log_path = dir.join(LOG);
+        // A log that's there but can't be read (an IO error, or over a lowered cap) may hold
+        // confirmed edits: the file isn't opened, and the log is left as it is for another try.
+        let read = match disk::read_capped(&log_path, self.cfg.max_file_bytes) {
+            Err(why) if log_path.exists() => return Err(format!("its log can't be read ({why}); it was left as it is")),
+            r => r,
+        };
+        // One that isn't a log is moved aside before a new one replaces it (or the file isn't opened).
+        let read = match read.map(|b| disk::read_log(&b)) {
+            Ok(Err(why)) => {
+                let aside = dir.join(format!("{LOG}.unreadable-{generation}-{}", now()));
+                fs::rename(&log_path, &aside).map_err(|e| format!("{why}, and it couldn't be moved aside ({e})"))?;
+                Err(format!("{why}; it was moved aside to {}", aside.display()))
+            }
+            Ok(Ok(log)) => Ok(log),
+            Err(why) => Err(why),
+        };
+        match read {
             Ok(log) if log.generation == generation => {
                 fresh_log = false;
                 for entry in log.entries {
@@ -1126,8 +1213,32 @@ impl Store {
                     fresh_log = true;
                 }
             }
-            // From before a compaction that was cut short: the snapshot has it all.
-            Ok(_) => {}
+            // From before a compaction that was cut short, the snapshot has it all; or a generation
+            // field damaged, which no checksum covers. Replaying tells them apart without trusting
+            // it: entries the snapshot holds are skipped, so only edits it lacks change anything.
+            Ok(log) => {
+                let before = server.seq();
+                let mut stopped = None;
+                for entry in log.entries {
+                    if let Err(e) = server.replay(entry) {
+                        stopped = Some(e);
+                        break;
+                    }
+                }
+                let (snap, found, recovered) = (generation, log.generation, server.seq().saturating_sub(before));
+                if recovered > 0 {
+                    issues.push(format!(
+                        "file {file}: its log's generation ({found}) doesn't match its snapshot's ({snap}), but it held \
+                         {recovered} changes the snapshot didn't; they were recovered"
+                    ));
+                }
+                if let Some(e) = stopped {
+                    issues.push(format!(
+                        "file {file}: its log's generation ({found}) doesn't match its snapshot's ({snap}) and it stops \
+                         making sense after {recovered} newer changes ({e}); the rest was dropped"
+                    ));
+                }
+            }
             Err(why) => issues.push(format!("file {file}: {why}; starting a new log")),
         }
         for i in issues {
@@ -1143,7 +1254,10 @@ impl Store {
                 Log { generation, file: f, pending: Vec::new(), entries: kept, bytes, dirty: kept > 0 }
             }
             // A new snapshot and log of the next generation, so appends start clean.
-            _ => self.rewrite(file, generation + 1, &server).map_err(|e| e.why)?,
+            _ => {
+                let next = generation.checked_add(1).ok_or("the file's generation can't go any higher")?;
+                self.rewrite(file, next, &server).map_err(|e| e.why)?
+            }
         };
         self.entry(file)?.log = Some(log);
         Ok(server)
@@ -1219,7 +1333,11 @@ impl Store {
     fn compact(&mut self, file: &str, server: &Server) {
         self.compactions += 1;
         let Some(generation) = self.files.get(file).and_then(|e| e.log.as_ref()).map(|l| l.generation) else { return };
-        match self.rewrite(file, generation + 1, server) {
+        let Some(next) = generation.checked_add(1) else {
+            log::error!("file {file}: compaction failed: the file's generation can't go any higher");
+            return;
+        };
+        match self.rewrite(file, next, server) {
             Ok(log) => {
                 if let Ok(e) = self.entry(file) {
                     e.log = Some(log);
diff --git a/apps/figcraft-server/src/store_tests.rs b/apps/figcraft-server/src/store_tests.rs
index f380568c8..bd1d9c32a 100644
--- a/apps/figcraft-server/src/store_tests.rs
+++ b/apps/figcraft-server/src/store_tests.rs
@@ -229,6 +229,17 @@ fn one_server_per_data_directory() {
     assert_eq!(again.key(), key, "the key is kept");
 }
 
+#[cfg(unix)]
+#[test]
+fn an_existing_data_directory_is_made_private() {
+    use std::os::unix::fs::PermissionsExt;
+    let dir = TempDir::new("perms");
+    fs::set_permissions(dir.path(), fs::Permissions::from_mode(0o755)).unwrap();
+    assert!(crate::store::lock(dir.path()).unwrap().is_some());
+    let mode = fs::metadata(dir.path()).unwrap().permissions().mode() & 0o777;
+    assert_eq!(mode, 0o700);
+}
+
 #[test]
 fn temporary_directories_are_removed() {
     let path = {
@@ -313,3 +324,124 @@ fn edits_confirmed_after_a_compaction_cut_short_survive_a_restart() {
     let name = page_name(&restored);
     assert!(at(&name) >= at(&confirmed), "restored {name:?}, confirmed {confirmed:?}");
 }
+
+#[test]
+fn a_log_that_cant_be_read_is_never_overwritten() {
+    let dir = TempDir::new("unreadlog");
+    let c = StoreConfig { compact_after: 1000, ..cfg(dir.path()) };
+    let log_path = dir.path().join(FILES);
+    let last = "Confirmed page name number 39 with some padding";
+    let id = {
+        let mut store = Store::open(dir.path(), c.clone()).unwrap();
+        let (id, _, _) = publish(&mut store, "Busy");
+        let mut server = store.open(&id).unwrap();
+        let mut a = join(&mut server, Access::Edit);
+        store.changed(&id, &mut server);
+        for i in 0..40 {
+            rename(&mut server, &mut a, &format!("Confirmed page name number {i} with some padding"));
+            store.changed(&id, &mut server);
+        }
+        assert!(store.flush().is_empty());
+        id
+    };
+    let log_path = log_path.join(&id).join(LOG);
+    let before = fs::read(&log_path).unwrap();
+    // The cap lowered just under the log: it can't be read now, but it must still be there after.
+    let lowered = StoreConfig { max_file_bytes: before.len() as u64 - 1, ..c.clone() };
+    {
+        let mut store = Store::open(dir.path(), lowered).unwrap();
+        let opened = store.open(&id);
+        assert!(opened.is_err(), "the file isn't opened without its log");
+        assert!(!store.problems().is_empty(), "the problem is reported");
+        assert_eq!(fs::read(&log_path).unwrap(), before, "the log is left as it was");
+    }
+    let mut store = Store::open(dir.path(), c).unwrap();
+    let server = store.open(&id).unwrap();
+    assert_eq!(page_name(&server), last, "every confirmed edit comes back");
+}
+
+#[test]
+fn a_log_that_isnt_one_is_moved_aside() {
+    let dir = TempDir::new("badlog");
+    let mut store = Store::open(dir.path(), cfg(dir.path())).unwrap();
+    let (id, _, _) = publish(&mut store, "Busy");
+    let folder = dir.path().join(FILES).join(&id);
+    let junk = b"not a log at all, but maybe worth keeping".to_vec();
+    fs::write(folder.join(LOG), &junk).unwrap();
+    drop(store);
+    let mut store = Store::open(dir.path(), cfg(dir.path())).unwrap();
+    store.open(&id).unwrap();
+    assert!(store.problems().iter().any(|p| p.contains("moved aside")), "{:?}", store.problems());
+    let kept = fs::read_dir(&folder).unwrap().filter_map(|e| e.ok()).any(|e| fs::read(e.path()).is_ok_and(|b| b == junk));
+    assert!(kept, "the old log's bytes are kept beside the file");
+}
+
+const BIDI: [char; 12] =
+    ['\u{61C}', '\u{200E}', '\u{200F}', '\u{202A}', '\u{202B}', '\u{202C}', '\u{202D}', '\u{202E}', '\u{2066}', '\u{2067}', '\u{2068}', '\u{2069}'];
+
+#[test]
+fn names_and_report_reasons_lose_bidi_controls() {
+    let dir = TempDir::new("bidi");
+    let mut store = Store::open(dir.path(), cfg(dir.path())).unwrap();
+    for (n, m) in BIDI.into_iter().enumerate() {
+        let ip: std::net::IpAddr = format!("192.0.2.{}", n + 1).parse().unwrap();
+        let (id, _, _) = publish(&mut store, &format!("a{m}b"));
+        assert_eq!(store.list(&|_| None)[0].name, "ab", "name U+{:04X}", m as u32);
+        store.keep_report(&id, None, ip, &format!("a{m}b")).unwrap();
+        assert_eq!(store.reports().last().unwrap().reason, "a b", "reason U+{:04X}", m as u32);
+        store.remove(&id).unwrap();
+    }
+}
+
+#[test]
+fn a_maxed_out_generation_does_not_wrap() {
+    let dir = TempDir::new("maxgen");
+    let c = StoreConfig { compact_after: 3, ..cfg(dir.path()) };
+    let mut store = Store::open(dir.path(), c.clone()).unwrap();
+    let (id, _, _) = publish(&mut store, "Max");
+    let path = dir.path().join(FILES).join(&id);
+    let (_, state) = disk::decode_snapshot(&fs::read(path.join(SNAPSHOT)).unwrap()).unwrap();
+    // Loading: no log goes with the snapshot, so the next generation would overflow.
+    fs::write(path.join(SNAPSHOT), disk::encode_snapshot(u64::MAX, &state).unwrap()).unwrap();
+    fs::remove_file(path.join(LOG)).unwrap();
+    assert!(store.open(&id).is_err());
+    // Compacting: the open log is at the largest generation.
+    fs::write(path.join(SNAPSHOT), disk::encode_snapshot(u64::MAX - 1, &state).unwrap()).unwrap();
+    let _ = fs::remove_file(path.join(LOG));
+    let mut server = store.open(&id).unwrap();
+    let mut a = join(&mut server, Access::Edit);
+    store.changed(&id, &mut server);
+    for i in 0..4 {
+        rename(&mut server, &mut a, &format!("P{i}"));
+        store.changed(&id, &mut server);
+        store.flush();
+    }
+    let snap = disk::check_snapshot(&fs::read(path.join(SNAPSHOT)).unwrap()).unwrap();
+    assert_eq!(snap, u64::MAX);
+}
+
+#[test]
+fn every_leftover_temporary_file_is_removed_at_startup() {
+    let dir = TempDir::new("leftovers");
+    let id = {
+        let mut store = Store::open(dir.path(), cfg(dir.path())).unwrap();
+        let id = publish(&mut store, "A").0;
+        store.flush();
+        id
+    };
+    let folder = dir.path().join(FILES).join(&id);
+    let leftovers = [
+        dir.path().join("blocked.json.tmp"),
+        dir.path().join("reports.json.tmp"),
+        dir.path().join("server.key.tmp"),
+        folder.join("usage.json.tmp"),
+        folder.join("library-1.bin.tmp"),
+    ];
+    for path in &leftovers {
+        fs::write(path, b"half").unwrap();
+    }
+    let _store = Store::open(dir.path(), cfg(dir.path())).unwrap();
+    for path in &leftovers {
+        assert!(!path.exists(), "leftover not cleaned at startup: {}", path.display());
+    }
+}
diff --git a/apps/figcraft-server/tests/it/header_recovery.rs b/apps/figcraft-server/tests/it/header_recovery.rs
new file mode 100644
index 000000000..bb0be1d05
--- /dev/null
+++ b/apps/figcraft-server/tests/it/header_recovery.rs
@@ -0,0 +1,138 @@
+//! A generation field damaged after an abrupt stop must not make the server drop a log that still
+//! holds confirmed edits (#408): the log is replayed over the snapshot, which only the changes the
+//! snapshot lacks survive, and the damage is reported. A genuine leftover of a compaction cut short
+//! still restores silently.
+
+use figcraft_collab::message::{Access, ClientMsg};
+use figcraft_collab::{Client, Outgoing, Replica, Server};
+use figcraft_collab_net::hub::Backend;
+use figcraft_doc::Document;
+use figcraft_server::config::Config;
+use figcraft_server::disk::{self, LOG, SNAPSHOT};
+use figcraft_server::store::{FILES, Store};
+use std::fs;
+use std::path::{Path, PathBuf};
+
+struct Fixture(PathBuf);
+
+impl Fixture {
+    fn new() -> Self {
+        let path = std::env::temp_dir().join(format!("figcraft-header-recovery-{}", figcraft_collab_net::token::file_id().unwrap()));
+        fs::create_dir(&path).unwrap();
+        Self(path)
+    }
+}
+
+impl Drop for Fixture {
+    fn drop(&mut self) {
+        let _ = fs::remove_dir_all(&self.0);
+    }
+}
+
+fn page_name(server: &Server) -> String {
+    let doc = server.document();
+    doc.node(doc.first_page().unwrap()).unwrap().name.clone()
+}
+
+/// A published file whose first page was renamed "Kept", flushed to its log (not compacted), then
+/// the store dropped without stopping (an abrupt stop). Returns the file id and the final state.
+fn renamed_and_stopped(data: &Path) -> (String, Server) {
+    let mut store = Store::open(data, Config::default().store()).unwrap();
+    let snapshot = Replica::new(Document::new("Fixture")).snapshot().unwrap();
+    let (info, _, _) = store.publish("Fixture", &snapshot).unwrap();
+    let id = info.id;
+    let mut server = store.open(&id).unwrap();
+    let ClientMsg::Hello(hello) = Client::hello("f", "", "Editor", "#FF8800") else { panic!("not a hello") };
+    let (_, messages) = server.join_as(hello, Access::Edit).unwrap();
+    let Some(Outgoing::To(_, welcome)) = messages.into_iter().next() else { panic!("no welcome") };
+    let mut client = Client::join(welcome).unwrap();
+    store.changed(&id, &mut server);
+    let mut edited = client.document().clone();
+    let page = edited.first_page().unwrap();
+    edited.node_mut(page).unwrap().name = "Kept".into();
+    let change = client.edit(&edited).unwrap().unwrap();
+    assert!(!server.receive(client.id(), change).is_empty());
+    store.changed(&id, &mut server);
+    assert!(store.flush().is_empty(), "the edit must reach disk");
+    assert_eq!(page_name(&server), "Kept");
+    let dir = data.join(FILES).join(&id);
+    assert!(!disk::read_log(&fs::read(dir.join(LOG)).unwrap()).unwrap().entries.is_empty());
+    assert_eq!(disk::decode_snapshot(&fs::read(dir.join(SNAPSHOT)).unwrap()).unwrap().1.seq, 0, "the rename is only in the log");
+    drop(store);
+    (id, server)
+}
+
+/// Reopen the data directory: the file's first page name and the problems reported.
+fn reopen(data: &Path, id: &str) -> (String, Vec<String>) {
+    let mut store = Store::open(data, Config::default().store()).unwrap();
+    let server = store.open(id).unwrap();
+    (page_name(&server), store.problems().to_vec())
+}
+
+fn flip(path: &Path, at: usize) {
+    let mut bytes = fs::read(path).unwrap();
+    bytes[at] ^= 1;
+    fs::write(path, bytes).unwrap();
+}
+
+/// The generation field's first byte in both headers (after the magic and the format byte).
+const GENERATION_AT: usize = 5;
+
+#[test]
+fn an_intact_log_restores_its_edits_without_a_report() {
+    let fixture = Fixture::new();
+    let (id, _) = renamed_and_stopped(&fixture.0);
+    let (name, problems) = reopen(&fixture.0, &id);
+    assert_eq!(name, "Kept");
+    assert!(problems.is_empty(), "{problems:?}");
+}
+
+#[test]
+fn a_damaged_log_generation_keeps_the_edits_and_is_reported() {
+    let fixture = Fixture::new();
+    let (id, _) = renamed_and_stopped(&fixture.0);
+    let log = fixture.0.join(FILES).join(&id).join(LOG);
+    flip(&log, GENERATION_AT);
+    // The records themselves still read: only the header's generation changed.
+    let read = disk::read_log(&fs::read(&log).unwrap()).unwrap();
+    assert!(read.damaged.is_none() && !read.entries.is_empty());
+    let (name, problems) = reopen(&fixture.0, &id);
+    assert_eq!(name, "Kept", "the flushed rename must survive");
+    assert!(problems.iter().any(|p| p.contains(&id) && p.contains("generation")), "{problems:?}");
+    // And it stays: the recovered edit is now in the file's snapshot.
+    assert_eq!(reopen(&fixture.0, &id).0, "Kept");
+}
+
+#[test]
+fn a_damaged_snapshot_generation_keeps_the_edits_and_is_reported() {
+    let fixture = Fixture::new();
+    let (id, _) = renamed_and_stopped(&fixture.0);
+    let snapshot = fixture.0.join(FILES).join(&id).join(SNAPSHOT);
+    flip(&snapshot, GENERATION_AT);
+    assert!(disk::check_snapshot(&fs::read(&snapshot).unwrap()).is_ok(), "the generation is outside the checksum");
+    let (name, problems) = reopen(&fixture.0, &id);
+    assert_eq!(name, "Kept", "the flushed rename must survive");
+    assert!(problems.iter().any(|p| p.contains(&id) && p.contains("generation")), "{problems:?}");
+    assert_eq!(reopen(&fixture.0, &id).0, "Kept");
+}
+
+#[test]
+fn a_damaged_log_format_is_still_reported() {
+    let fixture = Fixture::new();
+    let (id, _) = renamed_and_stopped(&fixture.0);
+    flip(&fixture.0.join(FILES).join(&id).join(LOG), 4);
+    let (_, problems) = reopen(&fixture.0, &id);
+    assert!(problems.iter().any(|p| p.contains(&id) && p.contains("format")), "{problems:?}");
+}
+
+#[test]
+fn a_log_left_by_a_compaction_cut_short_restores_without_a_report() {
+    let fixture = Fixture::new();
+    let (id, server) = renamed_and_stopped(&fixture.0);
+    // The next snapshot was written (it holds the rename); the old log wasn't replaced yet.
+    let bytes = disk::encode_snapshot(2, &server.state().unwrap()).unwrap();
+    fs::write(fixture.0.join(FILES).join(&id).join(SNAPSHOT), bytes).unwrap();
+    let (name, problems) = reopen(&fixture.0, &id);
+    assert_eq!(name, "Kept");
+    assert!(problems.is_empty(), "a leftover log is expected, not damage: {problems:?}");
+}
diff --git a/apps/figcraft-server/tests/it/main.rs b/apps/figcraft-server/tests/it/main.rs
new file mode 100644
index 000000000..3027ed99a
--- /dev/null
+++ b/apps/figcraft-server/tests/it/main.rs
@@ -0,0 +1,5 @@
+//! The crate's integration tests, built as one test binary.
+
+#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+mod header_recovery;
+mod problem_retention;
diff --git a/apps/figcraft-server/tests/problem_retention.rs b/apps/figcraft-server/tests/it/problem_retention.rs
similarity index 100%
rename from apps/figcraft-server/tests/problem_retention.rs
rename to apps/figcraft-server/tests/it/problem_retention.rs
diff --git a/apps/figcraft-web/Cargo.toml b/apps/figcraft-web/Cargo.toml
index 2f1a8190f..ffd44f3bc 100644
--- a/apps/figcraft-web/Cargo.toml
+++ b/apps/figcraft-web/Cargo.toml
@@ -26,4 +26,4 @@ eframe = { workspace = true, features = ["default_fonts", "wgpu", "accesskit"] }
 wasm-bindgen = "0.2"
 js-sys = "0.3"
 wasm-bindgen-futures = "0.4"
-web-sys = { version = "0.3", features = ["Window", "Document", "Element", "HtmlCanvasElement", "HtmlElement", "HtmlAnchorElement", "Node", "Blob", "BlobPropertyBag", "Url", "Location", "MediaQueryList", "Navigator", "Gamepad", "GamepadButton", "GamepadMappingType"] }
+web-sys = { version = "0.3", features = ["Window", "Document", "Element", "HtmlCanvasElement", "HtmlElement", "HtmlAnchorElement", "Node", "Blob", "BlobPropertyBag", "File", "FileList", "HtmlInputElement", "EventTarget", "Url", "Location", "MediaQueryList", "Navigator", "Gamepad", "GamepadButton", "GamepadMappingType"] }
diff --git a/apps/figcraft-web/src/main.rs b/apps/figcraft-web/src/main.rs
index 587fd60b8..7eed2ffb3 100644
--- a/apps/figcraft-web/src/main.rs
+++ b/apps/figcraft-web/src/main.rs
@@ -14,7 +14,16 @@
 //!   join from other machines.
 //!
 //! URL query flag: `?webgl` forces the WebGL2 backend instead of WebGPU.
+//!
+//! URL fragment: `#join=<invite link or join code>` joins that live session once the page has
+//! loaded, so a bookmark opens a shared file. `join` takes the rest of the fragment: put it last.
+//! The link carries the session's secret; a fragment is never sent to the web host, but the address
+//! bar and the browser history keep it, so the URL is as private as the link itself.
 
+#[cfg(any(target_arch = "wasm32", test))]
+mod query;
+#[cfg(test)]
+mod query_tests;
 #[cfg(target_arch = "wasm32")]
 mod web;
 
diff --git a/apps/figcraft-web/src/query.rs b/apps/figcraft-web/src/query.rs
new file mode 100644
index 000000000..befeb36b7
--- /dev/null
+++ b/apps/figcraft-web/src/query.rs
@@ -0,0 +1,15 @@
+//! The page's URL: the invite link its fragment names.
+
+/// The invite link in `#join=<link>` (`fragment` is `location.hash`, with or without its `#`), still
+/// escaped. The fragment, unlike the query, never leaves the browser, so the link's secret stays out
+/// of the web host's logs and `Referer` headers. `join` takes the rest of the fragment, so a pasted
+/// `figcraft://join?host=…&file=…&token=…` keeps its own `&`s. Anything longer than an escaped invite
+/// link can be is ignored; what is left is checked by `collab.join` like a link the desktop app is
+/// opened with.
+pub fn join_link(fragment: &str) -> Option<&str> {
+    // An invite link is at most 2 KiB; every byte of it escaped is three.
+    const MAX: usize = 3 * 2048;
+    let fragment = fragment.strip_prefix('#').unwrap_or(fragment);
+    let start = if fragment.starts_with("join=") { 0 } else { fragment.find("&join=")? + 1 };
+    fragment.get(start + "join=".len()..).filter(|link| !link.is_empty() && link.len() <= MAX)
+}
diff --git a/apps/figcraft-web/src/query_tests.rs b/apps/figcraft-web/src/query_tests.rs
new file mode 100644
index 000000000..261ebaeb6
--- /dev/null
+++ b/apps/figcraft-web/src/query_tests.rs
@@ -0,0 +1,29 @@
+//! `#join=` in the page's URL.
+
+use crate::query::join_link;
+
+#[test]
+fn join_takes_the_rest_of_the_fragment() {
+    let link = "figcraft://join?host=192.168.1.20:47900&file=abc&token=AbCdEfGhIjKlMnOpQrStUv";
+    assert_eq!(join_link(&format!("#join={link}")), Some(link), "a pasted link keeps its own &s");
+    assert_eq!(join_link(&format!("#x=1&join={link}")), Some(link), "after other entries");
+    assert_eq!(join_link("#join=figcraft%3A%2F%2Fjoin%3Fhost%3Dh"), Some("figcraft%3A%2F%2Fjoin%3Fhost%3Dh"), "escaped, decoded later");
+    assert_eq!(join_link("join=K7M-2QX-9TD"), Some("K7M-2QX-9TD"), "a join code, no leading #");
+}
+
+#[test]
+fn no_join_without_the_entry() {
+    assert_eq!(join_link(""), None);
+    assert_eq!(join_link("#"), None);
+    assert_eq!(join_link("#join="), None);
+    assert_eq!(join_link("#rejoin=x"), None, "only the whole entry name");
+    assert_eq!(join_link("#xjoin=x&a=1"), None);
+    assert_eq!(join_link("?join=x"), None, "the query isn't read: it goes to the web host");
+}
+
+#[test]
+fn an_overlong_link_is_ignored() {
+    let long = format!("#join=figcraft://join?host=h&file=f&token={}", "a".repeat(7000));
+    assert_eq!(join_link(&long), None);
+    assert_eq!(join_link(&format!("#join={}", "é".repeat(4000))), None, "length counts bytes");
+}
diff --git a/apps/figcraft-web/src/web.rs b/apps/figcraft-web/src/web.rs
index 8cadb0138..f08ca90f2 100644
--- a/apps/figcraft-web/src/web.rs
+++ b/apps/figcraft-web/src/web.rs
@@ -1,7 +1,7 @@
 //! The browser shell: web `Services` and the eframe web runner.
 
 use figcraft_engine::Session;
-use figcraft_ui_egui::{FigApp, Services};
+use figcraft_ui_egui::{ContentsFuture, FigApp, Services};
 use wasm_bindgen::JsCast as _;
 
 const CANVAS_ID: &str = "figcraft_canvas";
@@ -40,7 +40,13 @@ pub fn start() {
                     // on the socket wakes the page for a frame.
                     let ctx = cc.egui_ctx.clone();
                     session.live.install(Box::new(figcraft_collab_net::NetLink::new(std::sync::Arc::new(move || ctx.request_repaint()))));
-                    let fig = FigApp::new(session, Box::new(WebServices { reduce_motion, ctx: cc.egui_ctx.clone() }));
+                    let mut fig = FigApp::new(session, Box::new(WebServices { reduce_motion, ctx: cc.egui_ctx.clone() }));
+                    // `#join=<link>`: join that session, as opening an invite link does on the desktop.
+                    let hash = web_sys::window().and_then(|w| w.location().hash().ok()).unwrap_or_default();
+                    if let Some(link) = crate::query::join_link(&hash) {
+                        let link = js_sys::decode_uri_component(link).ok().and_then(|s| s.as_string()).unwrap_or_else(|| link.to_string());
+                        figcraft_ui_egui::live::open_invite(&mut fig, &link);
+                    }
                     Ok(Box::new(WebShell { fig }))
                 }),
             )
@@ -69,9 +75,10 @@ impl eframe::App for WebShell {
     }
 }
 
-/// Browser services. Open dialogs return nothing for now (the trait's defaults); files are saved
-/// as downloads. Copies go to the system clipboard through egui's output; pastes arrive as paste
-/// events with their text (a page can't read the clipboard when it likes).
+/// Browser services. Files are opened and imported through the browser's file picker, which hands
+/// over their contents (pickers that need a path return nothing, the trait's defaults); files are
+/// saved as downloads. Copies go to the system clipboard through egui's output; pastes arrive as
+/// paste events with their text (a page can't read the clipboard when it likes).
 struct WebServices {
     /// `prefers-reduced-motion: reduce` (it follows the setting while the page is open).
     reduce_motion: Option<web_sys::MediaQueryList>,
@@ -79,6 +86,16 @@ struct WebServices {
 }
 
 impl Services for WebServices {
+    /// An `<input type="file">` taking `exts`, clicked; its file is read once picked.
+    fn pick_open_contents(&mut self, _title: &str, exts: &[&str]) -> Option<ContentsFuture> {
+        let accept = exts.iter().map(|e| format!(".{e}")).collect::<Vec<_>>().join(",");
+        Some(Box::pin(async move {
+            pick_file(&accept).await.unwrap_or_else(|e| {
+                log::error!("couldn't open a file: {e:?}");
+                None
+            })
+        }))
+    }
     fn downloads(&self) -> bool {
         true
     }
@@ -130,6 +147,90 @@ impl Services for WebServices {
     }
 }
 
+/// The file picked in the browser's file picker (`accept`: the extensions it offers), with its
+/// name; `None` when the picker is cancelled, `Some(Err)` with what to tell the user when the file
+/// can't be read.
+async fn pick_file(accept: &str) -> Result<Option<Result<(String, Vec<u8>), String>>, wasm_bindgen::JsValue> {
+    let window = web_sys::window().ok_or("no window")?;
+    let document = window.document().ok_or("no document")?;
+    let body = document.body().ok_or("no body")?;
+    let input: web_sys::HtmlInputElement = document.create_element("input")?.dyn_into()?;
+    input.set_type("file");
+    input.set_accept(accept);
+    input.set_hidden(true);
+    // Some browsers (older Safari) open the picker only for an input in the page.
+    body.append_child(&input)?;
+    let (closed, picker) = PickerClosed::new(&window, input.clone());
+    input.click();
+    let result = wasm_bindgen_futures::JsFuture::from(closed).await;
+    let file = input.files().and_then(|files| files.get(0));
+    drop(picker);
+    result?;
+    let Some(file) = file else { return Ok(None) };
+    let name = file.name();
+    if let Err(why) = figcraft_ui_egui::browser_can_read(&name, file.size()) {
+        return Ok(Some(Err(why)));
+    }
+    Ok(Some(match wasm_bindgen_futures::JsFuture::from(file.array_buffer()).await {
+        Ok(buffer) => Ok((name, js_sys::Uint8Array::new(&buffer).to_vec())),
+        Err(e) => {
+            log::error!("couldn't read {name}: {e:?}");
+            Err(figcraft_ui_egui::unreadable(&name))
+        }
+    }))
+}
+
+/// How long after the page gets focus back the file picker counts as closed (milliseconds): a
+/// picked file's `change` can come just after the focus, and must win. A `change` later than this
+/// (a slow cloud-backed file in a browser that never sends `cancel`) counts as a cancel.
+const PICKER_FOCUS_SETTLE_MS: i32 = 1_000;
+
+/// Settles a file picker's promise once: on `change` (a file was picked), on `cancel` (closed
+/// without one) or shortly after the page gets focus back, for browsers that never send `cancel`
+/// (Safari before 16.4), where the pick would otherwise stay pending and block every later one.
+/// Dropping it (also when the pick is abandoned) removes the input, the focus listener and its timer.
+struct PickerClosed {
+    window: web_sys::Window,
+    input: web_sys::HtmlInputElement,
+    _settle: wasm_bindgen::closure::Closure<dyn FnMut()>,
+    on_focus: wasm_bindgen::closure::Closure<dyn FnMut()>,
+    timer: std::rc::Rc<std::cell::Cell<Option<i32>>>,
+}
+
+impl PickerClosed {
+    fn new(window: &web_sys::Window, input: web_sys::HtmlInputElement) -> (js_sys::Promise, Self) {
+        let resolve = std::rc::Rc::new(std::cell::RefCell::new(None::<js_sys::Function>));
+        let slot = resolve.clone();
+        let closed = js_sys::Promise::new(&mut |res, _rej| *slot.borrow_mut() = Some(res));
+        let settle = wasm_bindgen::closure::Closure::<dyn FnMut()>::new(move || {
+            if let Some(res) = resolve.borrow_mut().take() {
+                let _ = res.call0(&wasm_bindgen::JsValue::NULL);
+            }
+        });
+        let _ = input.add_event_listener_with_callback("change", settle.as_ref().unchecked_ref());
+        let _ = input.add_event_listener_with_callback("cancel", settle.as_ref().unchecked_ref());
+        let timer = std::rc::Rc::new(std::cell::Cell::new(None));
+        let (w, t, f) = (window.clone(), timer.clone(), settle.as_ref().unchecked_ref::<js_sys::Function>().clone());
+        let on_focus = wasm_bindgen::closure::Closure::<dyn FnMut()>::new(move || {
+            if t.get().is_none() {
+                t.set(w.set_timeout_with_callback_and_timeout_and_arguments_0(&f, PICKER_FOCUS_SETTLE_MS).ok());
+            }
+        });
+        let _ = window.add_event_listener_with_callback("focus", on_focus.as_ref().unchecked_ref());
+        (closed, Self { window: window.clone(), input, _settle: settle, on_focus, timer })
+    }
+}
+
+impl Drop for PickerClosed {
+    fn drop(&mut self) {
+        if let Some(t) = self.timer.take() {
+            self.window.clear_timeout_with_handle(t);
+        }
+        let _ = self.window.remove_event_listener_with_callback("focus", self.on_focus.as_ref().unchecked_ref());
+        self.input.remove();
+    }
+}
+
 fn download(name: &str, bytes: &[u8]) -> Result<(), wasm_bindgen::JsValue> {
     let window = web_sys::window().ok_or("no window")?;
     let document = window.document().ok_or("no document")?;
diff --git a/apps/figcraft/Cargo.toml b/apps/figcraft/Cargo.toml
index b22650eb3..38281dfcb 100644
--- a/apps/figcraft/Cargo.toml
+++ b/apps/figcraft/Cargo.toml
@@ -16,12 +16,16 @@ figcraft-ui-egui = { workspace = true }
 figcraft-collab-net = { workspace = true }
 figcraft-format = { workspace = true }
 figcraft-text = { workspace = true }
+# Shared decision of who draws the window frame on Linux (compositor vs. app), replacing the
+# bespoke Wayland xdg-decoration probe. See `[workspace.dependencies]`: pinned to the unmerged
+# craft-libs#217 branch and must be repointed to a merged `rev` before this PR is mergeable.
+craft-window = { workspace = true }
 egui = { workspace = true }
 eframe = { workspace = true, features = ["default_fonts", "wgpu", "accesskit", "wayland", "x11"] }
 serde_json = { workspace = true }
 log = { workspace = true }
 rfd = { workspace = true }
-arboard = { workspace = true, features = ["image-data"] }
+arboard = { workspace = true, features = ["image-data", "wayland-data-control"] }
 webbrowser = { workspace = true }
 image = { workspace = true }
 env_logger = { version = "0.11", default-features = false, features = ["auto-color", "humantime"] }
@@ -49,3 +53,8 @@ wat = { workspace = true }
 
 [build-dependencies]
 winresource = "0.1"
+
+[target.'cfg(target_os = "linux")'.dependencies]
+# Use vector window controls without a title-font renderer or embedded Cantarell. The compositor
+# probe that used to need raw-window-handle and wayland-client here now lives in craft-window.
+winit = { version = "0.30", default-features = false, features = ["wayland-csd-adwaita-notitle"] }
diff --git a/apps/figcraft/src/apple_events.rs b/apps/figcraft/src/apple_events.rs
index 6b7920944..41ae5cc36 100644
--- a/apps/figcraft/src/apple_events.rs
+++ b/apps/figcraft/src/apple_events.rs
@@ -50,7 +50,7 @@ pub fn poll(inbox: &Inbox, fig: &mut FigApp, ctx: &egui::Context) {
 /// Open `paths` as File › Open does; a file that fails shows its error and the others still open.
 pub fn open_documents(fig: &mut FigApp, paths: Vec<PathBuf>) {
     for p in paths {
-        if fig.run("file.open", json!({"path": p.to_string_lossy()})).is_some() {
+        if fig.run_user("file.open", json!({"path": p.to_string_lossy()})).is_some() {
             fig.ui.home = false;
         }
     }
diff --git a/apps/figcraft/src/args.rs b/apps/figcraft/src/args.rs
index 2e3099cbf..436df61f8 100644
--- a/apps/figcraft/src/args.rs
+++ b/apps/figcraft/src/args.rs
@@ -1,16 +1,26 @@
-//! The command line: `figcraft [--control <port>] [files…] [figcraft://join?…]`. An invite link
+//! The command line: `figcraft [--control <port>] [--automation-read-root <dir>]…
+//! [--automation-write-root <dir>]… [files…] [figcraft://join?…]`. An invite link
 //! (what the system passes when a `figcraft://` link is opened) joins that session once the window
 //! is up; everything else that isn't a flag is a file to open, as a path or a `file://` URL (the
-//! Linux desktop entry passes URLs, `%U`, so that it can also hand over invite links).
+//! Linux desktop entry passes URLs, `%U`, so that it can also hand over invite links). Any other
+//! `--flag` is unknown and stops the app at startup (#836): a mistyped root flag must never leave
+//! the app running unconfined. After a bare `--`, every argument is a file.
 
 /// What the app was started with.
 #[derive(Debug, Default, PartialEq, Eq)]
 pub struct Args {
-    /// `--control <port>`: the JSON-lines control server.
+    /// `--control <port>` (or `--control=<port>`): the JSON-lines control server.
     pub control: Option<u16>,
     pub files: Vec<String>,
     /// The last invite link given.
     pub join: Option<String>,
+    /// `--automation-read-root <dir>` / `--automation-write-root <dir>` (each repeatable; `=` works
+    /// too): the folders the app's file access is confined to. A flag without a value gives `""`,
+    /// which is refused at startup.
+    pub read_roots: Vec<String>,
+    pub write_roots: Vec<String>,
+    /// `--flags` the app doesn't know, as given.
+    pub unknown: Vec<String>,
 }
 
 /// An invite link rather than a file (`figcraft:` links, in any case).
@@ -49,13 +59,27 @@ pub fn parse(args: &[String]) -> Args {
     let mut out = Args::default();
     let mut it = args.iter();
     while let Some(a) = it.next() {
-        if a == "--control" {
-            out.control = it.next().and_then(|p| p.parse().ok());
+        if a == "--" {
+            out.files.extend(it.by_ref().cloned());
+            break;
+        }
+        let (flag, inline) = a.split_once('=').map_or((a.as_str(), None), |(f, v)| (f, Some(v.to_string())));
+        let roots = match flag {
+            "--automation-read-root" => Some(&mut out.read_roots),
+            "--automation-write-root" => Some(&mut out.write_roots),
+            _ => None,
+        };
+        if let Some(roots) = roots {
+            roots.push(inline.or_else(|| it.next().cloned()).unwrap_or_default());
+        } else if flag == "--control" {
+            out.control = inline.or_else(|| it.next().cloned()).and_then(|p| p.parse().ok());
         } else if is_invite(a) {
             out.join = Some(a.clone());
         } else if let Some(path) = file_url_path(a) {
             out.files.push(path);
-        } else if !a.starts_with("--") {
+        } else if a.starts_with("--") {
+            out.unknown.push(a.clone());
+        } else {
             out.files.push(a.clone());
         }
     }
diff --git a/apps/figcraft/src/args_tests.rs b/apps/figcraft/src/args_tests.rs
index 0ed404c8f..b274bedab 100644
--- a/apps/figcraft/src/args_tests.rs
+++ b/apps/figcraft/src/args_tests.rs
@@ -9,13 +9,44 @@ fn args(a: &[&str]) -> Vec<String> {
 #[test]
 fn files_and_the_control_port() {
     assert_eq!(parse(&args(&[])), Args::default());
-    let a = parse(&args(&["--control", "4242", "a.figcraft", "--verbose", "b.svg"]));
-    assert_eq!(a, Args { control: Some(4242), files: args(&["a.figcraft", "b.svg"]), join: None });
+    let a = parse(&args(&["--control", "4242", "a.figcraft", "b.svg"]));
+    assert_eq!(a, Args { control: Some(4242), files: args(&["a.figcraft", "b.svg"]), ..Args::default() });
     // A missing or bad port is ignored, not taken as a file.
     assert_eq!(parse(&args(&["--control"])), Args::default());
     assert_eq!(parse(&args(&["--control", "nope"])).control, None);
 }
 
+#[test]
+fn the_control_port_accepts_the_equals_form() {
+    let a = parse(&args(&["--control=7980", "a.figcraft"]));
+    assert_eq!(a, Args { control: Some(7980), files: args(&["a.figcraft"]), ..Args::default() });
+    // A bad port is ignored, not taken as a file.
+    assert_eq!(parse(&args(&["--control=nope"])), Args::default());
+}
+
+#[test]
+fn automation_roots_repeat_and_are_never_files() {
+    let a = parse(&args(&["--automation-read-root", "in", "--automation-write-root=out", "--automation-read-root=more", "a.figcraft"]));
+    assert_eq!(a.read_roots, args(&["in", "more"]));
+    assert_eq!(a.write_roots, args(&["out"]));
+    assert_eq!(a.files, args(&["a.figcraft"]));
+    // A flag without its folder is kept as an empty one, which startup refuses.
+    assert_eq!(parse(&args(&["--automation-write-root"])).write_roots, args(&[""]));
+}
+
+#[test]
+fn unknown_flags_are_refused_never_ignored() {
+    // #836: a mistyped root flag (or one an older release lacks) must stop the app, not start it
+    // unconfined. Both forms, with and without `=`.
+    let a = parse(&args(&["--automation-write-roots", "out", "--automation-write-dir=out", "--verbose", "a.figcraft"]));
+    assert_eq!(a.unknown, args(&["--automation-write-roots", "--automation-write-dir=out", "--verbose"]));
+    assert!(a.write_roots.is_empty());
+    // Single-dash arguments are left as they were (files); after `--` everything is a file.
+    let a = parse(&args(&["--control", "1", "--", "--odd.figcraft", "--automation-write-root=x"]));
+    assert_eq!(a.files, args(&["--odd.figcraft", "--automation-write-root=x"]));
+    assert!(a.unknown.is_empty() && a.write_roots.is_empty());
+}
+
 #[test]
 fn invite_links_join_instead_of_opening() {
     let link = "figcraft://join?host=192.168.1.20:47900&file=abc&token=AbCdEfGhIjKlMnOpQrStUv";
diff --git a/apps/figcraft/src/control_server.rs b/apps/figcraft/src/control_server.rs
index 1c91840fa..ff9c2fbe0 100644
--- a/apps/figcraft/src/control_server.rs
+++ b/apps/figcraft/src/control_server.rs
@@ -16,6 +16,10 @@ const MAX_LINE: usize = 32 * 1024 * 1024;
 const MAX_CONNECTIONS: usize = 8;
 const MAX_QUEUED_REQUESTS: usize = 8;
 const TIMEOUT: Duration = Duration::from_secs(60);
+/// How long the accepting thread waits after a failed accept. Accepting can keep failing, for
+/// example while the process has no file descriptors left, and retrying at once would keep a
+/// core busy until it recovers.
+const ACCEPT_RETRY: Duration = Duration::from_millis(100);
 
 /// Deferred requests for a hidden window must not make the UI's queue grow without a bound.
 pub fn drain_queue(queue: &Queue, target: &mut Vec<ControlRequest>) {
@@ -38,7 +42,7 @@ pub fn start(port: u16, queue: Queue, ctx: CtxSlot) {
     eprintln!("FigCraft control server listening on 127.0.0.1:{port}");
     let spawned = std::thread::Builder::new().name("figcraft-control".into()).spawn(move || {
         let mut workers = Vec::new();
-        for stream in listener.incoming().flatten() {
+        for stream in accepted(listener.incoming(), || std::thread::sleep(ACCEPT_RETRY)) {
             spawn_connection(stream, queue.clone(), ctx.clone(), &mut workers, TIMEOUT);
         }
     });
@@ -47,6 +51,11 @@ pub fn start(port: u16, queue: Queue, ctx: CtxSlot) {
     }
 }
 
+/// The connections `incoming` accepts, calling `wait` after each failed accept.
+fn accepted<T>(incoming: impl Iterator<Item = std::io::Result<T>>, mut wait: impl FnMut()) -> impl Iterator<Item = T> {
+    incoming.filter_map(move |stream| stream.map_err(|_| wait()).ok())
+}
+
 fn spawn_connection(stream: TcpStream, queue: Queue, ctx: CtxSlot, workers: &mut Vec<std::thread::JoinHandle<()>>, timeout: Duration) {
     workers.retain(|worker| !worker.is_finished());
     if workers.len() >= MAX_CONNECTIONS {
diff --git a/apps/figcraft/src/control_server_tests.rs b/apps/figcraft/src/control_server_tests.rs
index d243fb916..011b06133 100644
--- a/apps/figcraft/src/control_server_tests.rs
+++ b/apps/figcraft/src/control_server_tests.rs
@@ -131,6 +131,18 @@ fn idle_and_partial_frame_connections_expire() {
     }
 }
 
+/// A failed accept is followed by a wait before the next one, so a listener that keeps failing
+/// does not spin, and the connections around the failures still come through.
+#[test]
+fn a_failed_accept_waits_before_the_next() {
+    let failed = || Err(std::io::Error::other("no file descriptors left"));
+    let incoming = vec![failed(), Ok(1), failed(), failed(), Ok(2)];
+    let mut waits = 0;
+    let connections: Vec<i32> = accepted(incoming.into_iter(), || waits += 1).collect();
+    assert_eq!(connections, [1, 2]);
+    assert_eq!(waits, 3, "one wait per failed accept");
+}
+
 #[test]
 fn connection_limit_rejects_excess_clients_and_reuses_finished_slots() {
     let pending = queue();
@@ -160,7 +172,11 @@ fn connection_limit_rejects_excess_clients_and_reuses_finished_slots() {
     assert_eq!(workers.len(), 1);
     client.write_all(b"invalid\n").unwrap();
     assert_eq!(reply(&mut BufReader::new(client.try_clone().unwrap()))["ok"], false);
-    client.shutdown(Shutdown::Both).unwrap();
+    // The server closes this connection after answering an invalid request, and shutting down
+    // a socket whose peer has already closed is ENOTCONN on macOS and the BSDs where Linux
+    // returns Ok. Closing the client is what the worker is waiting for, so the result is moot:
+    // the other shutdowns in this file run while the peer is still open and stay checked.
+    let _ = client.shutdown(Shutdown::Both);
     workers.pop().unwrap().join().unwrap();
 }
 
diff --git a/apps/figcraft/src/main.rs b/apps/figcraft/src/main.rs
index fdcc66f9e..0b71149a9 100644
--- a/apps/figcraft/src/main.rs
+++ b/apps/figcraft/src/main.rs
@@ -6,6 +6,12 @@
 //! `--control <port>` (or `FIGCRAFT_CONTROL_PORT`) starts a localhost JSON-lines control server:
 //! `{"id":1,"method":"engine.execute","params":{"command":"shape.rectangle","params":{"x":0,"y":0,"width":100,"height":100}}}`
 //! → `{"id":1,"ok":true,"result":{…}}`. Methods: `figcraft_ui_egui::control`.
+//!
+//! `--automation-read-root <dir>` / `--automation-write-root <dir>` (each repeatable) confine the
+//! files the window and the control channel read and write (`figcraft_engine::file_access`); the
+//! app's own folders (settings, recovery copies, installed plugins) and opening the files given on
+//! the command line are not. A root that isn't an existing folder stops the app at startup, and so
+//! does any flag the app doesn't know (a mistyped root flag must not start the app unconfined).
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
 #![cfg_attr(all(target_os = "windows", not(debug_assertions)), windows_subsystem = "windows")]
 
@@ -100,10 +106,13 @@ impl eframe::App for App {
     }
 
     fn on_exit(&mut self) {
-        with_app(|fig| services::save_state(fig));
-        if let Some(r) = recovery::lock(&self.recovery).take() {
-            r.finish();
-        }
+        // With the app out of reach (busy), its recovery copies stay for the next start.
+        let copies = recovery::lock(&self.recovery).take();
+        with_app(|fig| services::shutdown(fig, services::config_dir().as_deref(), copies));
+        // Everything is kept: end before the windows' teardown, where AppKit's Touch Bar support
+        // throws on the content view AccessKit restores (craft-libs#3, #781).
+        #[cfg(target_os = "macos")]
+        std::process::exit(0);
     }
 }
 
@@ -119,6 +128,23 @@ fn main() -> eframe::Result {
         return Ok(());
     }
     let args = args::parse(&args);
+    if let Some(flag) = args.unknown.first() {
+        eprintln!(
+            "FigCraft: unknown option {flag}\nUsage: figcraft [--control PORT] [--automation-read-root DIR]... [--automation-write-root DIR]... [FILE | figcraft://join?...]..."
+        );
+        std::process::exit(2);
+    }
+    let roots = match (
+        args.read_roots.is_empty() && args.write_roots.is_empty(),
+        figcraft_engine::file_access::Roots::new(&args.read_roots, &args.write_roots),
+    ) {
+        (true, _) => None,
+        (false, Ok(r)) => Some(Arc::new(r)),
+        (false, Err(e)) => {
+            eprintln!("FigCraft: {e}");
+            std::process::exit(2);
+        }
+    };
     let port = args.control.or_else(|| std::env::var("FIGCRAFT_CONTROL_PORT").ok().and_then(|p| p.parse().ok()));
     // System fonts: index them in the background, then wake the UI (an idle window draws no frames)
     // to lay text out again with them.
@@ -143,6 +169,7 @@ fn main() -> eframe::Result {
             log::error!("{f}: {e}");
         }
     }
+    let opened: Vec<u64> = session.docs.iter().map(|d| d.uid).collect();
     // Documents a crashed or killed run left unsaved come back; this run keeps its own copies.
     let recovery_root = services::config_dir().map(|d| d.join("Recovery"));
     // The preferences first: they hold the online files a recovered document may be one of.
@@ -164,17 +191,18 @@ fn main() -> eframe::Result {
     // default, never a build from source unless asked).
     session.live.links = figcraft_collab_net::links::system();
     session.invite_links_startup();
-    // A first run (no settings kept yet, nothing to open) starts on the home screen, with its
-    // tips and templates; later runs start in a new file.
     let first_run = svc.prefs.is_none() && args.join.is_none();
-    if session.docs.is_empty() && !first_run {
+    if session.docs.is_empty() && opens_new_file(first_run, session.prefs.start_on_home, port.is_some()) {
         let _ = session.execute("file.new", &json!({}));
     }
     // The interface language from the first frame on, and for the message when the window can't
     // open (no frame then).
     figcraft_ui_egui::i18n::set(&session.prefs.language, figcraft_ui_egui::Services::system_language(&svc).as_deref());
     let mut fig = FigApp::new(session, Box::new(svc));
+    fig.automation_roots = roots;
     fig.ui.home = false;
+    // Files named on the command line are the user's too: their missing fonts are listed.
+    fig.ui.font_checks = opened;
     fig.note_recovered(recovered.copies);
     if let Some(link) = &args.join {
         figcraft_ui_egui::live::open_invite(&mut fig, link);
@@ -192,15 +220,15 @@ fn main() -> eframe::Result {
         .with_inner_size([1440.0, 900.0])
         .with_min_inner_size([800.0, 500.0])
         .with_drag_and_drop(true);
-    // The tab strip is the title bar: macOS keeps its window buttons inset into it; elsewhere the
-    // window is frameless and FigCraft draws the buttons and resize edges.
-    if cfg!(target_os = "macos") {
-        viewport = viewport.with_fullsize_content_view(true).with_titlebar_shown(false).with_title_shown(false);
-        fig.ui.title_bar = figcraft_ui_egui::TitleBar::Inset;
-    } else {
-        viewport = viewport.with_decorations(false);
-        fig.ui.title_bar = figcraft_ui_egui::TitleBar::Custom;
-    }
+    // Who draws the window frame is decided once, before the viewport is built, by the shared
+    // craft-window crate (the rest of the Craft suite uses it too). On macOS the system frame is
+    // kept with FigCraft's inset traffic lights; on Windows it is the system frame; on Linux the
+    // decision follows the desktop: a Wayland compositor with server-side decorations (KDE, Sway,
+    // Hyprland, COSMIC) or an X11 window manager keeps the native frame, while GNOME's Mutter —
+    // which draws no server-side frame — leaves it to the app's own custom title bar. This replaces
+    // the old bespoke xdg-decoration probe that always drew FigCraft's custom title bar on KDE.
+    fig.ui.title_bar = desktop_title_bar();
+    viewport = window_chrome(viewport, fig.ui.title_bar);
     if let Some(icon) = icon {
         viewport = viewport.with_icon(icon);
     }
@@ -233,3 +261,115 @@ fn main() -> eframe::Result {
     }
     result
 }
+
+/// With nothing to open, whether the window starts in a new file rather than on the home screen.
+/// A first run (no settings kept yet) shows the home screen's tips and templates, and later runs
+/// start in a new file unless the preference asks for Home, which `--control` overrides: its
+/// callers expect a document to act on.
+fn opens_new_file(first_run: bool, start_on_home: bool, control: bool) -> bool {
+    !first_run && (!start_on_home || control)
+}
+
+/// The title bar FigCraft starts with, decided by the shared craft-window crate so every Craft app
+/// agrees on who draws the frame per desktop. The override variable is `FIGCRAFT_TITLEBAR`
+/// (`app` / `system`). macOS keeps its inset traffic lights unchanged (craft-window returns the
+/// desktop frame there); Windows keeps the system frame; on Linux the compositor/window manager
+/// decides (KDE/Sway/Hyprland/COSMIC and X11 keep the native frame, GNOME gets the custom one).
+fn desktop_title_bar() -> figcraft_ui_egui::TitleBar {
+    let choice = craft_window::Choice::probe(craft_window::Prefix::new("FIGCRAFT"));
+    title_bar_for(choice.into_frame())
+}
+
+/// Map craft-window's [`craft_window::Frame`] onto FigCraft's own [`figcraft_ui_egui::TitleBar`].
+///
+/// `Frame::App` means the app draws its own frame — FigCraft's custom title bar. `Frame::Desktop`
+/// means the desktop draws it, but FigCraft keeps each platform's existing look there:
+/// - macOS: the inset title bar with its traffic lights (`TitleBar::Inset`), unchanged.
+/// - Windows: FigCraft's own custom title bar (`TitleBar::Custom`), unchanged — Windows never used
+///   the plain native frame, and craft-window returning `Desktop` on Windows must not change that.
+/// - Linux and the BSDs: the compositor's native frame (`TitleBar::Native`). This is the only
+///   behaviour change: KDE and the other server-side-decoration compositors now keep their frame.
+fn title_bar_for(frame: craft_window::Frame) -> figcraft_ui_egui::TitleBar {
+    use figcraft_ui_egui::TitleBar;
+    match frame {
+        craft_window::Frame::Desktop if cfg!(target_os = "macos") => TitleBar::Inset,
+        // Windows kept FigCraft's own title bar before this change; keep it.
+        craft_window::Frame::Desktop if cfg!(target_os = "windows") => TitleBar::Custom,
+        craft_window::Frame::Desktop => TitleBar::Native,
+        // The app draws the frame (GNOME's Wayland session, or a `FIGCRAFT_TITLEBAR=app` override).
+        craft_window::Frame::App(_) => TitleBar::Custom,
+    }
+}
+
+fn window_chrome(viewport: egui::ViewportBuilder, title_bar: figcraft_ui_egui::TitleBar) -> egui::ViewportBuilder {
+    use figcraft_ui_egui::TitleBar;
+    match title_bar {
+        TitleBar::Inset => viewport.with_fullsize_content_view(true).with_titlebar_shown(false).with_title_shown(false),
+        TitleBar::Native => viewport.with_decorations(true),
+        TitleBar::Custom => viewport.with_decorations(false),
+    }
+}
+
+#[cfg(test)]
+mod title_bar_tests {
+    use figcraft_ui_egui::TitleBar;
+
+    /// craft-window's app frame (GNOME's Wayland session, or a `FIGCRAFT_TITLEBAR=app` override)
+    /// becomes FigCraft's custom title bar on every platform, and `window_chrome` then drops the
+    /// decorations so FigCraft draws its own.
+    #[test]
+    fn the_app_frame_maps_to_the_custom_title_bar() {
+        let layout = craft_window::Layout::default();
+        let bar = super::title_bar_for(craft_window::Frame::App(layout));
+        assert_eq!(bar, TitleBar::Custom);
+        let viewport = super::window_chrome(egui::ViewportBuilder::default(), bar);
+        assert_eq!(viewport.decorations, Some(false));
+    }
+
+    /// craft-window's desktop frame keeps each platform's existing look: macOS its inset traffic
+    /// lights, Windows FigCraft's own custom title bar (unchanged), and Linux/BSD the compositor's
+    /// native frame. The Linux case is the only behaviour change: KDE and the other
+    /// server-side-decoration compositors now keep their native frame.
+    #[test]
+    fn the_desktop_frame_is_mapped_per_platform() {
+        let bar = super::title_bar_for(craft_window::Frame::Desktop);
+        if cfg!(target_os = "macos") {
+            assert_eq!(bar, TitleBar::Inset);
+        } else if cfg!(target_os = "windows") {
+            // Windows kept its own title bar before and must keep it now.
+            assert_eq!(bar, TitleBar::Custom);
+            let viewport = super::window_chrome(egui::ViewportBuilder::default(), bar);
+            assert_eq!(viewport.decorations, Some(false));
+        } else {
+            assert_eq!(bar, TitleBar::Native);
+            let viewport = super::window_chrome(egui::ViewportBuilder::default(), bar);
+            assert_eq!(viewport.decorations, Some(true));
+        }
+    }
+
+    /// macOS is untouched by this change: its inset title bar with the system traffic lights stays,
+    /// and `window_chrome` still asks for the full-size content view rather than toggling the
+    /// window decorations.
+    #[test]
+    #[cfg(target_os = "macos")]
+    fn macos_keeps_its_inset_title_bar() {
+        let bar = super::desktop_title_bar();
+        assert_eq!(bar, TitleBar::Inset);
+        let viewport = super::window_chrome(egui::ViewportBuilder::default(), bar);
+        assert_eq!(viewport.fullsize_content_view, Some(true));
+        assert_eq!(viewport.title_shown, Some(false));
+    }
+}
+
+#[cfg(test)]
+mod start_tests {
+    use super::opens_new_file;
+
+    #[test]
+    fn the_home_preference_starts_on_home_except_for_control_callers() {
+        assert!(opens_new_file(false, false, false), "a new file by default");
+        assert!(!opens_new_file(false, true, false), "Home when the preference asks");
+        assert!(opens_new_file(false, true, true), "--control still starts with a document");
+        assert!(!opens_new_file(true, false, false), "a first run shows the home screen");
+    }
+}
diff --git a/apps/figcraft/src/recovery.rs b/apps/figcraft/src/recovery.rs
index b2614598f..06b0cbeb7 100644
--- a/apps/figcraft/src/recovery.rs
+++ b/apps/figcraft/src/recovery.rs
@@ -120,8 +120,7 @@ impl Recovery {
         (0..10).find_map(|n| {
             let dir = root.join(if n == 0 { pid.to_string() } else { format!("{pid}-{n}") });
             std::fs::create_dir_all(&dir).ok()?;
-            let lock = File::options().write(true).create(true).truncate(false).open(dir.join(LOCK)).ok()?;
-            lock.try_lock().ok()?;
+            let lock = lock_folder(&dir).ok()?;
             Some(Self { dir, _lock: lock, written: HashMap::new(), next: 0.0, waiting: Vec::new() })
         })
     }
@@ -250,6 +249,17 @@ impl Recovery {
         self.written.insert(uid, Copy { done: None, flight: Some((vec![revision], writer)) });
     }
 
+    /// Quitting: a normal quit ([`finish`](Self::finish)) when the unsaved-changes question was
+    /// `asked` or nothing is unsaved. Otherwise (macOS's Quit menu ends the app without asking) the
+    /// unsaved documents are copied and the copies stay for the next start, as after a crash.
+    pub fn quit(mut self, s: &Session, asked: bool) {
+        if asked || !s.docs.iter().any(|d| needs_copy(s, d)) {
+            return self.finish();
+        }
+        self.write(s, true);
+        self.settle(s);
+    }
+
     /// A normal quit: the documents were saved or their changes discarded on purpose. (Earlier
     /// runs' copies still waiting for their outcome stay for the next start.)
     pub fn finish(self) {
@@ -282,6 +292,17 @@ fn remove_kept(w: Waiting) {
 /// The extension of the note beside the copy of a document that is one of your online files.
 const ONLINE: &str = "online";
 
+/// How long the startup waits, once, for folder locks that may free themselves (#334).
+#[cfg(unix)]
+const LOCK_WAIT: std::time::Duration = std::time::Duration::from_millis(100);
+
+/// Lock the folder `dir` (`WouldBlock` while another process holds it).
+fn lock_folder(dir: &Path) -> Result<File, std::fs::TryLockError> {
+    let lock = File::options().write(true).create(true).truncate(false).open(dir.join(LOCK)).map_err(std::fs::TryLockError::Error)?;
+    lock.try_lock()?;
+    Ok(lock)
+}
+
 /// The copy at `file` is of one of your online files: join that file again as its owner, keeping
 /// the copy to compare with what arrives. The session, or `None` when the copy isn't one (or its
 /// file isn't recorded any more, or is open already): then it opens as any other copy.
@@ -351,6 +372,7 @@ pub fn recover_all(root: &Path, s: &mut Session) -> Recovered {
             }
         }
     };
+    let (mut free, mut held) = (Vec::new(), Vec::new());
     for e in entries.flatten() {
         let path = e.path();
         if !path.is_dir() {
@@ -358,10 +380,22 @@ pub fn recover_all(root: &Path, s: &mut Session) -> Recovered {
             continue;
         }
         // Still running (another window of the app), or not ours to take.
-        let Ok(lock) = File::options().write(true).create(true).truncate(false).open(path.join(LOCK)) else { continue };
-        if lock.try_lock().is_err() {
-            continue;
+        match lock_folder(&path) {
+            Ok(lock) => free.push((path, lock)),
+            Err(std::fs::TryLockError::WouldBlock) => held.push(path),
+            Err(_) => {}
         }
+    }
+    // A child between its `fork` and its `exec` shares the run's open descriptors, and a `flock`
+    // lasts while any of them is open, so an ended run's folder can look held for a moment. Wait
+    // once, however many folders are held, and try those again (#334). Windows doesn't pass the
+    // lock to child processes.
+    #[cfg(unix)]
+    if !held.is_empty() {
+        std::thread::sleep(LOCK_WAIT);
+        free.extend(held.into_iter().filter_map(|path| lock_folder(&path).ok().map(|lock| (path, lock))));
+    }
+    for (path, lock) in free {
         let lock = Arc::new(lock);
         let files: Vec<PathBuf> = std::fs::read_dir(&path).into_iter().flatten().flatten().map(|f| f.path()).collect();
         for f in &files {
diff --git a/apps/figcraft/src/recovery_tests.rs b/apps/figcraft/src/recovery_tests.rs
index a3d608f9d..0322e2374 100644
--- a/apps/figcraft/src/recovery_tests.rs
+++ b/apps/figcraft/src/recovery_tests.rs
@@ -167,6 +167,23 @@ fn a_normal_quit_removes_the_recovered_copies_it_took_over() {
     let _ = std::fs::remove_dir_all(&root);
 }
 
+#[test]
+fn quitting_without_the_unsaved_question_keeps_copies_for_the_next_start() {
+    let root = root("quitunasked");
+    // macOS's Quit menu: nothing asked, so the unsaved document comes back next time.
+    let s = edited();
+    Recovery::start(&root).unwrap().quit(&s, false);
+    let mut next = Session::empty();
+    assert_eq!(recover(&root, &mut next), 1);
+    let _ = std::fs::remove_dir_all(&root);
+    // Asked (saved or discarded on purpose), or nothing unsaved: nothing is left.
+    for (s, asked) in [(edited(), true), (Session::new(), false)] {
+        Recovery::start(&root).unwrap().quit(&s, asked);
+        assert!(std::fs::read_dir(&root).unwrap().next().is_none(), "asked: {asked}");
+    }
+    let _ = std::fs::remove_dir_all(&root);
+}
+
 #[test]
 fn a_run_whose_folder_name_is_still_held_takes_another() {
     let root = root("pidreuse");
@@ -186,6 +203,29 @@ fn a_run_whose_folder_name_is_still_held_takes_another() {
     let _ = std::fs::remove_dir_all(&root);
 }
 
+/// #334: a lock that frees itself is not a run that is still going. A child between its `fork` and
+/// its `exec` inherits the run's open descriptors and a `flock` lasts while any descriptor for the
+/// file is open, so a crashed run's copies must still come back once that child has exec'd.
+#[cfg(unix)]
+#[test]
+fn a_lock_freed_a_moment_later_is_not_a_run_that_is_still_going() {
+    let root = root("fork-window");
+    crashed(&edited(), &root);
+    // Hold the crashed run's folder lock on a second descriptor, the way a child forked before its
+    // exec holds it, and free it shortly after.
+    let lock = std::fs::File::options().write(true).create(true).truncate(false).open(root.join("crashed").join("lock")).unwrap();
+    lock.try_lock().unwrap();
+    let freed = std::thread::spawn(move || {
+        std::thread::sleep(std::time::Duration::from_millis(10));
+        drop(lock);
+    });
+    // The next start waits for that lock rather than reading the run as still going.
+    let mut next = Session::empty();
+    assert_eq!(recover(&root, &mut next), 1, "the copies come back once the lock frees itself");
+    freed.join().unwrap();
+    let _ = std::fs::remove_dir_all(&root);
+}
+
 /// The rectangles in `doc`.
 fn rectangles(doc: &figcraft_engine::doc::Document) -> usize {
     doc.nodes().filter(|n| matches!(n.kind, figcraft_engine::doc::NodeKind::Rectangle)).count()
diff --git a/apps/figcraft/src/services.rs b/apps/figcraft/src/services.rs
index fa95e123d..cee8765b7 100644
--- a/apps/figcraft/src/services.rs
+++ b/apps/figcraft/src/services.rs
@@ -238,10 +238,18 @@ fn reveal(path: &Path) -> std::io::Result<()> {
 /// The preferences' file in the config folder.
 const STATE: &str = "state.json";
 
-pub fn save_state(app: &FigApp) {
-    if let Some(dir) = config_dir() {
-        write_prefs(&dir, &app.session.prefs);
+/// Everything quitting keeps, all done when it returns (macOS then ends the process): the
+/// preferences in `dir`, this run's recovery copies ([`Recovery::quit`](crate::recovery::Recovery::quit))
+/// and the live sessions' ends (one this app hosts tells everyone and stops; a joined one leaves).
+pub fn shutdown(app: &mut FigApp, dir: Option<&Path>, recovery: Option<crate::recovery::Recovery>) {
+    if let Some(dir) = dir {
+        write_prefs(dir, &app.session.prefs);
     }
+    // Before the sessions end: a recovered online file's copy waits for its session's outcome.
+    if let Some(r) = recovery {
+        r.quit(&app.session, app.ui.quit);
+    }
+    drop(std::mem::take(&mut app.session.live));
 }
 
 /// Write `prefs` to `dir` atomically (a temporary file renamed over the old one: a crash leaves
@@ -294,12 +302,47 @@ fn picked(pick: impl Future<Output = Option<rfd::FileHandle>> + 'static) -> Dial
     Box::pin(async move { pick.await.map(|f| f.path().to_path_buf()) })
 }
 
+/// How long a clipboard read may wait on the app that copied (Linux and the BSDs).
+#[cfg(all(unix, not(target_os = "macos")))]
+const CLIPBOARD_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(2);
+
+/// Read the clipboard. On Linux and the BSDs the read runs on a helper thread with its own handle
+/// and gives up after [`CLIPBOARD_TIMEOUT`]: a Wayland read waits on the app that copied with no
+/// timeout of its own, so an app that hangs must not hang the window too.
+#[cfg(all(unix, not(target_os = "macos")))]
+fn read_clipboard<T: Send + 'static>(_: &mut arboard::Clipboard, read: fn(&mut arboard::Clipboard) -> Option<T>) -> Option<T> {
+    let (tx, rx) = std::sync::mpsc::channel();
+    std::thread::spawn(move || {
+        let _ = tx.send(arboard::Clipboard::new().ok().and_then(|mut c| read(&mut c)));
+    });
+    rx.recv_timeout(CLIPBOARD_TIMEOUT).ok().flatten()
+}
+
+/// Read the clipboard (the system's own reads don't wait on the app that copied).
+#[cfg(not(all(unix, not(target_os = "macos"))))]
+fn read_clipboard<T>(c: &mut arboard::Clipboard, read: fn(&mut arboard::Clipboard) -> Option<T>) -> Option<T> {
+    read(c)
+}
+
+/// Native Save as filters; other callers keep their existing combined filter.
+fn save_filters<'a>(exts: &'a [&'a str]) -> Vec<(&'static str, &'a [&'a str])> {
+    if exts == ["figcraft", "fig"] {
+        vec![("FigCraft (.figcraft)", &exts[..1]), (figcraft_ui_egui::i18n::tr(".fig (experimental)"), &exts[1..])]
+    } else {
+        vec![("File", exts)]
+    }
+}
+
 impl Services for Desktop {
     fn pick_open(&mut self, title: &str, exts: &[&str]) -> DialogFuture {
         picked(dialog(title).add_filter("Supported files", exts).pick_file())
     }
     fn pick_save(&mut self, title: &str, name: &str, exts: &[&str]) -> DialogFuture {
-        picked(dialog(title).set_file_name(name).add_filter("File", exts).save_file())
+        let mut dialog = dialog(title).set_file_name(name);
+        for (label, extensions) in save_filters(exts) {
+            dialog = dialog.add_filter(label, extensions);
+        }
+        picked(dialog.save_file())
     }
     fn pick_folder(&mut self, title: &str) -> DialogFuture {
         picked(dialog(title).pick_folder())
@@ -310,7 +353,10 @@ impl Services for Desktop {
         }
     }
     fn clipboard_get_text(&mut self) -> Option<String> {
-        self.clipboard.as_mut()?.get_text().ok()
+        read_clipboard(self.clipboard.as_mut()?, |c| c.get_text().ok())
+    }
+    fn clipboard_get_html(&mut self) -> Option<String> {
+        read_clipboard(self.clipboard.as_mut()?, |c| c.get().html().ok())
     }
     fn clipboard_set_png(&mut self, w: u32, h: u32, rgba: &[u8]) {
         if let Some(c) = self.clipboard.as_mut() {
@@ -318,7 +364,7 @@ impl Services for Desktop {
         }
     }
     fn clipboard_get_image(&mut self) -> Option<(u32, u32, Vec<u8>)> {
-        let img = self.clipboard.as_mut()?.get_image().ok()?;
+        let img = read_clipboard(self.clipboard.as_mut()?, |c| c.get_image().ok())?;
         let (w, h) = (u32::try_from(img.width).ok()?, u32::try_from(img.height).ok()?);
         // Refuse absurd sizes (and mismatched buffers) rather than allocate.
         if w == 0 || h == 0 || u64::from(w) * u64::from(h) > 100_000_000 || img.bytes.len() != (w as usize) * (h as usize) * 4 {
@@ -375,3 +421,24 @@ pub fn window_icon() -> Option<egui::IconData> {
     let (w, h) = img.dimensions();
     Some(egui::IconData { rgba: img.into_raw(), width: w, height: h })
 }
+
+#[cfg(test)]
+mod save_filter_tests {
+    use super::save_filters;
+
+    #[test]
+    fn native_and_fig_save_filters_are_separate_with_native_first() {
+        let extensions = ["figcraft", "fig"];
+        assert_eq!(
+            save_filters(&extensions),
+            vec![("FigCraft (.figcraft)", &extensions[..1]), (figcraft_ui_egui::i18n::tr(".fig (experimental)"), &extensions[1..])]
+        );
+    }
+
+    #[test]
+    fn other_save_filters_keep_one_combined_group() {
+        for extensions in [&["figcraft"][..], &["fig"][..], &["png"][..], &["png", "jpg", "webp"][..], &[][..]] {
+            assert_eq!(save_filters(extensions), vec![("File", extensions)]);
+        }
+    }
+}
diff --git a/apps/figcraft/src/services_tests.rs b/apps/figcraft/src/services_tests.rs
index 2390b92fc..2abec5bba 100644
--- a/apps/figcraft/src/services_tests.rs
+++ b/apps/figcraft/src/services_tests.rs
@@ -82,3 +82,38 @@ fn preferences_are_readable_by_their_owner_only() {
     assert_eq!(mode(&dir.join("state.json")), 0o600);
     let _ = std::fs::remove_dir_all(&dir);
 }
+
+/// A live link that only records the sessions it was told to leave.
+struct Leaves(Arc<Mutex<Vec<u64>>>);
+
+impl figcraft_engine::live::LiveLink for Leaves {
+    fn host(&mut self, _: u64, _: figcraft_engine::live::HostOptions) -> Result<figcraft_engine::live::SessionInfo, String> {
+        Err("not in this test".into())
+    }
+    fn join(&mut self, _: u64, _: &str, _: &str) -> Result<(), String> {
+        Ok(())
+    }
+    fn leave(&mut self, session: u64) {
+        self.0.lock().unwrap().push(session);
+    }
+    fn presence(&mut self, _: u64, _: &figcraft_engine::live::Presence) {}
+    fn send(&mut self, _: u64, _: figcraft_engine::figcraft_collab::message::ClientMsg) {}
+    fn poll(&mut self) -> Vec<(u64, figcraft_engine::live::Event)> {
+        Vec::new()
+    }
+}
+
+#[test]
+fn quitting_keeps_the_preferences_and_ends_the_live_sessions() {
+    let dir = root("shutdown");
+    let mut fig = start(&dir);
+    let left = Arc::new(Mutex::new(Vec::new()));
+    fig.session.live.install(Box::new(Leaves(left.clone())));
+    let joined = fig.run("collab.join", json!({"link": "ws://127.0.0.1:9/?file=f1&token=EditSecretEditSecret00"})).unwrap();
+    fig.session.prefs.user_name = "Ada".into();
+    crate::services::shutdown(&mut fig, Some(&dir), None);
+    assert_eq!(*left.lock().unwrap(), [joined["session"].as_u64().unwrap()], "the session was left");
+    assert!(!fig.session.live.available(), "nothing is left to send on");
+    assert_eq!(start(&dir).session.prefs.user_name, "Ada", "the preferences were kept");
+    let _ = std::fs::remove_dir_all(&dir);
+}
diff --git a/contributors/people.toml b/contributors/people.toml
index bc8cf71bb..6a92a2a98 100644
--- a/contributors/people.toml
+++ b/contributors/people.toml
@@ -24,6 +24,10 @@ display_name = "VanTan"
 real_name = "Tyler Jennings"
 display_name = "tylerjenningsw"
 
+[people.SiadeLucas]
+real_name = "Siade Lucas"
+sync_github_name = true
+
 [people.Silvertree2010]
 display_name = "Netter"
 sync_github_name = false
@@ -37,6 +41,11 @@ real_name = "Justin John"
 
 [people.Losminek]
 
+[people.alrifatsabbir]
+real_name = "Al Rifat Sabbir"
+display_name = "Al Rifat Sabbir"
+sync_github_name = true
+
 [people.RevDonz]
 
 [people.Nael-Nathanael]
@@ -44,3 +53,26 @@ sync_github_name = true
 
 [people.volkovskey]
 real_name = "Andrii Volkov"
+
+[people.marcoarnulfo]
+real_name = "Marco Arnulfo"
+display_name = "Marco Arnulfo"
+sync_github_name = false
+
+[people.krinry]
+display_name = "krinry"
+sync_github_name = true
+
+[people.pechnikov2026-star]
+sync_github_name = true
+
+[people.MortenHusted]
+sync_github_name = true
+
+[people.AganzeFelicite]
+sync_github_name = true
+
+[people.switch87]
+real_name = "Gert Pellin"
+display_name = "Gert Pellin"
+sync_github_name = false
diff --git a/crates/collab-net/src/barred_tests.rs b/crates/collab-net/src/barred_tests.rs
index c9355a5fa..7942e766c 100644
--- a/crates/collab-net/src/barred_tests.rs
+++ b/crates/collab-net/src/barred_tests.rs
@@ -51,3 +51,47 @@ fn a_closed_file_forgets_whom_it_barred() {
     assert!(!hub.barred.contains_key("f"), "and its barred addresses went with it");
     assert!(hub.barred.contains_key("other"), "another file's stay");
 }
+
+#[test]
+fn a_kicked_connection_with_a_full_queue_is_shut() {
+    use std::io::Read;
+    use std::net::TcpListener;
+    use std::sync::Arc;
+    use std::sync::atomic::AtomicUsize;
+    use std::sync::mpsc::sync_channel;
+    use std::time::Duration;
+
+    use super::{Conn, Kind, Line, Out};
+
+    let listener = TcpListener::bind("127.0.0.1:0").unwrap();
+    let mut client = std::net::TcpStream::connect(listener.local_addr().unwrap()).unwrap();
+    let (server_side, _) = listener.accept().unwrap();
+    client.set_read_timeout(Some(Duration::from_secs(2))).unwrap();
+    // Stands in for the writer thread's handle: it keeps the socket open after the Conn is gone.
+    let _writer = server_side.try_clone().unwrap();
+    let (tx, _rx) = sync_channel(2);
+    while tx.try_send(Out::Bytes(Default::default(), None)).is_ok() {}
+    let out = Line {
+        tx,
+        queued: Arc::default(),
+        block: Arc::new(AtomicUsize::new(0)),
+        all: Arc::new(AtomicUsize::new(0)),
+        max: 1 << 20,
+        max_block: usize::MAX,
+        max_all: usize::MAX,
+    };
+    let ip = IpAddr::V4(Ipv4Addr::LOCALHOST);
+    let mut hub = Hub {
+        in_flight: InFlight(Default::default()),
+        backend: Closes,
+        rooms: HashMap::new(),
+        conns: HashMap::from([(1, Conn { out, sock: server_side, kind: Kind::Managing, ip })]),
+        local: None,
+        outbox: Vec::new(),
+        barred: HashMap::new(),
+    };
+    hub.kick(&[1], "kicked");
+    assert!(hub.conns.is_empty());
+    let mut buf = [0u8; 1];
+    assert_eq!(client.read(&mut buf).ok(), Some(0), "the kicked socket must be shut (client sees EOF)");
+}
diff --git a/crates/collab-net/src/code_tests.rs b/crates/collab-net/src/code_tests.rs
index 4880242f4..7fe766ec5 100644
--- a/crates/collab-net/src/code_tests.rs
+++ b/crates/collab-net/src/code_tests.rs
@@ -141,7 +141,9 @@ fn old_server() -> (Endpoint, std::thread::JoinHandle<()>) {
     let t = std::thread::spawn(move || {
         for stream in listener.incoming().take(2).flatten() {
             let Ok(mut ws) = tungstenite::accept(stream) else { continue };
-            let _ = ws.read();
+            // read() returns Result<Message>, not a lock guard; this test server deliberately
+            // ignores whatever the client sent first.
+            let _ = ws.read(); // NOSONAR
             let refused = ServerMsg::Refused { reason: "that message couldn't be read".into() };
             let _ = ws.send(Message::Binary(Bytes::from(message::encode(&refused).unwrap())));
             let _ = ws.close(None);
diff --git a/crates/collab-net/src/driver.rs b/crates/collab-net/src/driver.rs
index b8f6c1541..4ebbec157 100644
--- a/crates/collab-net/src/driver.rs
+++ b/crates/collab-net/src/driver.rs
@@ -16,7 +16,7 @@ use figcraft_engine::live::{Event, Status};
 use web_time::Instant;
 
 use crate::inbox::Inbox;
-use crate::join::{GuestConfig, Next, Outcome, Resuming, Seen, Taken, after, closed, hello, resolved, take, unresolved};
+use crate::join::{GuestConfig, Next, Outcome, Resuming, Seen, Taken, after, closed, hello, resolved, take, too_large, unresolved};
 use crate::throttle::{PRESENCE_INTERVAL, Throttle, earliest};
 
 /// A WebSocket the driver opens, writes and closes; what it receives comes back through the
@@ -114,6 +114,9 @@ impl<S: Socket> Driver<S> {
     /// A binary message from the host.
     pub(crate) fn message(&mut self, bytes: &[u8], now: Instant) {
         let Some(c) = self.conn.as_mut() else { return };
+        if bytes.len() > self.cfg.limits.max_server_message {
+            return self.end(too_large(&self.cfg.limits), now);
+        }
         c.last_heard = now;
         let taken = match message::decode::<ServerMsg>(bytes, self.cfg.limits.max_server_message) {
             // The join code's answer: join the file it opens, on a new connection.
diff --git a/crates/collab-net/src/driver_tests.rs b/crates/collab-net/src/driver_tests.rs
index ca6563c5f..5e395b981 100644
--- a/crates/collab-net/src/driver_tests.rs
+++ b/crates/collab-net/src/driver_tests.rs
@@ -10,7 +10,7 @@ use std::time::{Duration, Instant};
 use figcraft_collab::message::{self, ClientMsg, Presence, ServerMsg};
 use figcraft_collab::{Client, Limits, Outgoing, Server};
 use figcraft_doc::{Document, NodeId};
-use figcraft_engine::live::{Event, Status};
+use figcraft_engine::live::{Event, Status, TOO_LARGE_TO_JOIN};
 use tungstenite::protocol::WebSocket;
 use tungstenite::{Bytes, Message};
 
@@ -262,6 +262,15 @@ fn refusals_and_the_end_of_the_session_are_final() {
         assert!(d.done());
         assert!(matches!(statuses(&inbox.drain()).last(), Some(Status::Failed { reason }) if reason.starts_with("The host refused")));
     }
+    // A message over the size limit: the file is too large for this app, not refused by the host.
+    let inbox = Inbox::new(Arc::new(|| {}));
+    let mut cfg = GuestConfig::new(invite(), "Ada".into());
+    cfg.limits.max_server_message = 2 << 20;
+    let mut d = Driver::start(Script::default(), cfg, inbox.clone(), t0);
+    d.opened(t0);
+    d.message(&vec![0; (2 << 20) + 1], t0);
+    assert!(d.done());
+    assert!(matches!(statuses(&inbox.drain()).last(), Some(Status::Failed { reason }) if *reason == TOO_LARGE_TO_JOIN.replace("{mb}", "2")));
 }
 
 #[test]
diff --git a/crates/collab-net/src/guest.rs b/crates/collab-net/src/guest.rs
index eb899b8df..2e1d5046c 100644
--- a/crates/collab-net/src/guest.rs
+++ b/crates/collab-net/src/guest.rs
@@ -26,7 +26,7 @@ use tungstenite::{Bytes, Message};
 use crate::inbox::Inbox;
 use crate::invite::{Endpoint, Invite};
 pub use crate::join::GuestConfig;
-use crate::join::{Next, Outcome, Resuming, Seen, Taken, after, closed, hello, resolved, take, unresolved};
+use crate::join::{Next, Outcome, Resuming, Seen, Taken, after, closed, hello, resolved, take, too_large, unresolved};
 use crate::manage;
 use crate::net::{Duplex, NetLimits, config, open, shutdown};
 use crate::throttle::{PRESENCE_INTERVAL, Throttle, earliest};
@@ -367,7 +367,7 @@ fn read_loop(mut ws: WebSocket<Duplex>, ctx: &ReaderCtx) {
             Ok(Message::Close(f)) => break f.map_or_else(|| closed(0, ""), |f| closed(f.code.into(), &f.reason)),
             Ok(Message::Text(_)) => break Outcome::Refused("the host sent a text message".into()),
             Ok(_) => {}
-            Err(tungstenite::Error::Capacity(_)) => break Outcome::Refused("the host sent a message over the size limit".into()),
+            Err(tungstenite::Error::Capacity(_)) => break too_large(&ctx.cfg.limits),
             Err(e) => break Outcome::Retry(e.to_string()),
         }
     };
diff --git a/crates/collab-net/src/hub.rs b/crates/collab-net/src/hub.rs
index 5cf3e5191..2f87334db 100644
--- a/crates/collab-net/src/hub.rs
+++ b/crates/collab-net/src/hub.rs
@@ -402,6 +402,8 @@ enum HubIn {
         sock: TcpStream,
         /// Its size (in flight until handled).
         bytes: usize,
+        /// Told when the hub takes the connection in (dropped unsent when it doesn't).
+        admitted: SyncSender<()>,
     },
     Msg {
         conn: u64,
@@ -811,17 +813,22 @@ fn encode(msg: &ServerMsg) -> Option<Bytes> {
 
 /// Queue `Refused {reason}` and a close for one connection (small: not counted against its caps).
 fn refuse(out: &Line, why: &str) {
+    refused(out, why);
+}
+
+/// [`refuse`], and whether the close was queued (it isn't when the queue is full).
+fn refused(out: &Line, why: &str) -> bool {
     if let Some(b) = encode(&ServerMsg::Refused { reason: why.to_string() }) {
         let _ = out.tx.try_send(Out::Bytes(b, None));
     }
-    let _ = out.tx.try_send(Out::Close(CloseCode::Policy, reason(why)));
+    out.tx.try_send(Out::Close(CloseCode::Policy, reason(why))).is_ok()
 }
 
 /// What the server tells a client when it is too busy to take more from it.
 const BUSY: &str = "the server is busy: try again in a moment";
 
-/// Read the next binary message (skipping pings) and its size, or why the connection should end.
-fn next_message(ws: &mut WebSocket<Duplex>, max: usize) -> Result<Option<(ClientMsg, usize)>, String> {
+/// Read the next binary message (skipping pings, until `deadline`) and its size, or why the connection should end.
+fn next_message(ws: &mut WebSocket<Duplex>, max: usize, deadline: Option<Instant>) -> Result<Option<(ClientMsg, usize)>, String> {
     loop {
         return match ws.read() {
             Ok(Message::Binary(b)) => {
@@ -830,6 +837,10 @@ fn next_message(ws: &mut WebSocket<Duplex>, max: usize) -> Result<Option<(Client
                 message::decode::<ClientMsg>(&b, max).map(|m| Some((m, b.len()))).map_err(|_| "that message couldn't be read".to_string())
             }
             Ok(Message::Text(_)) => Err("only binary messages are spoken here".into()),
+            // Pings keep the per-read timeout alive, but not the overall deadline (slowloris).
+            Ok(Message::Ping(_) | Message::Pong(_) | Message::Frame(_)) if deadline.is_some_and(|d| Instant::now() >= d) => {
+                Err("no hello in time".into())
+            }
             Ok(Message::Ping(_) | Message::Pong(_) | Message::Frame(_)) => continue,
             Ok(Message::Close(_)) => Ok(None),
             Err(tungstenite::Error::Capacity(_)) => Err(too_large(max)),
@@ -851,6 +862,7 @@ fn too_large(max: usize) -> String {
 /// One connection's reader (the writer runs on its own thread).
 fn serve(mut stream: TcpStream, conn: u64, hub: &Sender<HubIn>, limits: NetLimits, open: Open, shared: &Shared) {
     let _ = stream.set_nodelay(true);
+    let hello_deadline = Instant::now() + limits.hello_timeout;
     if stream.set_read_timeout(Some(limits.hello_timeout)).is_err() || stream.set_write_timeout(Some(limits.write_timeout)).is_err() {
         return;
     }
@@ -923,7 +935,7 @@ fn serve(mut stream: TcpStream, conn: u64, hub: &Sender<HubIn>, limits: NetLimit
         log::info!("event=refused ip={ip} reason=connections_per_address");
         end(Some("too many connections from your address: close some and try again"));
     } else {
-        match next_message(&mut ws, limits.max_hello) {
+        match next_message(&mut ws, limits.max_hello, Some(hello_deadline)) {
             Ok(Some((
                 first @ (ClientMsg::Hello(_)
                 | ClientMsg::Manage(_)
@@ -946,9 +958,13 @@ fn serve(mut stream: TcpStream, conn: u64, hub: &Sender<HubIn>, limits: NetLimit
                 if reserved || !shared.in_flight.take(bytes, limits.max_in_flight) {
                     end(Some(BUSY));
                 } else {
-                    ws.set_config(|c| *c = config(max));
-                    let opened = sock.try_clone().is_ok_and(|s| hub.send(HubIn::Open { conn, ip, first, out: out.clone(), sock: s, bytes }).is_ok());
-                    if opened && ws.get_ref().set_read_timeout(Some(idle)).is_ok() {
+                    let (admitted, verdict) = sync_channel(1);
+                    let opened =
+                        sock.try_clone().is_ok_and(|s| hub.send(HubIn::Open { conn, ip, first, out: out.clone(), sock: s, bytes, admitted }).is_ok());
+                    // Nothing more is read until the hub took the connection in (its token checked):
+                    // only then may it send messages of the full size.
+                    if opened && verdict.recv().is_ok() && ws.get_ref().set_read_timeout(Some(idle)).is_ok() {
+                        ws.set_config(|c| *c = config(max));
                         read_loop(&mut ws, conn, hub, limits, max, &shared.in_flight, &end);
                         let _ = hub.send(HubIn::Gone { conn });
                     }
@@ -981,7 +997,7 @@ fn read_loop(
     let mut bucket = Bucket::new(limits.rate, limits.burst);
     let mut signals = Bucket::new(SIGNAL_RATE, SIGNAL_BURST);
     loop {
-        match next_message(ws, max) {
+        match next_message(ws, max, None) {
             Ok(Some((msg, bytes))) => {
                 let now = Instant::now();
                 if !bucket.take(now) {
@@ -1074,6 +1090,8 @@ struct Pending {
     out: Line,
     sock: TcpStream,
     ip: IpAddr,
+    /// Told when it is taken in.
+    admitted: SyncSender<()>,
 }
 
 /// A connection the hub took in.
@@ -1195,7 +1213,7 @@ impl<B: Backend> Hub<B> {
 
     fn handle(&mut self, m: HubIn) {
         match m {
-            HubIn::Open { conn, ip, first, out, sock, bytes } => {
+            HubIn::Open { conn, ip, first, out, sock, bytes, admitted } => {
                 self.in_flight.give(bytes);
                 // The operator (with the server key) gets in from anywhere; everyone else is
                 // checked (blocked addresses, connection rates).
@@ -1204,7 +1222,7 @@ impl<B: Backend> Hub<B> {
                     log::info!("event=refused ip={ip} reason={why:?}");
                     return refuse(&out, &why);
                 }
-                let c = Pending { out, sock, ip };
+                let c = Pending { out, sock, ip, admitted };
                 match first {
                     ClientMsg::Hello(hello) => self.join(conn, hello, c),
                     ClientMsg::Manage(m) => self.manage(conn, &m, c),
@@ -1399,6 +1417,7 @@ impl<B: Backend> Hub<B> {
                 if let Some(c) = old.and_then(|old| self.conns.remove(&old)) {
                     shutdown(&c.sock);
                 }
+                let _ = c.admitted.try_send(());
                 self.conns
                     .insert(conn, Conn { out: c.out, sock: c.sock, kind: Kind::Joined { file: file.clone(), id, link: admission.link }, ip: c.ip });
                 self.queue(&file, more);
@@ -1429,7 +1448,9 @@ impl<B: Backend> Hub<B> {
             barred.insert(c.ip);
         }
         log::info!("event=removed file={file} client={id} ip={}", c.ip);
-        let _ = c.out.tx.try_send(Out::Close(CloseCode::Away, REMOVED.into()));
+        if c.out.tx.try_send(Out::Close(CloseCode::Away, REMOVED.into())).is_err() {
+            shutdown(&c.sock);
+        }
         self.gone(conn);
         Ok(())
     }
@@ -1444,6 +1465,7 @@ impl<B: Backend> Hub<B> {
 
     /// Take in connection `c` as `kind` and send it `first`.
     fn take_in(&mut self, conn: u64, c: Pending, kind: Kind, first: &ServerMsg) {
+        let _ = c.admitted.try_send(());
         self.conns.insert(conn, Conn { out: c.out, sock: c.sock, kind, ip: c.ip });
         self.answer(conn, first);
     }
@@ -1543,8 +1565,10 @@ impl<B: Backend> Hub<B> {
             // People in the file are told the session is over for them, as when a host stops (they
             // keep their copy; nothing retries); a library request is refused.
             for conn in &people {
-                if let Some(c) = self.conns.get(conn) {
-                    let _ = c.out.tx.try_send(Out::Close(CloseCode::Away, STOPPED.into()));
+                if let Some(c) = self.conns.get(conn)
+                    && c.out.tx.try_send(Out::Close(CloseCode::Away, STOPPED.into())).is_err()
+                {
+                    shutdown(&c.sock);
                 }
                 self.gone(*conn);
             }
@@ -1593,8 +1617,10 @@ impl<B: Backend> Hub<B> {
     /// Refuse connections with `why` and drop them at once (nothing more they send counts).
     fn kick(&mut self, conns: &[u64], why: &str) {
         for conn in conns {
-            if let Some(c) = self.conns.get(conn) {
-                refuse(&c.out, why);
+            if let Some(c) = self.conns.get(conn)
+                && !refused(&c.out, why)
+            {
+                shutdown(&c.sock);
             }
             self.gone(*conn);
         }
@@ -1747,3 +1773,7 @@ mod queue_tests;
 #[cfg(test)]
 #[path = "barred_tests.rs"]
 mod barred_tests;
+
+#[cfg(test)]
+#[path = "preauth_tests.rs"]
+mod preauth_tests;
diff --git a/crates/collab-net/src/inbox.rs b/crates/collab-net/src/inbox.rs
index fb505a0aa..1ec00e67c 100644
--- a/crates/collab-net/src/inbox.rs
+++ b/crates/collab-net/src/inbox.rs
@@ -11,11 +11,18 @@ use figcraft_engine::live::{Event, Presence};
 pub type Waker = Arc<dyn Fn() + Send + Sync>;
 
 /// Most discrete events kept between two drains (joins, leaves, status); the oldest go first.
+/// Document sync events don't count and are never dropped: the sync client treats a missing
+/// batch as a fatal sequence gap, so losing one would end the session.
 const MAX_EVENTS: usize = 10_000;
 
 #[derive(Default)]
 struct State {
-    events: VecDeque<Event>,
+    /// Arrival number of the next event, so [`Inbox::drain`] can merge the two queues in order.
+    next: u64,
+    /// [`Event::Sync`] events, never dropped.
+    syncs: VecDeque<(u64, Event)>,
+    /// Every other event, capped at [`MAX_EVENTS`].
+    others: VecDeque<(u64, Event)>,
     presence: BTreeMap<u32, Presence>,
 }
 
@@ -43,11 +50,17 @@ impl Inbox {
             if let Event::PeerLeft(id) = &e {
                 s.presence.remove(id);
             }
-            if s.events.len() >= MAX_EVENTS {
-                log::warn!("live session: {MAX_EVENTS} events not taken; dropping the oldest");
-                s.events.pop_front();
+            let n = s.next;
+            s.next += 1;
+            if matches!(e, Event::Sync(_)) {
+                s.syncs.push_back((n, e));
+                return;
             }
-            s.events.push_back(e);
+            if s.others.len() >= MAX_EVENTS {
+                log::warn!("live session: {MAX_EVENTS} events not taken; dropping the oldest");
+                s.others.pop_front();
+            }
+            s.others.push_back((n, e));
         });
     }
 
@@ -62,8 +75,70 @@ impl Inbox {
     /// peer.
     pub fn drain(&self) -> Vec<figcraft_engine::live::Event> {
         let mut s = self.state.lock().unwrap_or_else(PoisonError::into_inner);
-        let mut out: Vec<Event> = s.events.drain(..).collect();
+        let mut syncs = std::mem::take(&mut s.syncs).into_iter().peekable();
+        let mut others = std::mem::take(&mut s.others).into_iter().peekable();
+        let mut out = Vec::with_capacity(syncs.len() + others.len() + s.presence.len());
+        loop {
+            let sync_first = match (syncs.peek(), others.peek()) {
+                (Some((a, _)), Some((b, _))) => a < b,
+                (Some(_), None) => true,
+                (None, Some(_)) => false,
+                (None, None) => break,
+            };
+            let next = if sync_first { syncs.next() } else { others.next() };
+            out.extend(next.map(|(_, e)| e));
+        }
         out.extend(std::mem::take(&mut s.presence).into_iter().map(|(id, p)| Event::Presence(id, p)));
         out
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use figcraft_collab::message::ServerMsg;
+
+    fn reject(batch_id: u64) -> Event {
+        Event::Sync(ServerMsg::Reject { batch_id, reason: String::new(), fixes: Vec::new() })
+    }
+
+    fn sync_ids(events: &[Event]) -> Vec<u64> {
+        events
+            .iter()
+            .filter_map(|e| match e {
+                Event::Sync(ServerMsg::Reject { batch_id, .. }) => Some(*batch_id),
+                _ => None,
+            })
+            .collect()
+    }
+
+    #[test]
+    fn a_full_inbox_never_drops_sync_events() {
+        let inbox = Inbox::new(Arc::new(|| {}));
+        inbox.push(reject(1));
+        for _ in 0..MAX_EVENTS {
+            inbox.push(Event::PeerLeft(7));
+        }
+        inbox.push(reject(2));
+        for _ in 0..MAX_EVENTS {
+            inbox.push(Event::PeerLeft(7));
+        }
+        let out = inbox.drain();
+        assert_eq!(sync_ids(&out), vec![1, 2]);
+        assert!(out.len() <= MAX_EVENTS + 2, "{} events kept", out.len());
+    }
+
+    #[test]
+    fn sync_events_past_the_cap_are_all_kept_in_order() {
+        let inbox = Inbox::new(Arc::new(|| {}));
+        let n = MAX_EVENTS as u64 + 5;
+        for id in 0..n {
+            inbox.push(reject(id));
+        }
+        inbox.push(Event::PeerLeft(7));
+        let out = inbox.drain();
+        let ids = sync_ids(&out);
+        assert_eq!(ids.len() as u64, n, "Sync events dropped");
+        assert!(ids.iter().copied().eq(0..n), "Sync events out of order");
+    }
+}
diff --git a/crates/collab-net/src/invite.rs b/crates/collab-net/src/invite.rs
index bfa2e606e..e5d86bf29 100644
--- a/crates/collab-net/src/invite.rs
+++ b/crates/collab-net/src/invite.rs
@@ -203,7 +203,7 @@ fn pairs(query: &str) -> Result<Vec<(String, String)>, String> {
 fn with_port(authority: &str, default: u16) -> String {
     let has_port = match authority.rsplit_once(':') {
         // `[v6]` alone has colons inside the brackets only.
-        Some((h, p)) => !(h.starts_with('[') && !h.ends_with(']')) && !p.contains(']'),
+        Some((h, p)) => (!h.starts_with('[') || h.ends_with(']')) && !p.contains(']'),
         None => false,
     };
     if has_port { authority.to_string() } else { format!("{authority}:{default}") }
@@ -220,7 +220,8 @@ fn valid_host(s: &str) -> bool {
         return true;
     }
     let Some((name, port)) = s.rsplit_once(':') else { return false };
-    port.parse::<u16>().is_ok_and(|p| p != 0)
+    port.bytes().all(|b| b.is_ascii_digit())
+        && port.parse::<u16>().is_ok_and(|p| p != 0)
         && (1..=253).contains(&name.len())
         && name.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'-' || b == b'.')
         && !name.starts_with(['-', '.'])
@@ -239,6 +240,9 @@ fn percent_decode(s: &str) -> Option<String> {
     while let Some(&b) = bytes.get(i) {
         if b == b'%' {
             let hex = bytes.get(i + 1..i + 3)?;
+            if !hex.iter().all(u8::is_ascii_hexdigit) {
+                return None;
+            }
             out.push(u8::from_str_radix(std::str::from_utf8(hex).ok()?, 16).ok()?);
             i += 3;
         } else {
diff --git a/crates/collab-net/src/invite_tests.rs b/crates/collab-net/src/invite_tests.rs
index 02017517d..b7618dc28 100644
--- a/crates/collab-net/src/invite_tests.rs
+++ b/crates/collab-net/src/invite_tests.rs
@@ -123,3 +123,19 @@ proptest! {
         prop_assert_eq!(Invite::parse(&i.url()), Ok(i));
     }
 }
+
+#[test]
+fn plus_or_sign_inside_a_percent_escape_is_broken() {
+    assert!(Endpoint::parse("ws://example.org/a/?key=%41").is_ok());
+    for bad in ["%+1", "%-1", "%1", "%+a"] {
+        assert!(Endpoint::parse(&format!("ws://example.org/a/?key={bad}")).is_err(), "{bad}");
+    }
+}
+
+#[test]
+fn port_must_be_all_digits() {
+    assert!(Endpoint::parse("ws://localhost:80/").is_ok());
+    for bad in ["ws://localhost:+80/", "ws://localhost:-80/", "ws://localhost:/"] {
+        assert!(Endpoint::parse(bad).is_err(), "accepted {bad}");
+    }
+}
diff --git a/crates/collab-net/src/join.rs b/crates/collab-net/src/join.rs
index 81cd2437c..cc3be839f 100644
--- a/crates/collab-net/src/join.rs
+++ b/crates/collab-net/src/join.rs
@@ -7,7 +7,7 @@ use std::time::Duration;
 
 use figcraft_collab::Client;
 use figcraft_collab::message::{ClientMsg, Peer, Resume, ServerMsg};
-use figcraft_engine::live::{Event, Role, SessionInfo, Status};
+use figcraft_engine::live::{Event, Role, SessionInfo, Status, TOO_LARGE_TO_JOIN};
 
 use crate::inbox::Inbox;
 use crate::invite::Invite;
@@ -95,6 +95,12 @@ pub(crate) fn unresolved(cfg: &GuestConfig, outcome: Outcome) -> Outcome {
     })
 }
 
+/// The host sent a message over this app's size limit (the file's welcome, usually): final, and
+/// not the host's doing.
+pub(crate) fn too_large(limits: &NetLimits) -> Outcome {
+    Outcome::Failed(TOO_LARGE_TO_JOIN.replace("{mb}", &(limits.max_server_message >> 20).to_string()))
+}
+
 /// The server's answer to the join code: the invite is whole now.
 pub(crate) fn resolved(cfg: &mut GuestConfig, file: String, token: String) -> Result<(), Outcome> {
     if !crate::invite::valid_id(&file, 1, 64) || !crate::invite::valid_id(&token, 16, 128) {
diff --git a/crates/collab-net/src/limits.rs b/crates/collab-net/src/limits.rs
index c31118767..a0647fa6a 100644
--- a/crates/collab-net/src/limits.rs
+++ b/crates/collab-net/src/limits.rs
@@ -12,7 +12,9 @@ pub struct NetLimits {
     /// before: its hello.
     pub max_client_message: usize,
     pub max_hello: usize,
-    /// Largest message a client accepts from the host (a welcome carries the whole document).
+    /// Largest message a client accepts from the host (a welcome carries the whole document): 1 GiB,
+    /// room for any file up to 1023 MiB and well past the servers' defaults, while a hostile server
+    /// (any link can name one) can't make the app or a browser tab buffer more than that.
     pub max_server_message: usize,
     /// Messages a client may send per second on average, and in a burst; beyond that it is
     /// disconnected.
@@ -61,7 +63,7 @@ impl Default for NetLimits {
             max_connections: 64,
             max_client_message: figcraft_collab::Limits::default().max_message_bytes,
             max_hello: 64 << 10,
-            max_server_message: figcraft_collab::Limits::default().max_message_bytes,
+            max_server_message: 1 << 30,
             rate: 100.0,
             burst: 400.0,
             hello_timeout: Duration::from_secs(10),
diff --git a/crates/collab-net/src/loopback_tests.rs b/crates/collab-net/src/loopback_tests.rs
index 32c86bd0c..464d8714e 100644
--- a/crates/collab-net/src/loopback_tests.rs
+++ b/crates/collab-net/src/loopback_tests.rs
@@ -10,7 +10,7 @@ use std::time::{Duration, Instant};
 use figcraft_collab::message::{self, ClientMsg, Hello, Presence, ServerMsg, Signal};
 use figcraft_collab::{Client, Limits};
 use figcraft_doc::{Document, NodeId};
-use figcraft_engine::live::{Event, PEOPLE, Status};
+use figcraft_engine::live::{Event, PEOPLE, Status, TOO_LARGE_TO_JOIN};
 use tungstenite::protocol::WebSocket;
 use tungstenite::{Bytes, Message};
 
@@ -642,3 +642,62 @@ fn the_host_removes_someone_and_they_cant_come_back() {
     host.stop();
     assert_eq!(host.connections(), 0);
 }
+
+#[test]
+fn a_welcome_over_the_size_limit_says_the_file_is_too_large() {
+    let mut doc = Document::new("B".repeat(1 << 20));
+    doc.repair();
+    let probe = Probe::new();
+    let cfg = HostConfig {
+        addr: SocketAddr::from(([127, 0, 0, 1], 0)),
+        any_port_if_taken: false,
+        file: FILE.into(),
+        token: TOKEN.into(),
+        doc,
+        name: "Hana".into(),
+        limits: fast_limits(),
+        core: Limits::default(),
+    };
+    let mut host = Host::start(cfg, probe.inbox.clone()).unwrap();
+    let invite = Invite::new(host.addr().to_string(), FILE, TOKEN);
+
+    let mut guest_cfg = quick(GuestConfig::new(invite, "Ada".into()));
+    guest_cfg.limits = NetLimits { max_server_message: 1 << 20, ..fast_limits() };
+    let mut gp = Probe::new();
+    let _g = Guest::start(guest_cfg, gp.inbox.clone()).unwrap();
+    let too_large = TOO_LARGE_TO_JOIN.replace("{mb}", "1");
+    gp.wait("the file too large to join", |e| e.iter().any(|ev| matches!(ev, Event::Status(Status::Failed { reason }) if *reason == too_large)));
+    assert!(!welcomed(&gp.events));
+    host.stop();
+}
+
+#[test]
+fn pings_do_not_keep_a_connection_without_a_hello_alive() {
+    let (mut host, _hp, invite) = start_with(NetLimits { hello_timeout: Duration::from_secs(1), ..fast_limits() }, Limits::default());
+    let addr: SocketAddr = invite.server.host.parse().unwrap();
+    let mut r = Raw::connect(addr);
+    let t0 = Instant::now();
+    let mut closed = None;
+    while t0.elapsed() < Duration::from_secs(6) {
+        if r.0.send(Message::Ping(Bytes::new())).is_err() || r.0.flush().is_err() {
+            closed = Some(t0.elapsed());
+            break;
+        }
+        std::thread::sleep(Duration::from_millis(300));
+        // Drain what the host sent back (pongs, the close); an error means it hung up.
+        r.0.get_mut().set_read_timeout(Some(Duration::from_millis(10))).unwrap();
+        match r.0.read() {
+            Ok(Message::Close(_)) | Err(tungstenite::Error::ConnectionClosed | tungstenite::Error::AlreadyClosed) => {
+                closed = Some(t0.elapsed());
+                break;
+            }
+            Err(tungstenite::Error::Io(e)) if !matches!(e.kind(), std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut) => {
+                closed = Some(t0.elapsed());
+                break;
+            }
+            _ => {}
+        }
+    }
+    assert!(closed.is_some_and(|t| t < Duration::from_secs(3)), "pinged pre-hello connection survived: {closed:?}");
+    host.stop();
+}
diff --git a/crates/collab-net/src/manage.rs b/crates/collab-net/src/manage.rs
index 6e995bdb8..dc3ec3154 100644
--- a/crates/collab-net/src/manage.rs
+++ b/crates/collab-net/src/manage.rs
@@ -206,10 +206,15 @@ fn connect(server: &Endpoint, limits: &NetLimits, timeout: Duration) -> Result<W
     Ok(ws)
 }
 
-/// Close politely: read until the server's close arrives (or the socket ends), so it isn't lost.
+/// How long `close` waits for the server's close.
+const CLOSE_DRAIN: Duration = Duration::from_secs(2);
+
+/// Close politely: read until the server's close arrives (or the socket ends), so it isn't lost,
+/// but no longer than [`CLOSE_DRAIN`] (a server that keeps pinging would pin the loop).
 fn close(mut ws: Ws) {
     let _ = ws.close(None);
-    while ws.read().is_ok() {}
+    let deadline = std::time::Instant::now() + CLOSE_DRAIN;
+    while std::time::Instant::now() < deadline && ws.read().is_ok() {}
 }
 
 fn send(ws: &mut Ws, msg: &ClientMsg) -> Result<(), String> {
@@ -240,3 +245,31 @@ fn reply<T>(ws: &mut Ws, limits: &NetLimits, pick: impl Fn(ServerMsg) -> Option<
         };
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// A server that keeps pinging and never answers the close must not pin `close` forever.
+    #[test]
+    fn close_returns_against_a_server_that_keeps_pinging() {
+        let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
+        let addr = listener.local_addr().unwrap();
+        std::thread::spawn(move || {
+            let (s, _) = listener.accept().unwrap();
+            let Ok(mut ws) = tungstenite::accept(s) else { return };
+            while ws.send(Message::Ping(Bytes::new())).is_ok() {
+                std::thread::sleep(Duration::from_millis(10));
+            }
+        });
+        let limits = NetLimits { idle_timeout: Duration::from_millis(300), ..NetLimits::default() };
+        let server = Endpoint { host: addr.to_string(), path: "/".into(), secure: false };
+        let ws = connect(&server, &limits, Duration::from_secs(2)).unwrap();
+        let (tx, rx) = std::sync::mpsc::channel();
+        std::thread::spawn(move || {
+            close(ws);
+            let _ = tx.send(());
+        });
+        assert!(rx.recv_timeout(Duration::from_secs(3)).is_ok(), "close() kept draining a pinging server");
+    }
+}
diff --git a/crates/collab-net/src/preauth_tests.rs b/crates/collab-net/src/preauth_tests.rs
new file mode 100644
index 000000000..5ae91665c
--- /dev/null
+++ b/crates/collab-net/src/preauth_tests.rs
@@ -0,0 +1,72 @@
+//! A connection whose hello the backend hasn't admitted yet is held to the hello's size limit: it
+//! can't have a message of the full size read while its token is unchecked.
+
+use std::net::{SocketAddr, TcpListener, TcpStream};
+use std::sync::mpsc::{Receiver, channel};
+use std::time::{Duration, Instant};
+
+use figcraft_collab::message::{self, ClientMsg, ServerMsg, Signal};
+use figcraft_collab::{Client, Server};
+use tungstenite::{Bytes, Message};
+
+use super::{Admission, Backend, Closing, Hosting};
+use crate::net::NetLimits;
+
+/// A backend that refuses every hello, once it is told to.
+struct Slow(Receiver<()>);
+
+impl Backend for Slow {
+    fn admit(&mut self, _file: &str, _token: &str) -> Result<Admission, String> {
+        let _ = self.0.recv();
+        Err("wrong token".into())
+    }
+
+    fn open(&mut self, _file: &str) -> Result<Server, String> {
+        Err("no".into())
+    }
+
+    fn closing(&self) -> Closing {
+        Closing::Ended
+    }
+}
+
+fn connect(addr: SocketAddr) -> tungstenite::WebSocket<TcpStream> {
+    let s = TcpStream::connect(addr).unwrap();
+    s.set_read_timeout(Some(Duration::from_secs(10))).unwrap();
+    tungstenite::client::client(format!("ws://{addr}/"), s).unwrap().0
+}
+
+#[test]
+fn an_unadmitted_connection_cant_send_a_large_message() {
+    let limits = NetLimits { hello_timeout: Duration::from_secs(5), ..NetLimits::default() };
+    let (release, wait) = channel();
+    let mut hosting = Hosting::serve(TcpListener::bind("127.0.0.1:0").unwrap(), Slow(wait), limits).unwrap();
+    let addr = hosting.addr();
+    let sender = std::thread::spawn(move || {
+        let mut ws = connect(addr);
+        let hello = message::encode(&Client::hello("0123456789abcdef", "bad", "x", "")).unwrap();
+        ws.send(Message::Binary(Bytes::from(hello))).unwrap();
+        let big = ClientMsg::Signal(Signal { kind: Signal::CHAT.into(), text: "x".repeat(1 << 20) });
+        let _ = ws.send(Message::Binary(Bytes::from(message::encode(&big).unwrap())));
+        let mut refused = None;
+        while let Ok(m) = ws.read() {
+            if let Message::Binary(b) = m
+                && let Ok(ServerMsg::Refused { reason }) = message::decode(&b, 64 << 20)
+            {
+                refused = Some(reason);
+            }
+        }
+        refused
+    });
+    let mut peak = 0;
+    let until = Instant::now() + Duration::from_secs(2);
+    while Instant::now() < until {
+        peak = peak.max(hosting.in_flight_bytes());
+        std::thread::sleep(Duration::from_millis(2));
+    }
+    release.send(()).unwrap();
+    let refused = sender.join().unwrap();
+    hosting.stop();
+    assert!(peak <= limits.max_hello, "a message of {peak} bytes was read before the token was checked");
+    assert_eq!(refused.as_deref(), Some("wrong token"));
+}
diff --git a/crates/collab/Cargo.toml b/crates/collab/Cargo.toml
index 89a796873..ed85201dc 100644
--- a/crates/collab/Cargo.toml
+++ b/crates/collab/Cargo.toml
@@ -13,6 +13,7 @@ figcraft-doc = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
+chrono = { workspace = true }
 imbl = { workspace = true }
 base64 = { workspace = true }
 postcard = { workspace = true }
diff --git a/crates/collab/src/board_sync_tests.rs b/crates/collab/src/board_sync_tests.rs
new file mode 100644
index 000000000..3dbff8bb0
--- /dev/null
+++ b/crates/collab/src/board_sync_tests.rs
@@ -0,0 +1,45 @@
+//! Boards sync: the file kind reaches joiners in their snapshot, and a layer's board metadata (a
+//! connector's ends, a sticky's author) syncs as one property, through both encodings.
+
+use figcraft_doc::{BoardItem, Connector, Document, End, FileKind, NodeKind, Routing, Side};
+
+use crate::change::{Change, DocProp, Prop};
+use crate::replica::{Mode, Replica};
+use crate::{diff, message};
+
+#[test]
+fn a_boards_kind_and_its_objects_metadata_sync() {
+    let mut doc = Document::new("Board");
+    doc.kind = FileKind::Board;
+    let page = doc.first_page().unwrap();
+    let a = doc.create(page, NodeKind::Frame, "Sticky", 0.0, 0.0, 200.0, 200.0).unwrap();
+    doc.node_mut(a).unwrap().board = Some(BoardItem::Sticky { author: "Ada".into() });
+    let host = Replica::new(doc);
+    // A joiner's copy, built from the snapshot, is a board with the sticky's metadata.
+    let snap = host.snapshot().unwrap();
+    assert!(snap.iter().any(|c| matches!(c, Change::SetDoc { prop: DocProp::Kind, .. })));
+    let joiner = Replica::from_snapshot(&snap).unwrap();
+    assert_eq!(joiner.document().kind, FileKind::Board);
+    assert_eq!(joiner.document().node(a).unwrap().board, host.document().node(a).unwrap().board);
+    // Re-attaching a connector's end is one property write, the same after the wire.
+    let mut edited = host.document().clone();
+    let c = edited.create(page, NodeKind::Vector { network: Default::default() }, "Connector", 0.0, 0.0, 1.0, 1.0).unwrap();
+    edited.node_mut(c).unwrap().board = Some(BoardItem::Connector(Connector {
+        from: End::Node { node: a, side: Side::Auto },
+        to: End::Point { x: 5.0, y: 5.0 },
+        routing: Routing::Elbow,
+    }));
+    let mut r = host.clone();
+    r.apply(&diff(&host, &edited).unwrap().changes, Mode::Strict).unwrap();
+    let mut moved = r.document().clone();
+    moved.node_mut(c).unwrap().board = Some(BoardItem::Connector(Connector {
+        from: End::Node { node: a, side: Side::Top },
+        to: End::Point { x: 9.0, y: 1.0 },
+        routing: Routing::Straight,
+    }));
+    let d = diff(&r, &moved).unwrap();
+    assert!(matches!(d.changes.as_slice(), [Change::Set { prop: Prop::Board, .. }]), "{:?}", d.changes);
+    let wire: Vec<Change> = message::decode(&message::encode(&d.changes).unwrap(), usize::MAX).unwrap();
+    r.apply(&wire, Mode::Strict).unwrap();
+    assert_eq!(r.document(), &moved);
+}
diff --git a/crates/collab/src/change.rs b/crates/collab/src/change.rs
index 32a491843..57bb9cf2d 100644
--- a/crates/collab/src/change.rs
+++ b/crates/collab/src/change.rs
@@ -87,8 +87,9 @@ macro_rules! node_props {
     ($($variant:ident => $field:ident),* $(,)?) => {
         /// A node property: the tree position (`parent`, `position`) or one saved field of
         /// [`Node`]. List-valued fields (fills, text runs, vector networks…) are one property each,
-        /// replaced whole (three-way merges line fills, strokes and effects up item by item, see
-        /// [`merge`](crate::merge)). New properties go at the end (the binary form numbers them).
+        /// replaced whole (three-way merges line the lists whose items stand on their own, such as
+        /// fills, up item by item, see [`merge`](crate::merge)). New properties go at the end (the
+        /// binary form numbers them).
         #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
         #[serde(rename_all = "camelCase")]
         pub enum Prop {
@@ -180,6 +181,7 @@ node_props! {
     Annotations => annotations,
     CodeLinks => code_links,
     DevResources => dev_resources,
+    Board => board,
 }
 
 /// A document-level property. Lists of entries with ids (styles, comments, variable collections,
@@ -218,6 +220,8 @@ pub enum DocProp {
     Variables,
     /// Variable ids in order.
     VariableOrder,
+    /// A design file or a board.
+    Kind,
 }
 
 /// A document-level entry, by id.
diff --git a/crates/collab/src/code.rs b/crates/collab/src/code.rs
index c046682ab..6eebe9f74 100644
--- a/crates/collab/src/code.rs
+++ b/crates/collab/src/code.rs
@@ -135,7 +135,7 @@ impl Local {
         let query = link.strip_prefix("figcraft://join?")?;
         let get = |key: &str| query.split('&').find_map(|kv| kv.split_once('=').filter(|(k, _)| *k == key).map(|(_, v)| v));
         let addr: std::net::SocketAddrV4 = get("host")?.parse().ok()?;
-        let hex = get("token")?.strip_prefix(TOKEN_PREFIX).filter(|h| h.len() == 11)?;
+        let hex = get("token")?.strip_prefix(TOKEN_PREFIX).filter(|h| h.len() == 11 && h.bytes().all(|b| b.is_ascii_hexdigit()))?;
         let local = Local { ip: *addr.ip(), port: addr.port(), secret: u64::from_str_radix(hex, 16).ok()? };
         (get("file") == Some(LOCAL_FILE) && local.port != 0).then_some(local)
     }
diff --git a/crates/collab/src/code_tests.rs b/crates/collab/src/code_tests.rs
index 2dd902b32..31bd34885 100644
--- a/crates/collab/src/code_tests.rs
+++ b/crates/collab/src/code_tests.rs
@@ -104,6 +104,7 @@ fn only_local_session_links_have_a_code() {
         "figcraft://join?host=[::1]:47900&file=local&token=local-0123456789a",
         "figcraft://join?host=192.168.1.20:0&file=local&token=local-0123456789a",
         "figcraft://join?host=192.168.1.20:47900&file=local&token=local-0123456789az",
+        "figcraft://join?host=10.0.0.1:47900&file=local&token=local-+0000000001",
         "figcraft://join?server=wss://example.org/&file=local&token=local-0123456789a",
         "ws://192.168.1.20:47900/?file=local&token=local-0123456789a",
         "",
diff --git a/crates/collab/src/docprops.rs b/crates/collab/src/docprops.rs
index 535c333e4..9b35e05da 100644
--- a/crates/collab/src/docprops.rs
+++ b/crates/collab/src/docprops.rs
@@ -213,6 +213,7 @@ doc_scalars! {
     ImagePresets => image_presets,
     AnnotationCategories => annotation_categories,
     Libraries => libraries,
+    Kind => kind,
 }
 
 /// Keyed maps (no order): changed and added entries are put, missing ones removed.
diff --git a/crates/collab/src/lib.rs b/crates/collab/src/lib.rs
index 2c693bc41..fa271f35b 100644
--- a/crates/collab/src/lib.rs
+++ b/crates/collab/src/lib.rs
@@ -123,6 +123,8 @@ impl Recompute for NoRecompute {
     fn recompute(&self, _: &mut Document, _: &Document, _: &BTreeSet<NodeId>) {}
 }
 
+#[cfg(test)]
+mod board_sync_tests;
 #[cfg(test)]
 mod client_tests;
 #[cfg(test)]
diff --git a/crates/collab/src/merge.rs b/crates/collab/src/merge.rs
index bb18e661e..5132ce75f 100644
--- a/crates/collab/src/merge.rs
+++ b/crates/collab/src/merge.rs
@@ -4,12 +4,13 @@
 //!
 //! A conflict is the same property (or document-level entry) changed on both sides to different
 //! values, or a layer deleted on one side while the other side edited it or something inside it
-//! (including adding layers to it or moving layers into or out of it). Fills, strokes and effects
-//! merge item by item: both sides changing different items of the list (or one adding items at its
-//! end) is no conflict, only the same item changed both ways or the list shortened on a side
-//! while the other changed it. Nothing that conflicts is
-//! merged until it is resolved: each conflict is resolved for one side, and the other side's
-//! changes to it are left out. Everything else from both sides is kept.
+//! (including adding layers to it or moving layers into or out of it). The layer lists whose items
+//! stand on their own (fills, strokes, effects, layout grids, export settings, guides, prototype
+//! interactions, accessibility annotations and Dev Mode resources) merge item by item: both sides
+//! changing different items of the list (or one adding items at its end) is no conflict, only the
+//! same item changed both ways or the list shortened on a side while the other changed it. Nothing
+//! that conflicts is merged until it is resolved: each conflict is resolved for one side, and the
+//! other side's changes to it are left out. Everything else from both sides is kept.
 
 use std::collections::{BTreeMap, BTreeSet};
 use std::fmt;
@@ -159,8 +160,23 @@ fn by_key(changes: &[Change]) -> BTreeMap<Key, Vec<usize>> {
     out
 }
 
-/// List properties whose items merge one by one.
-const PER_ITEM: &[Prop] = &[Prop::Fills, Prop::Strokes, Prop::Effects];
+/// List properties whose items merge one by one: the items stand on their own, so both sides
+/// changing different ones (or one side adding at its end) is no conflict. Sets and keyed maps
+/// (`bound`, `varModes`, `overrides`, `propRefs`, `pluginData`) are not here: their items line up
+/// by key, not by position.
+const PER_ITEM: &[Prop] = &[
+    Prop::Fills,
+    Prop::Strokes,
+    Prop::Effects,
+    Prop::Grids,
+    Prop::Exports,
+    Prop::Guides,
+    Prop::Interactions,
+    Prop::Annotations,
+    // Not `CodeLinks`: there is one per language, and lining them up by position could leave two
+    // for one language (the second hidden), so they merge whole.
+    Prop::DevResources,
+];
 
 /// Both sides' writes `b` and `m` of list property `key` merged item by item against the base
 /// (see [`merge_items`]); `None` when `key` isn't such a list or the writes conflict.
diff --git a/crates/collab/src/merge_list_tests.rs b/crates/collab/src/merge_list_tests.rs
index 436e6b6f3..e92f6bbbf 100644
--- a/crates/collab/src/merge_list_tests.rs
+++ b/crates/collab/src/merge_list_tests.rs
@@ -1,8 +1,10 @@
-//! Fills, strokes and effects merge item by item: different items changed on each side merge,
-//! the same item changed both ways conflicts.
+//! The layer lists whose items stand on their own (fills, strokes, effects, layout grids, export
+//! settings, guides, prototype interactions, accessibility annotations and Dev Mode resources)
+//! merge item by item: different items changed on each side merge, the same item changed both ways
+//! conflicts.
 
 use figcraft_color::{Color, Paint};
-use figcraft_doc::{Document, Effect, NodeId, NodeKind};
+use figcraft_doc::{Document, Effect, LayoutGrid, NodeId, NodeKind, proto};
 use serde_json::{Value, json};
 
 use crate::merge::{Key, Side, merge_items, plan};
@@ -100,19 +102,113 @@ fn the_same_item_changed_both_ways_conflicts() {
 }
 
 #[test]
-fn other_lists_still_conflict_as_a_whole() {
-    // Docs silent: lists other than fills, strokes and effects (export settings here) still
-    // conflict whole when both sides change them.
+fn the_other_item_lists_merge_one_by_one_too() {
+    // Layout grids, export settings, guides, accessibility annotations and Dev Mode resources are
+    // item lists like fills: both sides changing different items merges.
     let (mut base, _, _, r) = files();
     let export = |suffix: &str| figcraft_doc::ExportSetting { suffix: suffix.into(), ..Default::default() };
-    base.get_mut(r).unwrap().exports = vec![export("@1"), export("@2")];
+    let guide = |vertical: bool, offset: f64| figcraft_doc::Guide { vertical, offset };
+    let annot = |label: &str| figcraft_doc::Annotation { label: label.into(), properties: Vec::new(), category: None };
+    let grid = |size: f64| LayoutGrid { size, ..Default::default() };
+    let res = |url: &str| figcraft_doc::DevResource { url: url.into(), name: String::new() };
+    let n = base.get_mut(r).unwrap();
+    n.exports = vec![export("@1"), export("@2")];
+    n.guides = vec![guide(true, 10.0), guide(false, 20.0)];
+    n.annotations = vec![annot("a1"), annot("a2")];
+    n.grids = vec![grid(10.0), grid(20.0)];
+    n.dev_resources = vec![res("https://a.test"), res("https://b.test")];
     let (mut branch, mut main) = (base.clone(), base.clone());
     branch.set_client_id(base.highest_id_space() + 1);
-    branch.get_mut(r).unwrap().exports[0] = export("@b");
-    main.get_mut(r).unwrap().exports[1] = export("@m");
+    // The branch changes the first item of each list; main the second.
+    let b = branch.get_mut(r).unwrap();
+    (b.exports[0].suffix, b.guides[0].offset, b.annotations[0].label, b.grids[0].size, b.dev_resources[0].url) =
+        ("@b".into(), 11.0, "b1".into(), 12.0, "https://branch.test".into());
+    let m = main.get_mut(r).unwrap();
+    (m.exports[1].suffix, m.guides[1].offset, m.annotations[1].label, m.grids[1].size, m.dev_resources[1].url) =
+        ("@m".into(), 22.0, "m2".into(), 24.0, "https://main.test".into());
+    both_ways(&base, &branch, &main, |doc| {
+        let n = doc.node(r).unwrap();
+        let suffixes: Vec<&str> = n.exports.iter().map(|e| e.suffix.as_str()).collect();
+        assert_eq!(suffixes, ["@b", "@m"], "export settings");
+        let offsets: Vec<f64> = n.guides.iter().map(|g| g.offset).collect();
+        assert_eq!(offsets, [11.0, 22.0], "guides");
+        let labels: Vec<&str> = n.annotations.iter().map(|a| a.label.as_str()).collect();
+        assert_eq!(labels, ["b1", "m2"], "annotations");
+        let sizes: Vec<f64> = n.grids.iter().map(|g| g.size).collect();
+        assert_eq!(sizes, [12.0, 24.0], "layout grids");
+        let urls: Vec<&str> = n.dev_resources.iter().map(|d| d.url.as_str()).collect();
+        assert_eq!(urls, ["https://branch.test", "https://main.test"], "dev resources");
+    });
+}
+
+#[test]
+fn the_same_item_of_another_list_changed_both_ways_conflicts() {
+    let (mut base, _, _, r) = files();
+    let link = |language: &str| figcraft_doc::CodeLink { language: language.into(), ..Default::default() };
+    let n = base.get_mut(r).unwrap();
+    n.exports = vec![
+        figcraft_doc::ExportSetting { suffix: "@1".into(), ..Default::default() },
+        figcraft_doc::ExportSetting { suffix: "@2".into(), ..Default::default() },
+    ];
+    n.code_links = vec![link("react"), link("vue")];
+    let (mut branch, mut main) = (base.clone(), base.clone());
+    branch.set_client_id(base.highest_id_space() + 1);
+    branch.get_mut(r).unwrap().exports[0].suffix = "@b".into();
+    main.get_mut(r).unwrap().exports[0].suffix = "@m".into();
+    // Code links are one per language, not an item list: different links changed still conflict.
+    branch.get_mut(r).unwrap().code_links[0].name = "B".into();
+    main.get_mut(r).unwrap().code_links[1].name = "M".into();
     let p = plan(&base, &branch, &main).unwrap();
-    let keys: Vec<String> = p.conflicts.iter().map(|c| c.key.to_string()).collect();
-    assert_eq!(keys, [format!("{r}/exports")]);
+    let mut keys: Vec<String> = p.conflicts.iter().map(|c| c.key.to_string()).collect();
+    keys.sort();
+    let mut want = [format!("{r}/codeLinks"), format!("{r}/exports")];
+    want.sort();
+    assert_eq!(keys, want);
+}
+
+#[test]
+fn interactions_merge_item_by_item() {
+    let ia = |duration_ms: u32| proto::Interaction {
+        trigger: Default::default(),
+        actions: vec![proto::Action::Back],
+        transition: Default::default(),
+        duration_ms,
+        easing: Default::default(),
+        delay_ms: 0,
+    };
+    let durations = |doc: &Document, r: NodeId| doc.node(r).unwrap().interactions.iter().map(|i| i.duration_ms).collect::<Vec<_>>();
+    let (mut base, _, _, r) = files();
+    base.get_mut(r).unwrap().interactions = vec![ia(100), ia(200)];
+    let fork = || {
+        let (mut branch, main) = (base.clone(), base.clone());
+        branch.set_client_id(base.highest_id_space() + 1);
+        (branch, main)
+    };
+    // The branch changes the first interaction and adds one; main changes the second.
+    let (mut branch, mut main) = fork();
+    branch.get_mut(r).unwrap().interactions[0].duration_ms = 150;
+    branch.get_mut(r).unwrap().interactions.push(ia(300));
+    main.get_mut(r).unwrap().interactions[1].duration_ms = 250;
+    both_ways(&base, &branch, &main, |doc| assert_eq!(durations(doc, r), [150, 250, 300]));
+    // The branch deletes one while main leaves them alone.
+    let (mut branch, mut main) = fork();
+    branch.get_mut(r).unwrap().interactions.remove(0);
+    main.get_mut(r).unwrap().fills[0] = red();
+    both_ways(&base, &branch, &main, |doc| assert_eq!(durations(doc, r), [200]));
+    // The same interaction changed both ways, or one deleted while the other side changed the
+    // list, conflicts.
+    for delete in [false, true] {
+        let (mut branch, mut main) = fork();
+        if delete {
+            branch.get_mut(r).unwrap().interactions.remove(0);
+        } else {
+            branch.get_mut(r).unwrap().interactions[1].duration_ms = 220;
+        }
+        main.get_mut(r).unwrap().interactions[1].duration_ms = 250;
+        let p = plan(&base, &branch, &main).unwrap();
+        let keys: Vec<String> = p.conflicts.iter().map(|c| c.key.to_string()).collect();
+        assert_eq!(keys, [format!("{r}/interactions")], "delete: {delete}");
+    }
 }
 
 #[test]
diff --git a/crates/collab/src/message.rs b/crates/collab/src/message.rs
index d035042b2..4fda776af 100644
--- a/crates/collab/src/message.rs
+++ b/crates/collab/src/message.rs
@@ -696,22 +696,38 @@ pub enum ServerMsg {
     },
 }
 
+/// (days since 1970-01-01, seconds-of-day, nanos) → (proleptic Gregorian year, the same wall-clock
+/// instant moved into chrono's range by whole 400-year cycles). The calendar repeats every 400
+/// years (146_097 days), so month, day and time of day come from chrono and only the year is
+/// carried, which keeps the result exact for any `i64` day count. This is not hand-rolled calendar
+/// math: chrono still does the date, the cycle count just shifts the year.
+fn utc_parts(days: i64, sod: u32, nanos: u32) -> (i64, chrono::NaiveDateTime) {
+    use chrono::Datelike;
+    let (cycles, rest) = (days.div_euclid(146_097), days.rem_euclid(146_097));
+    // `rest + 719_163` (1970-01-01 is CE day 719_163) is always a valid CE day, and `sod` < 86_400.
+    let date = i32::try_from(rest + 719_163).ok().and_then(chrono::NaiveDate::from_num_days_from_ce_opt);
+    let time = chrono::NaiveTime::from_num_seconds_from_midnight_opt(sod.min(86_399), nanos.min(999_999_999));
+    match (date, time) {
+        (Some(d), Some(t)) => {
+            let y = i128::from(d.year()) + i128::from(cycles) * 400;
+            (i64::try_from(y).unwrap_or(if y < 0 { i64::MIN } else { i64::MAX }), d.and_time(t))
+        }
+        _ => (1970, chrono::NaiveDateTime::default()), // unreachable
+    }
+}
+
 /// `YYYY-MM-DD HH:MM UTC` for seconds since 1970 (how servers and apps show the times in these
-/// messages).
+/// messages). Years past chrono's own range (262143) keep converting: the instant is moved into
+/// range by whole 400-year cycles and the real year restored, so every `u64` reads as the date the
+/// old hand-rolled conversion produced (e.g. `u64::MAX` → `584554051223-11-09 07:00 UTC`).
 pub fn utc_date(secs: u64) -> String {
-    let days = i64::try_from(secs / 86_400).unwrap_or(0);
-    let (h, m) = ((secs % 86_400) / 3600, (secs % 3600) / 60);
-    // Days to a civil date (proleptic Gregorian).
-    let z = days + 719_468;
-    let era = z.div_euclid(146_097);
-    let doe = z.rem_euclid(146_097);
-    let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
-    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
-    let mp = (5 * doy + 2) / 153;
-    let d = doy - (153 * mp + 2) / 5 + 1;
-    let mo = if mp < 10 { mp + 3 } else { mp - 9 };
-    let y = yoe + era * 400 + i64::from(mo <= 2);
-    format!("{y:04}-{mo:02}-{d:02} {h:02}:{m:02} UTC")
+    // The day count of any `u64` seconds fits in `i64` (`u64::MAX / 86_400` ≈ 2.1e14), and the
+    // seconds-of-day is < 86_400, so the conversion is always exact (no epoch fallback). Splitting
+    // with `u64` arithmetic (as the old code did) avoids the `i64` seconds overflow near `u64::MAX`.
+    let (days, sod) = (i64::try_from(secs / 86_400).unwrap_or(i64::MAX), (secs % 86_400) as u32);
+    let (y, t) = utc_parts(days, sod, 0);
+    // `{y:04}` rather than `%Y`, which writes a `+` before years past 9999 (the old code did not).
+    format!("{y:04}-{}", t.format("%m-%d %H:%M UTC"))
 }
 
 /// The binary form of `msg`: [`WIRE_VERSION`], then postcard.
@@ -752,3 +768,25 @@ pub fn decode_json<T: DeserializeOwned>(text: &str, max_bytes: usize) -> Result<
     }
     serde_json::from_str(text).map_err(|e| Error::Decode(e.to_string()))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// `utc_date` keeps the exact `YYYY-MM-DD HH:MM UTC` output the hand-rolled civil-from-days
+    /// code produced (leap days and all).
+    #[test]
+    fn utc_date_formats_seconds_since_1970() {
+        assert_eq!(utc_date(0), "1970-01-01 00:00 UTC");
+        assert_eq!(utc_date(1_000_000), "1970-01-12 13:46 UTC");
+        assert_eq!(utc_date(951_782_400), "2000-02-29 00:00 UTC");
+        assert_eq!(utc_date(1_709_164_800), "2024-02-29 00:00 UTC");
+        assert_eq!(utc_date(1_791_208_980), "2026-10-05 14:03 UTC");
+        // A year past 9999 keeps the plain zero-padded year (no `+`), as the old `{y:04}` did.
+        assert_eq!(utc_date(253_402_300_800), "10000-01-01 00:00 UTC");
+        // Past chrono's own year range (262143) the instant is moved into range by whole 400-year
+        // cycles and the real year restored, so it keeps the old hand-rolled output instead of
+        // falling back to the epoch.
+        assert_eq!(utc_date(u64::MAX), "584554051223-11-09 07:00 UTC");
+    }
+}
diff --git a/crates/color/src/lib.rs b/crates/color/src/lib.rs
index d6859a510..84149dfbd 100644
--- a/crates/color/src/lib.rs
+++ b/crates/color/src/lib.rs
@@ -61,7 +61,7 @@ impl<'de> Deserialize<'de> for Color {
 }
 
 fn clamp01(v: f32) -> f32 {
-    if v.is_finite() { v.clamp(0.0, 1.0) } else { 0.0 }
+    if v.is_nan() { 0.0 } else { v.clamp(0.0, 1.0) }
 }
 
 impl Default for Color {
@@ -162,7 +162,13 @@ impl Color {
                     p.parse::<f32>().ok().map(|v| v / 255.0)
                 }
             };
-            let alpha = parts.get(3).and_then(|a| parse_alpha(a)).unwrap_or(1.0);
+            let alpha = match parts.get(3) {
+                Some(a) => parse_alpha(a)?,
+                None => 1.0,
+            };
+            if parts.len() > 4 {
+                return None;
+            }
             return Some(Self::new(num(0)?, num(1)?, num(2)?, alpha));
         }
         if let Some(inner) = t.strip_prefix("hsla(").or_else(|| t.strip_prefix("hsl(")).and_then(|r| r.strip_suffix(')')) {
@@ -170,7 +176,13 @@ impl Color {
             let h = parts.first()?.trim_end_matches("deg").parse::<f32>().ok()?;
             let s = parts.get(1)?.trim_end_matches('%').parse::<f32>().ok()? / 100.0;
             let l = parts.get(2)?.trim_end_matches('%').parse::<f32>().ok()? / 100.0;
-            let alpha = parts.get(3).and_then(|a| parse_alpha(a)).unwrap_or(1.0);
+            let alpha = match parts.get(3) {
+                Some(a) => parse_alpha(a)?,
+                None => 1.0,
+            };
+            if parts.len() > 4 {
+                return None;
+            }
             return Some(Hsl { h, s, l }.to_color().with_alpha(alpha));
         }
         if t == "transparent" {
@@ -537,7 +549,7 @@ pub enum PaintKind {
 }
 
 /// One fill or stroke paint.
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct Paint {
     #[serde(flatten)]
     pub kind: PaintKind,
@@ -547,6 +559,17 @@ pub struct Paint {
     pub visible: bool,
     #[serde(default)]
     pub blend: BlendMode,
+    /// The opacity holds the alpha of a typed solid colour (see [`Paint::solid`]) rather than an
+    /// opacity set on its own: a colour variable bound to the paint replaces it.
+    #[serde(default, rename = "colorAlpha", skip_serializing_if = "std::ops::Not::not")]
+    pub color_alpha: bool,
+}
+
+/// Paints compare by what they paint; where the opacity came from doesn't matter.
+impl PartialEq for Paint {
+    fn eq(&self, other: &Self) -> bool {
+        self.kind == other.kind && self.opacity == other.opacity && self.visible == other.visible && self.blend == other.blend
+    }
 }
 
 fn yes() -> bool {
@@ -555,11 +578,17 @@ fn yes() -> bool {
 
 impl Paint {
     pub fn solid(color: Color) -> Self {
-        Self { kind: PaintKind::Solid { color: color.with_alpha(1.0) }, opacity: color.a, visible: true, blend: BlendMode::Normal }
+        Self {
+            kind: PaintKind::Solid { color: color.with_alpha(1.0) },
+            opacity: color.a,
+            visible: true,
+            blend: BlendMode::Normal,
+            color_alpha: color.a < 1.0,
+        }
     }
 
     pub fn gradient(g: Gradient) -> Self {
-        Self { kind: PaintKind::Gradient(g), opacity: 1.0, visible: true, blend: BlendMode::Normal }
+        Self { kind: PaintKind::Gradient(g), opacity: 1.0, visible: true, blend: BlendMode::Normal, color_alpha: false }
     }
 
     pub fn image(hash: impl Into<String>, mode: ImageScaleMode) -> Self {
@@ -575,12 +604,13 @@ impl Paint {
             opacity: 1.0,
             visible: true,
             blend: BlendMode::Normal,
+            color_alpha: false,
         }
     }
 
     /// Layer `source` (a node id) tiled at its own size.
     pub fn pattern(source: u64) -> Self {
-        Self { kind: PaintKind::Pattern(PatternPaint::new(source)), opacity: 1.0, visible: true, blend: BlendMode::Normal }
+        Self { kind: PaintKind::Pattern(PatternPaint::new(source)), opacity: 1.0, visible: true, blend: BlendMode::Normal, color_alpha: false }
     }
 
     /// The solid colour (with the paint opacity folded into alpha), if solid.
diff --git a/crates/color/src/tests.rs b/crates/color/src/tests.rs
index 68a838e05..2216b6fa9 100644
--- a/crates/color/src/tests.rs
+++ b/crates/color/src/tests.rs
@@ -80,7 +80,7 @@ fn blend_names() {
 #[test]
 fn nan_inputs_are_sanitized() {
     let c = Color::new(f32::NAN, 2.0, -1.0, f32::INFINITY);
-    assert_eq!(c.to_rgba8(), [0, 255, 0, 0]);
+    assert_eq!(c.to_rgba8(), [0, 255, 0, 255]);
 }
 
 #[test]
@@ -106,3 +106,21 @@ fn crop_defaults_to_fill_and_roundtrips() {
         assert!((a - b).abs() < 1e-9);
     }
 }
+
+#[test]
+fn infinite_channels_clamp() {
+    let c = Color::parse_css("rgb(1e40, 0, 0)").unwrap();
+    assert_eq!(c.r, 1.0);
+    let c = Color::new(f32::INFINITY, f32::NEG_INFINITY, f32::NAN, f32::INFINITY);
+    assert_eq!((c.r, c.g, c.b, c.a), (1.0, 0.0, 0.0, 1.0));
+}
+
+#[test]
+fn malformed_alpha_or_extra_args_rejected() {
+    assert_eq!(Color::parse_css("rgba(0,0,0,abc)"), None);
+    assert_eq!(Color::parse_css("hsla(0,0%,0%,abc)"), None);
+    assert_eq!(Color::parse_css("rgb(1,2,3,4,5)"), None);
+    assert_eq!(Color::parse_css("hsl(0,0%,0%,0.5,1)"), None);
+    assert_eq!(Color::parse_css("rgb(1,2,3)").unwrap().a, 1.0);
+    assert_eq!(Color::parse_css("rgba(1,2,3,0.5)").unwrap().a, 0.5);
+}
diff --git a/crates/doc/src/board.rs b/crates/doc/src/board.rs
new file mode 100644
index 000000000..28ed0c1d1
--- /dev/null
+++ b/crates/doc/src/board.rs
@@ -0,0 +1,433 @@
+//! Boards: a file kind for whiteboarding, and the small piece of metadata board objects carry.
+//!
+//! Board objects are ordinary nodes (frames, vectors, text) with a [`BoardItem`] on them, so
+//! rendering, hit testing, undo, saving, export, copy and paste and live sessions treat them like
+//! any other layer. The metadata says what the object is for: which text a sticky note fits, what
+//! a connector joins, who placed a stamp.
+
+use figcraft_color::Color;
+use figcraft_geom::kurbo::{Ellipse, RoundedRect};
+use figcraft_geom::{BezPath, Point, Rect, Shape};
+use serde::{Deserialize, Serialize};
+
+use crate::NodeId;
+
+/// What a file is for: designing screens, or a board to think together on.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum FileKind {
+    #[default]
+    Design,
+    Board,
+}
+
+impl FileKind {
+    pub fn is_design(&self) -> bool {
+        *self == FileKind::Design
+    }
+    pub fn id(self) -> &'static str {
+        match self {
+            FileKind::Design => "design",
+            FileKind::Board => "board",
+        }
+    }
+}
+
+/// What a board object is.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "camelCase")]
+pub enum BoardItem {
+    /// A sticky note: a frame whose first text layer is the note (its size shrinks as the note
+    /// grows) and, below it, who wrote it.
+    Sticky {
+        #[serde(default, skip_serializing_if = "String::is_empty")]
+        author: String,
+    },
+    /// A shape with text: a frame holding the outline (a vector) and a centred text.
+    Shape { shape: BoardShape },
+    /// A line between two objects or points (a vector, re-routed when they move).
+    Connector(Connector),
+    /// The label in the middle of connector `connector` (a frame holding its text).
+    Label { connector: NodeId },
+    /// A stamp, and who placed it.
+    Stamp {
+        stamp: Stamp,
+        #[serde(default, skip_serializing_if = "String::is_empty")]
+        author: String,
+    },
+    /// A marker or highlighter stroke (what the eraser takes).
+    Ink,
+}
+
+impl BoardItem {
+    /// Objects selected and moved as a whole: a click on their text or outline picks them, and
+    /// they never take other layers in.
+    pub fn is_atom(&self) -> bool {
+        matches!(self, BoardItem::Sticky { .. } | BoardItem::Shape { .. } | BoardItem::Label { .. } | BoardItem::Stamp { .. })
+    }
+
+    /// Objects whose first text layer is their text (a double-click or Enter edits it).
+    pub fn has_text(&self) -> bool {
+        matches!(self, BoardItem::Sticky { .. } | BoardItem::Shape { .. } | BoardItem::Label { .. })
+    }
+
+    /// Who made it (stickies and stamps; empty when unknown).
+    pub fn author(&self) -> &str {
+        match self {
+            BoardItem::Sticky { author } | BoardItem::Stamp { author, .. } => author,
+            _ => "",
+        }
+    }
+
+    /// Point the layers this object refers to (a connector's ends, a label's connector) at their
+    /// copies in `map`; the others stay.
+    pub fn remap(&mut self, map: &std::collections::BTreeMap<NodeId, NodeId>) {
+        match self {
+            BoardItem::Connector(c) => {
+                for end in [&mut c.from, &mut c.to] {
+                    if let End::Node { node, .. } = end
+                        && let Some(m) = map.get(node)
+                    {
+                        *node = *m;
+                    }
+                }
+            }
+            BoardItem::Label { connector } => {
+                if let Some(m) = map.get(connector) {
+                    *connector = *m;
+                }
+            }
+            _ => {}
+        }
+    }
+
+    pub fn kind_id(&self) -> &'static str {
+        match self {
+            BoardItem::Sticky { .. } => "sticky",
+            BoardItem::Shape { .. } => "shape",
+            BoardItem::Connector(_) => "connector",
+            BoardItem::Label { .. } => "label",
+            BoardItem::Stamp { .. } => "stamp",
+            BoardItem::Ink => "ink",
+        }
+    }
+}
+
+/// The colours stickies, shapes and connectors come in: soft tints that dark text reads on.
+pub const BOARD_COLORS: [(&str, Color); 8] = [
+    ("yellow", Color::from_rgb8_const(0xFF, 0xE7, 0x8A)),
+    ("orange", Color::from_rgb8_const(0xFF, 0xC9, 0x94)),
+    ("red", Color::from_rgb8_const(0xFF, 0xAE, 0xA6)),
+    ("pink", Color::from_rgb8_const(0xF7, 0xB9, 0xDA)),
+    ("violet", Color::from_rgb8_const(0xD4, 0xC2, 0xFC)),
+    ("blue", Color::from_rgb8_const(0xAC, 0xD3, 0xFA)),
+    ("green", Color::from_rgb8_const(0xC2, 0xE8, 0xA6)),
+    ("gray", Color::from_rgb8_const(0xE3, 0xE1, 0xDD)),
+];
+
+/// A board colour by name ("yellow") or as hex ("#FFE78A").
+pub fn board_color(s: &str) -> Option<Color> {
+    let s = s.trim();
+    BOARD_COLORS.iter().find(|(n, _)| n.eq_ignore_ascii_case(s)).map(|(_, c)| *c).or_else(|| Color::from_hex(s))
+}
+
+/// The page colour boards start with: a warm light grey the colours stand out on.
+pub const BOARD_PAGE: Color = Color::from_rgb8_const(0xF4, 0xF3, 0xF0);
+
+/// The outlines shapes with text come in.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum BoardShape {
+    #[default]
+    Rectangle,
+    RoundedRectangle,
+    Ellipse,
+    Diamond,
+    Triangle,
+    SpeechBubble,
+    Chevron,
+}
+
+impl BoardShape {
+    pub const ALL: [BoardShape; 7] = [
+        BoardShape::Rectangle,
+        BoardShape::RoundedRectangle,
+        BoardShape::Ellipse,
+        BoardShape::Diamond,
+        BoardShape::Triangle,
+        BoardShape::SpeechBubble,
+        BoardShape::Chevron,
+    ];
+
+    pub fn id(self) -> &'static str {
+        match self {
+            BoardShape::Rectangle => "rectangle",
+            BoardShape::RoundedRectangle => "roundedRectangle",
+            BoardShape::Ellipse => "ellipse",
+            BoardShape::Diamond => "diamond",
+            BoardShape::Triangle => "triangle",
+            BoardShape::SpeechBubble => "speechBubble",
+            BoardShape::Chevron => "chevron",
+        }
+    }
+
+    pub fn from_id(s: &str) -> Option<BoardShape> {
+        BoardShape::ALL.into_iter().find(|b| b.id().eq_ignore_ascii_case(s))
+    }
+
+    pub fn label(self) -> &'static str {
+        match self {
+            BoardShape::Rectangle => "Rectangle",
+            BoardShape::RoundedRectangle => "Rounded rectangle",
+            BoardShape::Ellipse => "Ellipse",
+            BoardShape::Diamond => "Diamond",
+            BoardShape::Triangle => "Triangle",
+            BoardShape::SpeechBubble => "Speech bubble",
+            BoardShape::Chevron => "Chevron",
+        }
+    }
+
+    /// The outline in a `w` × `h` box at the origin.
+    pub fn path(self, w: f64, h: f64) -> BezPath {
+        let poly = |pts: &[(f64, f64)]| {
+            let mut p = BezPath::new();
+            for (i, (x, y)) in pts.iter().enumerate() {
+                let q = Point::new(x * w, y * h);
+                if i == 0 { p.move_to(q) } else { p.line_to(q) }
+            }
+            p.close_path();
+            p
+        };
+        let r = w.min(h);
+        match self {
+            BoardShape::Rectangle => Rect::new(0.0, 0.0, w, h).to_path(0.1),
+            BoardShape::RoundedRectangle => RoundedRect::new(0.0, 0.0, w, h, r * 0.16).to_path(0.1),
+            BoardShape::Ellipse => Ellipse::from_rect(Rect::new(0.0, 0.0, w, h)).to_path(0.1),
+            BoardShape::Diamond => poly(&[(0.5, 0.0), (1.0, 0.5), (0.5, 1.0), (0.0, 0.5)]),
+            BoardShape::Triangle => poly(&[(0.5, 0.0), (1.0, 1.0), (0.0, 1.0)]),
+            BoardShape::Chevron => poly(&[(0.0, 0.0), (0.72, 0.0), (1.0, 0.5), (0.72, 1.0), (0.0, 1.0), (0.28, 0.5)]),
+            BoardShape::SpeechBubble => {
+                // A rounded body over the bottom fifth, with a tail down to the left.
+                let (b, c) = (h * 0.8, r * 0.14);
+                let mut p = BezPath::new();
+                p.move_to((c, 0.0));
+                p.line_to((w - c, 0.0));
+                p.quad_to((w, 0.0), (w, c));
+                p.line_to((w, b - c));
+                p.quad_to((w, b), (w - c, b));
+                p.line_to((w * 0.42, b));
+                p.line_to((w * 0.18, h));
+                p.line_to((w * 0.24, b));
+                p.line_to((c, b));
+                p.quad_to((0.0, b), (0.0, b - c));
+                p.line_to((0.0, c));
+                p.quad_to((0.0, 0.0), (c, 0.0));
+                p.close_path();
+                p
+            }
+        }
+    }
+
+    /// Where the text goes, as insets of the box (top, right, bottom, left, in fractions of its
+    /// size): inside the outline's widest part.
+    pub fn text_insets(self) -> [f64; 4] {
+        match self {
+            BoardShape::Rectangle | BoardShape::RoundedRectangle => [0.08, 0.08, 0.08, 0.08],
+            BoardShape::Ellipse => [0.16, 0.16, 0.16, 0.16],
+            BoardShape::Diamond => [0.25, 0.25, 0.25, 0.25],
+            BoardShape::Triangle => [0.45, 0.22, 0.06, 0.22],
+            BoardShape::SpeechBubble => [0.08, 0.08, 0.28, 0.08],
+            BoardShape::Chevron => [0.12, 0.3, 0.12, 0.3],
+        }
+    }
+}
+
+/// The stamps: round badges with a mark.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum Stamp {
+    #[default]
+    ThumbsUp,
+    Heart,
+    PlusOne,
+    Star,
+    Question,
+    Check,
+}
+
+/// One part of a stamp's mark: SVG path data on the badge's 40-unit box, filled or stroked.
+pub struct MarkPart {
+    pub d: &'static str,
+    pub filled: bool,
+}
+
+/// A stamp badge's size.
+pub const STAMP_SIZE: f64 = 40.0;
+
+impl Stamp {
+    pub const ALL: [Stamp; 6] = [Stamp::ThumbsUp, Stamp::Heart, Stamp::PlusOne, Stamp::Star, Stamp::Question, Stamp::Check];
+
+    pub fn id(self) -> &'static str {
+        match self {
+            Stamp::ThumbsUp => "thumbsUp",
+            Stamp::Heart => "heart",
+            Stamp::PlusOne => "plusOne",
+            Stamp::Star => "star",
+            Stamp::Question => "question",
+            Stamp::Check => "check",
+        }
+    }
+
+    pub fn from_id(s: &str) -> Option<Stamp> {
+        Stamp::ALL.into_iter().find(|b| b.id().eq_ignore_ascii_case(s))
+    }
+
+    pub fn label(self) -> &'static str {
+        match self {
+            Stamp::ThumbsUp => "Thumbs up",
+            Stamp::Heart => "Heart",
+            Stamp::PlusOne => "Plus one",
+            Stamp::Star => "Star",
+            Stamp::Question => "Question",
+            Stamp::Check => "Check",
+        }
+    }
+
+    /// The badge's colour (the mark is white on it).
+    pub fn color(self) -> Color {
+        match self {
+            Stamp::ThumbsUp => Color::from_rgb8_const(0x3B, 0x82, 0xE8),
+            Stamp::Heart => Color::from_rgb8_const(0xE5, 0x48, 0x5F),
+            Stamp::PlusOne => Color::from_rgb8_const(0x2E, 0xA0, 0x63),
+            Stamp::Star => Color::from_rgb8_const(0xEE, 0x9B, 0x1A),
+            Stamp::Question => Color::from_rgb8_const(0x84, 0x5E, 0xD8),
+            Stamp::Check => Color::from_rgb8_const(0x14, 0x96, 0x8C),
+        }
+    }
+
+    /// The mark, drawn for FigCraft from lines, arcs and simple outlines.
+    pub fn mark(self) -> &'static [MarkPart] {
+        match self {
+            // A cuff and a raised hand with its thumb up.
+            Stamp::ThumbsUp => &[
+                MarkPart { d: "M10.5 19 H15 V29 H10.5 Z", filled: true },
+                MarkPart {
+                    d: "M16.5 19 L20.6 11.4 C21.6 9.8 24.6 10.6 24.2 13 L23.4 17 H28.2 C29.8 17 30.9 18.5 30.4 20 L28.4 27.3 C28 28.4 27.1 29 25.9 29 H16.5 Z",
+                    filled: true,
+                },
+            ],
+            // Two round lobes meeting in a point.
+            Stamp::Heart => &[MarkPart {
+                d: "M20 29.5 C12.5 24.5 9.5 20.6 10.4 16.4 C11.3 12.2 16.8 11.2 20 15.4 C23.2 11.2 28.7 12.2 29.6 16.4 C30.5 20.6 27.5 24.5 20 29.5 Z",
+                filled: true,
+            }],
+            Stamp::PlusOne => &[MarkPart { d: "M10 20 H20 M15 15 V25", filled: false }, MarkPart { d: "M24.5 15 L27.5 12.5 V27.5", filled: false }],
+            Stamp::Star => &[MarkPart {
+                d: "M20 10.5 L22.8 16.7 L29.5 17.4 L24.5 21.9 L25.9 28.6 L20 25.2 L14.1 28.6 L15.5 21.9 L10.5 17.4 L17.2 16.7 Z",
+                filled: true,
+            }],
+            Stamp::Question => &[
+                MarkPart { d: "M15.6 16.2 C15.6 10.6 24.4 10.6 24.4 16 C24.4 19.6 20 19.9 20 23.6", filled: false },
+                MarkPart { d: "M18.2 28 A1.8 1.8 0 1 0 21.8 28 A1.8 1.8 0 1 0 18.2 28 Z", filled: true },
+            ],
+            Stamp::Check => &[MarkPart { d: "M12.5 20.5 L18 26 L28 14.5", filled: false }],
+        }
+    }
+}
+
+/// How a connector runs between its ends.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum Routing {
+    #[default]
+    Straight,
+    /// Right angles only: out of each end along its side's normal, turning once or twice.
+    Elbow,
+}
+
+impl Routing {
+    pub fn id(self) -> &'static str {
+        match self {
+            Routing::Straight => "straight",
+            Routing::Elbow => "elbow",
+        }
+    }
+    pub fn from_id(s: &str) -> Option<Routing> {
+        [Routing::Straight, Routing::Elbow].into_iter().find(|r| r.id().eq_ignore_ascii_case(s))
+    }
+}
+
+/// The side of an object a connector end is attached to (at its middle).
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum Side {
+    /// The side facing the other end.
+    #[default]
+    Auto,
+    Top,
+    Right,
+    Bottom,
+    Left,
+}
+
+impl Side {
+    pub fn from_id(s: &str) -> Option<Side> {
+        Some(match s.to_ascii_lowercase().as_str() {
+            "auto" => Side::Auto,
+            "top" => Side::Top,
+            "right" => Side::Right,
+            "bottom" => Side::Bottom,
+            "left" => Side::Left,
+            _ => return None,
+        })
+    }
+
+    /// The side's middle on `b`.
+    pub fn point(self, b: Rect) -> Point {
+        let c = b.center();
+        match self {
+            Side::Top => Point::new(c.x, b.y0),
+            Side::Right => Point::new(b.x1, c.y),
+            Side::Bottom => Point::new(c.x, b.y1),
+            Side::Left => Point::new(b.x0, c.y),
+            Side::Auto => c,
+        }
+    }
+
+    pub fn horizontal(self) -> bool {
+        matches!(self, Side::Left | Side::Right)
+    }
+}
+
+/// One end of a connector: attached to a layer, or a free point on the page.
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum End {
+    Node {
+        node: NodeId,
+        #[serde(default)]
+        side: Side,
+    },
+    Point {
+        x: f64,
+        y: f64,
+    },
+}
+
+impl End {
+    pub fn node(&self) -> Option<NodeId> {
+        match self {
+            End::Node { node, .. } => Some(*node),
+            End::Point { .. } => None,
+        }
+    }
+}
+
+/// What a connector joins and how it runs (its arrowheads are its stroke's caps).
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Connector {
+    pub from: End,
+    pub to: End,
+    #[serde(default)]
+    pub routing: Routing,
+}
diff --git a/crates/doc/src/geometry.rs b/crates/doc/src/geometry.rs
index 06596ddcd..b4f89dbc3 100644
--- a/crates/doc/src/geometry.rs
+++ b/crates/doc/src/geometry.rs
@@ -51,6 +51,10 @@ pub fn is_closed(n: &Node) -> bool {
     }
 }
 
+/// How much further than `tol` a stroke with nothing filled reaches: a thin line or stroke-only path
+/// is hard to land on with the plain tolerance, so it gets a wider band (5 screen px for the usual 2 px tolerance).
+const STROKE_REACH: f64 = 2.5;
+
 /// Whether `pt` hits `n` itself; in `outline` mode (nothing filled on the canvas) a shape only where
 /// its outline is.
 fn hits_node_itself(doc: &Document, id: NodeId, n: &Node, pt: Point, tol: f64, outline: bool) -> bool {
@@ -62,13 +66,22 @@ fn hits_node_itself(doc: &Document, id: NodeId, n: &Node, pt: Point, tol: f64, o
         NodeKind::Group | NodeKind::BooleanOp { .. } | NodeKind::Page { .. } => false,
         NodeKind::Text(_) | NodeKind::Slice => n.local_rect().inflate(tol_l, tol_l).contains(lp),
         NodeKind::Line => {
-            let half = (n.stroke.weight / 2.0).max(tol_l);
+            let half = (n.stroke.weight / 2.0).max(tol_l * STROKE_REACH);
             lp.x >= -half && lp.x <= n.width + half && lp.y.abs() <= half
         }
         NodeKind::Frame | NodeKind::Component { .. } | NodeKind::ComponentSet { .. } | NodeKind::Instance { .. } | NodeKind::Section { .. } => {
             n.local_rect().inflate(tol_l, tol_l).contains(lp)
         }
-        _ => shape_path(n).is_some_and(|path| hits_path(n, &path, lp, tol_l, !outline && is_closed(n) && path.winding(lp) != 0)),
+        _ => shape_path(n).is_some_and(|path| hits_path(n, &path, lp, tol_l, !outline && is_closed(n) && fills_point(n, &path, lp))),
+    }
+}
+
+/// Whether the fill of `n`, drawn as `path`, covers `lp` (vectors follow the rule of
+/// [`VectorNetwork::fill_contains`](crate::VectorNetwork::fill_contains): even-odd when any region asks for it).
+fn fills_point(n: &Node, path: &BezPath, lp: Point) -> bool {
+    match &n.kind {
+        NodeKind::Vector { network } => network.fill_contains(lp),
+        _ => path.winding(lp) != 0,
     }
 }
 
@@ -78,7 +91,9 @@ fn hits_path(n: &Node, path: &BezPath, lp: Point, tol: f64, inside: bool) -> boo
     if inside && (n.fills.iter().any(|f| f.visible) || !n.has_visible_stroke()) {
         return true;
     }
-    let reach = (n.stroke.max_weight() / 2.0).max(tol);
+    // Only a stroke with nothing filled gets the wider band: a filled shape's edge keeps the plain one.
+    let stroke_only = n.has_visible_stroke() && !n.fills.iter().any(|f| f.visible);
+    let reach = (n.stroke.max_weight() / 2.0).max(if stroke_only { tol * STROKE_REACH } else { tol });
     if !path.bounding_box().inflate(reach, reach).contains(lp) {
         return false;
     }
@@ -249,6 +264,18 @@ pub fn select_target(doc: &Document, leaf: NodeId, context: &[NodeId], deep: boo
     if deep {
         return leaf;
     }
+    let target = level_target(doc, leaf, context);
+    // A board object is picked whole (a sticky, not its text), unless a layer inside it is selected.
+    let mut chain = doc.ancestors(target);
+    chain.reverse();
+    chain.push(target);
+    chain
+        .into_iter()
+        .find(|c| doc.node(*c).is_some_and(Node::is_board_atom) && !context.iter().any(|s| s != c && doc.is_ancestor(*c, *s)))
+        .unwrap_or(target)
+}
+
+fn level_target(doc: &Document, leaf: NodeId, context: &[NodeId]) -> NodeId {
     // Chain from the page's child down to the leaf.
     let mut chain: Vec<NodeId> = doc.ancestors(leaf);
     chain.reverse();
diff --git a/crates/doc/src/lib.rs b/crates/doc/src/lib.rs
index 71c6da393..1eb1fb0bc 100644
--- a/crates/doc/src/lib.rs
+++ b/crates/doc/src/lib.rs
@@ -8,6 +8,7 @@
 //! live in higher crates.
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
 
+pub mod board;
 pub mod colors;
 pub mod comments;
 pub mod geometry;
@@ -23,6 +24,7 @@ pub mod vector;
 pub mod vector_faces;
 pub mod vector_regions;
 
+pub use board::*;
 pub use colors::*;
 pub use comments::*;
 pub use figcraft_color as color;
@@ -77,17 +79,19 @@ pub enum DocError {
 
 pub type DocResult<T> = Result<T, DocError>;
 
-/// The set of touched node ids, and whether any layer is a mask (worked out when first asked
-/// after a change: hit testing skips its mask checks without one). Never part of equality or
+/// The set of touched node ids, whether any layer is a mask (hit testing skips its mask checks
+/// without one) and the largest background blur radius (renders keep that much overlap between
+/// their bands), both worked out when first asked after a change. Never part of equality or
 /// serialisation.
 #[derive(Clone, Debug, Default)]
-pub struct Dirty(pub std::collections::BTreeSet<NodeId>, std::sync::OnceLock<bool>);
+pub struct Dirty(pub std::collections::BTreeSet<NodeId>, std::sync::OnceLock<bool>, std::sync::OnceLock<f64>);
 
 impl Dirty {
     /// Record node `id` as touched (edited, added or removed).
     fn touch(&mut self, id: NodeId) {
         self.0.insert(id);
         self.1 = std::sync::OnceLock::new();
+        self.2 = std::sync::OnceLock::new();
     }
 }
 
@@ -155,6 +159,9 @@ pub struct ImageData {
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct Document {
     pub name: String,
+    /// A design file or a board (files from before boards are design files).
+    #[serde(default, skip_serializing_if = "FileKind::is_design")]
+    pub kind: FileKind,
     /// Page ids in order.
     pub pages: Vec<NodeId>,
     nodes: imbl::OrdMap<NodeId, Arc<Node>>,
@@ -219,6 +226,7 @@ impl Document {
     pub fn without_pages(name: impl Into<String>) -> Self {
         Self {
             name: name.into(),
+            kind: FileKind::Design,
             pages: Vec::new(),
             nodes: imbl::OrdMap::new(),
             dirty: Dirty::default(),
@@ -254,6 +262,11 @@ impl Document {
         *self.dirty.1.get_or_init(|| self.nodes.values().any(|n| n.is_mask))
     }
 
+    /// The largest background blur or glass radius of any layer's effects (0 without any).
+    pub fn max_backdrop_radius(&self) -> f64 {
+        *self.dirty.2.get_or_init(|| self.nodes.values().flat_map(|n| n.effects.iter()).map(Effect::backdrop_radius).fold(0.0, f64::max))
+    }
+
     /// Node ids touched so far (without clearing).
     pub fn dirty(&self) -> &std::collections::BTreeSet<NodeId> {
         &self.dirty.0
@@ -262,7 +275,16 @@ impl Document {
     /// A fresh unused id (in this document's client space during a collaboration session; see
     /// [`set_client_id`](Self::set_client_id)).
     pub fn alloc_id(&mut self) -> NodeId {
-        self.next_id.alloc()
+        // A file's saved `next_id` can be stale (behind ids already in use): skip taken ids.
+        let mut id = self.next_id.alloc();
+        while self.nodes.contains_key(&id) {
+            let next = self.next_id.alloc();
+            if next == id {
+                break;
+            }
+            id = next;
+        }
+        id
     }
 
     /// The id [`alloc_id`](Self::alloc_id) returns next.
@@ -446,8 +468,9 @@ impl Document {
                 return true;
             }
             guard += 1;
-            if guard > 10_000 {
-                return false;
+            // More hops than nodes means the parent chain loops; fail closed so callers reject the move.
+            if guard > self.nodes.len() {
+                return true;
             }
             cur = self.node(c).and_then(|n| n.parent);
         }
@@ -814,6 +837,10 @@ impl Document {
             return Err(DocError::NotContainer(parent));
         }
         let new_root = *map.get(&root).ok_or(DocError::NoNode(root))?;
+        // Never overwrite an existing node with a copy.
+        if let Some(taken) = nodes.iter().filter_map(|n| map.get(&n.id)).find(|i| self.nodes.contains_key(*i)) {
+            return Err(DocError::Invalid(format!("node {taken} already exists")));
+        }
         for n in nodes {
             let Some(new_id) = map.get(&n.id) else { continue };
             let mut c = n.clone();
@@ -828,6 +855,10 @@ impl Document {
             {
                 *component = *m;
             }
+            // A connector (or label) copied with what it joins joins the copies.
+            if let Some(b) = c.board.as_mut() {
+                b.remap(map);
+            }
             // A pattern tiling a layer of the copy tiles the copy's layer.
             for p in c.fills.iter_mut().chain(c.strokes.iter_mut()) {
                 if let figcraft_color::PaintKind::Pattern(pt) = &mut p.kind
@@ -942,56 +973,81 @@ impl Document {
         self.styles.iter().find(|s| s.id == id || s.name == id)
     }
 
-    /// The effective variable modes for a node (walking up its ancestors).
+    /// The effective variable modes for a node: the ones it sets over [`Self::inherited_modes`].
     pub fn modes_for(&self, id: NodeId) -> BTreeMap<CollectionId, ModeId> {
-        let mut out = BTreeMap::new();
-        let mut chain = vec![id];
-        chain.extend(self.ancestors(id));
-        for c in chain.into_iter().rev() {
-            if let Some(n) = self.node(c) {
-                for (k, v) in &n.var_modes {
-                    out.insert(k.clone(), v.clone());
-                }
-            }
+        let mut out = self.inherited_modes(id);
+        if let Some(n) = self.node(id) {
+            out.extend(n.var_modes.iter().map(|(k, v)| (k.clone(), v.clone())));
         }
         out
     }
 
+    /// The modes a node is on where it sets none (Auto): its ancestors', and for an instance the
+    /// ones its main component sets, which are closer than any container's.
+    pub fn inherited_modes(&self, id: NodeId) -> BTreeMap<CollectionId, ModeId> {
+        let mut out = BTreeMap::new();
+        for c in self.ancestors(id).into_iter().rev() {
+            if let Some(n) = self.node(c) {
+                out.extend(self.main_modes(n).chain(&n.var_modes).map(|(k, v)| (k.clone(), v.clone())));
+            }
+        }
+        if let Some(n) = self.node(id) {
+            out.extend(self.main_modes(n).map(|(k, v)| (k.clone(), v.clone())));
+        }
+        out
+    }
+
+    /// The modes an instance's main component sets (none for other layers).
+    fn main_modes<'a>(&'a self, n: &Node) -> impl Iterator<Item = (&'a CollectionId, &'a ModeId)> {
+        let main = match n.kind {
+            NodeKind::Instance { component, .. } => self.node(component),
+            _ => None,
+        };
+        main.into_iter().flat_map(|m| &m.var_modes)
+    }
+
     /// Check structural invariants (used by tests and after loading untrusted files).
     pub fn validate(&self) -> Vec<String> {
+        // Hostile files can break an invariant per child; keep only the first few reports.
+        const MAX_ISSUES: usize = 100;
+        fn note(issues: &mut Vec<String>, msg: impl FnOnce() -> String) {
+            if issues.len() < MAX_ISSUES {
+                issues.push(msg());
+            }
+        }
         let mut issues = Vec::new();
         for (id, n) in self.nodes.iter() {
             if n.id != *id {
-                issues.push(format!("node key {id} has id {}", n.id));
+                note(&mut issues, || format!("node key {id} has id {}", n.id));
             }
             let mut seen = std::collections::BTreeSet::new();
             for c in &n.children {
                 if !seen.insert(*c) {
-                    issues.push(format!("child {c} listed twice in {id}"));
+                    note(&mut issues, || format!("child {c} listed twice in {id}"));
                 }
                 match self.node(*c) {
                     Some(cn) if cn.parent == Some(*id) => {}
-                    Some(_) => issues.push(format!("child {c} of {id} has another parent")),
-                    None => issues.push(format!("child {c} of {id} missing")),
+                    Some(_) => note(&mut issues, || format!("child {c} of {id} has another parent")),
+                    None => note(&mut issues, || format!("child {c} of {id} missing")),
                 }
             }
             if let Some(p) = n.parent
                 && !self.node(p).is_some_and(|pn| pn.children.contains(id))
             {
-                issues.push(format!("{id} not listed in parent {p}"));
+                note(&mut issues, || format!("{id} not listed in parent {p}"));
             }
             // The library store's root is a page that is never listed.
             let listed = self.pages.contains(id) || (n.is_page() && self.libraries.store == Some(*id));
             if n.is_page() != listed {
-                issues.push(format!("page list mismatch for {id}"));
+                note(&mut issues, || format!("page list mismatch for {id}"));
             }
             if n.is_page() && n.parent.is_some() {
-                issues.push(format!("page {id} has a parent"));
+                note(&mut issues, || format!("page {id} has a parent"));
             }
         }
         let reachable = self.reachable();
         for id in self.nodes.keys().filter(|k| !reachable.contains(*k)) {
-            issues.push(format!("{id} is not under a page (cycle or detached)"));
+            note(&mut issues, || format!("{id} is not under a page (cycle or detached)"));
         }
         issues
     }
@@ -1117,8 +1173,14 @@ impl Document {
     /// mask with the layers above it up to the next mask, or a single layer. An auto layout frame
     /// whose first child paints on top paints the runs in reverse (see [`Node::paint_order`]).
     pub fn paint_runs(&self, n: &Node) -> Vec<std::ops::Range<usize>> {
-        let kids = &n.children;
-        let node = |i: usize| kids.get(i).and_then(|k| self.node(*k));
+        let kids: Vec<Option<&Node>> = n.children.iter().map(|k| self.node(*k)).collect();
+        Self::paint_runs_of(&kids, n.layout.as_ref().is_some_and(|l| l.reverse_z))
+    }
+
+    /// [`Self::paint_runs`] of children already looked up (`None`: not in the document), last run
+    /// first when `reverse_z`.
+    pub fn paint_runs_of(kids: &[Option<&Node>], reverse_z: bool) -> Vec<std::ops::Range<usize>> {
+        let node = |i: usize| kids.get(i).copied().flatten();
         let mut runs = Vec::new();
         let mut i = 0;
         while i < kids.len() {
@@ -1131,7 +1193,7 @@ impl Document {
             runs.push(i..j);
             i = j;
         }
-        if n.layout.as_ref().is_some_and(|l| l.reverse_z) {
+        if reverse_z {
             runs.reverse();
         }
         runs
diff --git a/crates/doc/src/node.rs b/crates/doc/src/node.rs
index 00f7d5599..649d5e56e 100644
--- a/crates/doc/src/node.rs
+++ b/crates/doc/src/node.rs
@@ -518,6 +518,9 @@ pub struct Node {
     /// Dev resources: links for developers (docs, code, tickets…), in the order they were added.
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub dev_resources: Vec<DevResource>,
+    /// On a board: what this object is (a sticky note, a connector, a stamp…).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub board: Option<crate::BoardItem>,
 }
 
 pub(crate) fn yes() -> bool {
@@ -628,6 +631,7 @@ impl Node {
             annotations: Vec::new(),
             code_links: Vec::new(),
             dev_resources: Vec::new(),
+            board: None,
         }
     }
 
@@ -653,6 +657,11 @@ impl Node {
         matches!(self.kind, NodeKind::Page { .. })
     }
 
+    /// A board object selected and moved as a whole (a sticky, a shape with text, a stamp…).
+    pub fn is_board_atom(&self) -> bool {
+        self.board.as_ref().is_some_and(crate::BoardItem::is_atom)
+    }
+
     /// A section whose contents are hidden: only its name and outline show; its children are
     /// skipped when rendering and hit testing.
     pub fn hides_contents(&self) -> bool {
diff --git a/crates/doc/src/proto.rs b/crates/doc/src/proto.rs
index 91d2e8eb8..a844774c5 100644
--- a/crates/doc/src/proto.rs
+++ b/crates/doc/src/proto.rs
@@ -860,7 +860,35 @@ pub struct Device {
 
 impl PrototypeSettings {
     /// The devices to pick from ("None" presents the frame at its own size).
-    pub const DEVICES: [Device; 6] = [
+    pub const DEVICES: [Device; 19] = [
+        Device {
+            name: "iPhone 17",
+            width: 402.0,
+            height: 874.0,
+            rotates: true,
+            colors: &[c("Black", 0x38, 0x39, 0x3D), c("White", 0xE9, 0xE9, 0xE5)],
+        },
+        Device {
+            name: "iPhone 17 Pro",
+            width: 402.0,
+            height: 874.0,
+            rotates: true,
+            colors: &[c("Black", 0x38, 0x39, 0x3D), c("Silver", 0xD7, 0xD7, 0xD5)],
+        },
+        Device {
+            name: "iPhone 17 Pro Max",
+            width: 440.0,
+            height: 956.0,
+            rotates: true,
+            colors: &[c("Black", 0x38, 0x39, 0x3D), c("Silver", 0xD7, 0xD7, 0xD5)],
+        },
+        Device {
+            name: "iPhone Air",
+            width: 420.0,
+            height: 912.0,
+            rotates: true,
+            colors: &[c("Black", 0x38, 0x39, 0x3D), c("Silver", 0xD7, 0xD7, 0xD5)],
+        },
         Device {
             name: "iPhone 16",
             width: 393.0,
@@ -874,6 +902,13 @@ impl PrototypeSettings {
                 c("Blue", 0x72, 0x84, 0xD4),
             ],
         },
+        Device {
+            name: "iPhone 16 Pro",
+            width: 402.0,
+            height: 874.0,
+            rotates: true,
+            colors: &[c("Black", 0x3B, 0x3A, 0x38), c("White", 0xEC, 0xEB, 0xE6)],
+        },
         Device {
             name: "iPhone 16 Pro Max",
             width: 440.0,
@@ -881,6 +916,55 @@ impl PrototypeSettings {
             rotates: true,
             colors: &[c("Black", 0x3B, 0x3A, 0x38), c("White", 0xEC, 0xEB, 0xE6), c("Natural", 0xBF, 0xB9, 0xAF), c("Sand", 0xC6, 0xAC, 0x8F)],
         },
+        Device {
+            name: "iPhone 16 Plus",
+            width: 430.0,
+            height: 932.0,
+            rotates: true,
+            colors: &[c("Black", 0x3A, 0x3B, 0x3F), c("White", 0xEE, 0xED, 0xE8)],
+        },
+        Device {
+            name: "iPhone 15 Pro",
+            width: 393.0,
+            height: 852.0,
+            rotates: true,
+            colors: &[c("Black", 0x3B, 0x3A, 0x38), c("Silver", 0xD7, 0xD7, 0xD5)],
+        },
+        Device {
+            name: "iPhone 15 Pro Max",
+            width: 430.0,
+            height: 932.0,
+            rotates: true,
+            colors: &[c("Black", 0x3B, 0x3A, 0x38), c("Silver", 0xD7, 0xD7, 0xD5)],
+        },
+        Device {
+            name: "iPhone 15 Plus",
+            width: 430.0,
+            height: 932.0,
+            rotates: true,
+            colors: &[c("Black", 0x3A, 0x3B, 0x3F), c("White", 0xEE, 0xED, 0xE8)],
+        },
+        Device {
+            name: "iPhone 14 Pro",
+            width: 393.0,
+            height: 852.0,
+            rotates: true,
+            colors: &[c("Black", 0x3B, 0x3A, 0x38), c("Silver", 0xD7, 0xD7, 0xD5)],
+        },
+        Device {
+            name: "iPhone 14 Pro Max",
+            width: 430.0,
+            height: 932.0,
+            rotates: true,
+            colors: &[c("Black", 0x3B, 0x3A, 0x38), c("Silver", 0xD7, 0xD7, 0xD5)],
+        },
+        Device {
+            name: "iPhone 14",
+            width: 390.0,
+            height: 844.0,
+            rotates: true,
+            colors: &[c("Black", 0x3A, 0x3B, 0x3F), c("White", 0xEE, 0xED, 0xE8)],
+        },
         Device {
             name: "Android Compact",
             width: 412.0,
@@ -888,6 +972,13 @@ impl PrototypeSettings {
             rotates: true,
             colors: &[c("Black", 0x2E, 0x2F, 0x33), c("Silver", 0xD6, 0xD8, 0xDB), c("Green", 0xA6, 0xC0, 0xA3)],
         },
+        Device {
+            name: "Android Medium",
+            width: 700.0,
+            height: 840.0,
+            rotates: true,
+            colors: &[c("Black", 0x2E, 0x2F, 0x33), c("Silver", 0xD6, 0xD8, 0xDB)],
+        },
         Device {
             name: "iPad mini",
             width: 744.0,
diff --git a/crates/doc/src/proto_expr.rs b/crates/doc/src/proto_expr.rs
index f4404dc7e..d5441b283 100644
--- a/crates/doc/src/proto_expr.rs
+++ b/crates/doc/src/proto_expr.rs
@@ -169,7 +169,12 @@ impl Expr {
                     })
                     .collect();
                 match (op, parts.as_slice()) {
-                    (ExprOp::Not, [x]) => format!("not {x}"),
+                    // `not done` reads as a variable named "not done" if there is one: then
+                    // `not (done)`.
+                    (ExprOp::Not, [x]) => {
+                        let bare = format!("not {x}");
+                        if x.starts_with('(') || Expr::parse(&bare, vars).is_ok_and(|e| e == *self) { bare } else { format!("not ({x})") }
+                    }
                     (ExprOp::Negate, [x]) => format!("-{x}"),
                     _ => parts.join(&format!(" {} ", op.symbol())),
                 }
diff --git a/crates/doc/src/proto_expr_parse.rs b/crates/doc/src/proto_expr_parse.rs
index 5214a2d60..54615ee04 100644
--- a/crates/doc/src/proto_expr_parse.rs
+++ b/crates/doc/src/proto_expr_parse.rs
@@ -459,16 +459,19 @@ impl Parser<'_> {
                 if self.at_keyword("mode") && self.next_after(4) == Some('(') {
                     return self.mode_of();
                 }
-                if let Some((id, n)) = self.variable_here() {
-                    self.i += n;
-                    return self.in_mode(id);
-                }
+                let var = self.variable_here();
+                // A bare `true`/`false` is the literal, also when a variable has that name (it reads
+                // as `{true}`); longer names that start with it ("true value") stay variables.
                 for (word, v) in [("true", true), ("false", false)] {
-                    if self.at_keyword(word) {
+                    if self.at_keyword(word) && var.as_ref().is_none_or(|(_, n)| *n <= word.len()) {
                         self.i += word.len();
                         return Ok(Expr::Value(VariableValue::Boolean(v)));
                     }
                 }
+                if let Some((id, n)) = var {
+                    self.i += n;
+                    return self.in_mode(id);
+                }
                 let word: String = self.s.iter().skip(self.i).take_while(|c| ident(**c)).collect();
                 if word.is_empty() { Err(self.err(format!("Unexpected {c}"))) } else { Err(self.err(format!("No variable `{word}`"))) }
             }
diff --git a/crates/doc/src/proto_expr_parse_tests.rs b/crates/doc/src/proto_expr_parse_tests.rs
index e106121d8..1cac9f536 100644
--- a/crates/doc/src/proto_expr_parse_tests.rs
+++ b/crates/doc/src/proto_expr_parse_tests.rs
@@ -195,3 +195,49 @@ fn names_that_look_like_literals_read_back_as_variables() {
     assert_eq!(parse("1"), n(1.0));
     assert_eq!(parse("\"q\""), Expr::Value(VariableValue::String("q".into())));
 }
+
+#[test]
+fn not_of_a_variable_reads_back_when_a_name_starts_with_not() {
+    use ExprOp::*;
+    let mut v = vars();
+    let b = v.variables.iter().find(|x| x.id == "b").unwrap().clone();
+    for (id, name) in [("done", "done"), ("nd", "not done")] {
+        let mut x = b.clone();
+        x.id = id.into();
+        x.name = name.into();
+        v.variables.push(x);
+    }
+    let not_done = Expr::op(Not, vec![Expr::var("done")]);
+    for e in [
+        not_done.clone(),
+        Expr::op(And, vec![Expr::var("b"), not_done.clone()]),
+        Expr::op(Equals, vec![not_done.clone(), Expr::Value(VariableValue::Boolean(true))]),
+        Expr::op(Not, vec![not_done.clone()]),
+    ] {
+        let shown = e.display(&v);
+        assert_eq!(Expr::parse(&shown, &v), Ok(e.clone()), "shown as {shown:?}");
+    }
+    assert_eq!(Expr::op(Not, vec![Expr::var("b")]).display(&vars()), "not b-name", "plain names stay bare");
+}
+
+#[test]
+fn literal_true_false_survive_variables_named_true_false() {
+    use ExprOp::*;
+    let lit = |x: bool| Expr::Value(VariableValue::Boolean(x));
+    for name in ["true", "false", "TRUE"] {
+        let mut v = vars();
+        if let Some(var) = v.variables.iter_mut().find(|x| x.id == "b") {
+            var.name = name.into();
+        }
+        for e in [
+            Expr::op(Equals, vec![Expr::var("b"), lit(true)]),
+            Expr::op(Equals, vec![Expr::var("b"), lit(false)]),
+            Expr::op(Not, vec![lit(false)]),
+            Expr::var("b"),
+        ] {
+            let shown = e.display(&v);
+            assert_eq!(Expr::parse(&shown, &v), Ok(e.clone()), "{name:?} shown as {shown:?}");
+        }
+        assert_eq!(Expr::parse(&format!("{{{name}}}"), &v), Ok(Expr::var("b")));
+    }
+}
diff --git a/crates/doc/src/tests.rs b/crates/doc/src/tests.rs
index a5ead3b7d..38cab817c 100644
--- a/crates/doc/src/tests.rs
+++ b/crates/doc/src/tests.rs
@@ -326,6 +326,20 @@ fn repair_drops_cycles_and_repeated_children() {
     assert_eq!(bad.subtree(p), vec![p, r]);
 }
 
+#[test]
+fn validate_caps_the_issue_list() {
+    let mut d = Document::new("x");
+    let p = page(&d);
+    let f = d.create(p, NodeKind::Frame, "F", 0.0, 0.0, 100.0, 100.0).unwrap();
+    let g = d.create(f, NodeKind::Frame, "G", 0.0, 0.0, 10.0, 10.0).unwrap();
+    let mut v = serde_json::to_value(&d).unwrap();
+    v["nodes"][f.to_string()]["children"] = serde_json::json!(vec![g; 5000]);
+    let bad: Document = serde_json::from_value(v).unwrap();
+    let issues = bad.validate();
+    assert!(!issues.is_empty());
+    assert!(issues.len() <= 100, "{}", issues.len());
+}
+
 #[test]
 fn auto_layout_loads_files_without_grid_tracks() {
     // Saved before grid tracks, cells and spans existed.
@@ -464,3 +478,78 @@ fn text_style_empty_range_links_and_unlinks_all() {
     e.unlink_text_style(0, 0);
     assert!(e.style.style_id.is_none());
 }
+
+#[test]
+fn stale_next_id_never_overwrites_existing_nodes() {
+    let mut d = Document::new("x");
+    let p = page(&d);
+    let f = d.create(p, NodeKind::Frame, "F", 0.0, 0.0, 100.0, 100.0).unwrap();
+    let a = d.create(f, NodeKind::Rectangle, "A", 0.0, 0.0, 10.0, 10.0).unwrap();
+    let mut v = serde_json::to_value(&d).unwrap();
+    v["next_id"] = serde_json::json!(1);
+    let mut bad: Document = serde_json::from_value(v).unwrap();
+    let before: Vec<(NodeId, String, Option<NodeId>)> =
+        [p, f, a].iter().map(|i| (*i, bad.node(*i).unwrap().name.clone(), bad.node(*i).unwrap().parent)).collect();
+    let n = bad.node_count();
+    let copy = bad.duplicate_into(f, p, None).unwrap();
+    assert!(![p, f, a].contains(&copy));
+    assert_eq!(bad.node_count(), n + 2);
+    let copies = bad.duplicate_all_into(&[f], p).unwrap();
+    assert_eq!(bad.node_count(), n + 4);
+    assert!(copies.iter().all(|c| ![p, f, a, copy].contains(c)));
+    for (i, name, parent) in &before {
+        let node = bad.node(*i).unwrap();
+        assert_eq!((&node.name, node.parent), (name, *parent));
+    }
+    assert!(bad.validate().is_empty(), "{:?}", bad.validate());
+
+    // A paste whose id map points at an existing node fails and changes nothing.
+    let nodes: Vec<Node> = bad.subtree(f).into_iter().filter_map(|i| bad.node(i).cloned()).collect();
+    let mut map: BTreeMap<NodeId, NodeId> = nodes.iter().map(|n| (n.id, bad.alloc_id())).collect();
+    map.insert(a, p);
+    let snapshot = bad.clone();
+    assert!(bad.paste_nodes(&nodes, &map, f, p, None).is_err());
+    assert_eq!(bad, snapshot);
+    assert_eq!(bad.node(p).unwrap().name, snapshot.node(p).unwrap().name);
+    assert!(bad.validate().is_empty(), "{:?}", bad.validate());
+}
+
+#[test]
+fn hit_test_even_odd_vector_hole_misses() {
+    let ring = |rule| {
+        let sq = |o: f64, s: f64, base: usize| {
+            (
+                [(o, o), (o + s, o), (o + s, o + s), (o, o + s)].map(|(x, y)| Vertex::new(x, y)),
+                [Segment::line(base, base + 1), Segment::line(base + 1, base + 2), Segment::line(base + 2, base + 3), Segment::line(base + 3, base)],
+            )
+        };
+        let (v1, s1) = sq(0.0, 200.0, 0);
+        let (v2, s2) = sq(60.0, 80.0, 4);
+        VectorNetwork {
+            vertices: v1.into_iter().chain(v2).collect(),
+            segments: s1.into_iter().chain(s2).collect(),
+            regions: vec![Region { loops: vec![vec![0, 1, 2, 3], vec![4, 5, 6, 7]], winding: rule }],
+        }
+    };
+    let mut d = Document::new("x");
+    let p = page(&d);
+    let eo = d.create(p, NodeKind::Vector { network: ring(WindingRule::EvenOdd) }, "V", 0.0, 0.0, 200.0, 200.0).unwrap();
+    assert_eq!(d.hit_test(p, Point::new(20.0, 100.0), 0.0, None), Some(eo));
+    assert_eq!(d.hit_test(p, Point::new(100.0, 100.0), 0.0, None), None, "the hole is not filled");
+    let mut d = Document::new("x");
+    let p = page(&d);
+    let nz = d.create(p, NodeKind::Vector { network: ring(WindingRule::NonZero) }, "V", 0.0, 0.0, 200.0, 200.0).unwrap();
+    assert_eq!(d.hit_test(p, Point::new(100.0, 100.0), 0.0, None), Some(nz));
+}
+
+#[test]
+fn is_ancestor_holds_for_very_deep_chains() {
+    let mut d = Document::new("x");
+    let root = d.create(page(&d), NodeKind::Frame, "root", 0.0, 0.0, 1.0, 1.0).unwrap();
+    let mut leaf = root;
+    for _ in 0..10_005 {
+        leaf = d.create(leaf, NodeKind::Frame, "n", 0.0, 0.0, 1.0, 1.0).unwrap();
+    }
+    assert!(d.is_ancestor(root, leaf));
+    assert!(matches!(d.reparent(root, leaf, None), Err(DocError::Cycle(..))));
+}
diff --git a/crates/doc/src/text.rs b/crates/doc/src/text.rs
index b294151bb..458426ad7 100644
--- a/crates/doc/src/text.rs
+++ b/crates/doc/src/text.rs
@@ -60,6 +60,9 @@ impl LetterSpacing {
 }
 
 pub fn trim_num(v: f64) -> String {
+    if v.abs() >= 9.0e18 {
+        return format!("{v}");
+    }
     let r = (v * 100.0).round() / 100.0;
     if r.fract().abs() < 1e-9 { format!("{}", r as i64) } else { format!("{r}") }
 }
@@ -215,6 +218,10 @@ pub struct ParaList {
     pub list: ListStyle,
     /// Nesting level (0 = outermost; plain paragraphs are always 0).
     pub indent: u8,
+    /// A numbered list that starts counting at this paragraph counts from `start_offset + 1`
+    /// (items that go on counting ignore it; other paragraphs are always 0).
+    #[serde(skip_serializing_if = "crate::node::is_default")]
+    pub start_offset: u32,
 }
 
 /// Character style. In runs, every field is an override; `None` means "inherit the base".
@@ -637,13 +644,13 @@ impl TextData {
 
     /// Paragraph `p`'s list settings.
     pub fn para_list(&self, p: usize) -> ParaList {
-        self.paragraphs.get(p).copied().unwrap_or(ParaList { list: self.list, indent: 0 })
+        self.paragraphs.get(p).copied().unwrap_or(ParaList { list: self.list, ..ParaList::default() })
     }
 
     /// Spell out every paragraph's list settings in `paragraphs` (and drop extra entries).
     fn fill_paragraphs(&mut self) {
         let n = self.paragraph_count();
-        let fill = ParaList { list: self.list, indent: 0 };
+        let fill = ParaList { list: self.list, ..ParaList::default() };
         self.paragraphs.resize(n, fill);
     }
 
@@ -657,17 +664,23 @@ impl TextData {
     }
 
     /// Apply `f` to the list settings of the paragraphs chars `start..end` touch (plain
-    /// paragraphs stay at level 0, levels stop at [`MAX_LIST_INDENT`]); one style for all with
-    /// no nesting folds back into `list`.
+    /// paragraphs stay at level 0, only numbered ones keep a start, levels stop at
+    /// [`MAX_LIST_INDENT`]); one style for all with no nesting or start folds back into `list`.
     pub fn set_para_lists(&mut self, start: usize, end: usize, f: impl Fn(&mut ParaList)) {
         let (a, b) = self.para_span(start, end);
         self.fill_paragraphs();
         for pl in self.paragraphs.get_mut(a..=b).unwrap_or(&mut []) {
             f(pl);
-            pl.indent = if pl.list == ListStyle::None { 0 } else { pl.indent.min(MAX_LIST_INDENT) };
+            if pl.list == ListStyle::None {
+                pl.indent = 0;
+            }
+            if pl.list != ListStyle::Numbered {
+                pl.start_offset = 0;
+            }
+            pl.indent = pl.indent.min(MAX_LIST_INDENT);
         }
         if let Some(first) = self.paragraphs.first().copied()
-            && first.indent == 0
+            && first == (ParaList { list: first.list, ..ParaList::default() })
             && self.paragraphs.iter().all(|p| *p == first)
         {
             self.list = first.list;
@@ -675,11 +688,12 @@ impl TextData {
         }
     }
 
-    /// The list settings shared by the paragraphs chars `start..end` touch, or None when they differ.
+    /// The list style and level shared by the paragraphs chars `start..end` touch (the first
+    /// one's settings), or None when they differ. Start numbers don't count.
     pub fn common_para_list(&self, start: usize, end: usize) -> Option<ParaList> {
         let (a, b) = self.para_span(start, end);
         let first = self.para_list(a);
-        (a..=b).all(|p| self.para_list(p) == first).then_some(first)
+        (a..=b).all(|p| self.para_list(p).list == first.list && self.para_list(p).indent == first.indent).then_some(first)
     }
 
     /// Link chars `start..end` (all of them when the range is empty or the whole text) to text
@@ -749,6 +763,15 @@ impl TextData {
 mod case_tests {
     use super::*;
 
+    #[test]
+    fn trim_num_prints_huge_whole_numbers() {
+        assert_eq!(trim_num(1e19), "10000000000000000000");
+        assert_eq!(trim_num(-1e19), "-10000000000000000000");
+        assert_eq!(trim_num(12.0), "12");
+        let v = 12345678901234567890.0_f64;
+        assert_eq!(trim_num(v).parse::<f64>().unwrap(), v);
+    }
+
     #[test]
     fn title_case_respects_context() {
         assert_eq!(TextCase::Title.apply("hello wORLD don't 3d x-ray"), "Hello WORLD Don't 3d X-Ray");
@@ -782,4 +805,29 @@ mod case_tests {
         assert_eq!(st.variations.keys().collect::<Vec<_>>(), ["wdth"]);
         assert!(valid_axis_tag("wght") && !valid_axis_tag("weight"));
     }
+
+    #[test]
+    fn list_starts_load_from_old_files_and_follow_edits() {
+        use ListStyle::{Bulleted as B, None as P, Numbered as N};
+        // Files written before start numbers load with none, and write the same bytes.
+        let old = r#"{"list":"numbered","indent":1}"#;
+        let pl: ParaList = serde_json::from_str(old).unwrap();
+        assert_eq!(pl, ParaList { list: N, indent: 1, start_offset: 0 });
+        assert_eq!(serde_json::to_string(&pl).unwrap(), old);
+        // One numbered paragraph with a start keeps it (it doesn't fold into `list`).
+        let mut t = TextData { characters: "Next".into(), ..Default::default() };
+        t.set_para_lists(0, 0, |p| *p = ParaList { list: N, indent: 0, start_offset: 1 });
+        assert_eq!(t.para_list(0), ParaList { list: N, indent: 0, start_offset: 1 });
+        // Enter copies it to the new item; different starts don't make the list mixed.
+        t.replace_range(4, 4, "\nMore");
+        assert_eq!(t.para_list(1).start_offset, 1);
+        t.set_para_lists(5, 5, |p| p.start_offset = 0);
+        assert!(t.common_para_list(0, t.char_count()).is_some_and(|p| p.list == N));
+        // Bullets have no number, so no start.
+        t.set_para_lists(0, 0, |p| *p = ParaList { list: B, indent: 1, start_offset: 4 });
+        assert_eq!(t.para_list(0), ParaList { list: B, indent: 1, start_offset: 0 });
+        // A plain paragraph has none.
+        t.set_para_lists(0, 0, |p| p.list = P);
+        assert_eq!(t.para_list(0), ParaList::default());
+    }
 }
diff --git a/crates/doc/src/vector.rs b/crates/doc/src/vector.rs
index fd0a0f7ed..1165bd600 100644
--- a/crates/doc/src/vector.rs
+++ b/crates/doc/src/vector.rs
@@ -468,9 +468,9 @@ impl VectorNetwork {
         start_dir(&self.outward(seg, at_a)?)
     }
 
-    /// Whether any point has a stroke cap or join of its own.
-    pub fn has_point_styles(&self) -> bool {
-        self.vertices.iter().any(|v| v.cap.is_some() || v.join.is_some())
+    /// Whether any point has a stroke cap of its own or a join other than the layer's `layer_join`.
+    pub fn has_point_styles(&self, layer_join: StrokeJoin) -> bool {
+        self.vertices.iter().any(|v| v.cap.is_some() || v.join.is_some_and(|j| j != layer_join))
     }
 
     /// The fill path: every region's loops.
diff --git a/crates/engine/Cargo.toml b/crates/engine/Cargo.toml
index f610c38b3..545d872cc 100644
--- a/crates/engine/Cargo.toml
+++ b/crates/engine/Cargo.toml
@@ -20,6 +20,7 @@ figcraft-render = { workspace = true }
 figcraft-format = { workspace = true }
 figcraft-svg = { workspace = true }
 figcraft-pdf = { workspace = true }
+craft-docpath = { workspace = true }
 figcraft-plugin = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
diff --git a/crates/engine/clippy.toml b/crates/engine/clippy.toml
new file mode 100644
index 000000000..3ceac8998
--- /dev/null
+++ b/crates/engine/clippy.toml
@@ -0,0 +1,39 @@
+# The workspace settings (../../clippy.toml; clippy reads only the nearest file), plus the engine's
+# own rule: shipped engine code reaches the file system only through `file_access`, which enforces
+# the automation roots (#715), so every command is confined without a check of its own.
+allow-unwrap-in-tests = true
+allow-expect-in-tests = true
+allow-panic-in-tests = true
+too-many-arguments-threshold = 10
+disallowed-methods = [
+    { path = "std::fs::read", reason = "use file_access::read (automation roots)" },
+    { path = "std::fs::read_to_string", reason = "use file_access::read (automation roots)" },
+    { path = "std::fs::write", reason = "use file_access::write (automation roots)" },
+    { path = "std::fs::metadata", reason = "use file_access::metadata (automation roots)" },
+    { path = "std::fs::symlink_metadata", reason = "use file_access (automation roots)" },
+    { path = "std::fs::read_dir", reason = "use file_access::read_dir (automation roots)" },
+    { path = "std::fs::canonicalize", reason = "use file_access (automation roots)" },
+    { path = "std::fs::copy", reason = "use file_access (automation roots)" },
+    { path = "std::fs::rename", reason = "use file_access (automation roots)" },
+    { path = "std::fs::create_dir", reason = "use file_access::create_dir_all (automation roots)" },
+    { path = "std::fs::create_dir_all", reason = "use file_access::create_dir_all (automation roots)" },
+    { path = "std::fs::remove_file", reason = "use file_access (automation roots)" },
+    { path = "std::fs::remove_dir", reason = "use file_access (automation roots)" },
+    { path = "std::fs::remove_dir_all", reason = "use file_access (automation roots)" },
+    { path = "std::fs::hard_link", reason = "use file_access (automation roots)" },
+    { path = "std::fs::File::open", reason = "use file_access::open (automation roots)" },
+    { path = "std::fs::File::create", reason = "use file_access::write (automation roots)" },
+    { path = "std::fs::File::create_new", reason = "use file_access::write (automation roots)" },
+    { path = "std::fs::OpenOptions::open", reason = "use file_access (automation roots)" },
+    { path = "std::path::Path::exists", reason = "use file_access::exists (automation roots)" },
+    { path = "std::path::Path::try_exists", reason = "use file_access::exists (automation roots)" },
+    { path = "std::path::Path::is_file", reason = "use file_access::metadata (automation roots)" },
+    { path = "std::path::Path::is_dir", reason = "use file_access::is_dir (automation roots)" },
+    { path = "std::path::Path::metadata", reason = "use file_access::metadata (automation roots)" },
+    { path = "std::path::Path::symlink_metadata", reason = "use file_access (automation roots)" },
+    { path = "std::path::Path::read_dir", reason = "use file_access::read_dir (automation roots)" },
+    { path = "std::path::Path::canonicalize", reason = "use file_access (automation roots)" },
+    { path = "figcraft_format::write_file_atomic", reason = "use file_access::write (automation roots)" },
+    { path = "figcraft_format::save_file", reason = "use file_access::write (automation roots)" },
+    { path = "figcraft_format::load_file", reason = "use file_access::read (automation roots)" },
+]
diff --git a/crates/engine/src/a11y_keys_tests.rs b/crates/engine/src/a11y_keys_tests.rs
index 6687886cd..e4892bcae 100644
--- a/crates/engine/src/a11y_keys_tests.rs
+++ b/crates/engine/src/a11y_keys_tests.rs
@@ -55,3 +55,51 @@ fn reduce_motion_is_a_preference_that_persists() {
     let old: crate::Prefs = serde_json::from_value(json!({"theme": "dark"})).unwrap();
     assert!(!old.reduce_motion);
 }
+
+#[test]
+fn interface_size_is_relative_to_the_system_and_persists() {
+    let mut s = Session::new();
+    assert_eq!(s.prefs.ui_scale, 1.0, "the system's own size by default");
+    assert_eq!(s.execute("pref.uiScale", &json!({})).unwrap()["scale"], 1.0);
+    assert_eq!(s.execute("pref.uiScale", &json!({"scale": 1.25})).unwrap()["scale"], 1.25);
+    assert_eq!(s.prefs.ui_scale, 1.25);
+    // Reading changes nothing; "auto" (older scripts) is the system's own size.
+    assert_eq!(s.execute("pref.uiScale", &json!({})).unwrap()["scale"], 1.25);
+    assert_eq!(s.execute("pref.uiScale", &json!({"scale": "Auto"})).unwrap()["scale"], 1.0);
+    // Nothing to undo: the document didn't change.
+    assert!(!s.ds().map(|d| d.is_dirty()).unwrap_or(false));
+    // Saved with the other preferences and read back.
+    s.prefs.ui_scale = 0.9;
+    let v = serde_json::to_value(&s.prefs).unwrap();
+    assert_eq!(v["ui_scale"], 0.9);
+    let back: crate::Prefs = serde_json::from_value(v).unwrap();
+    assert_eq!(back.ui_scale, 0.9);
+}
+
+#[test]
+fn interface_size_stops_at_the_ends_and_junk_never_changes_it() {
+    let mut s = Session::new();
+    assert_eq!(s.execute("pref.uiScale", &json!({"scale": 0.01})).unwrap()["scale"], crate::UI_SCALE_MIN);
+    assert_eq!(s.execute("pref.uiScale", &json!({"scale": -4})).unwrap()["scale"], crate::UI_SCALE_MIN);
+    assert_eq!(s.execute("pref.uiScale", &json!({"scale": 1e308})).unwrap()["scale"], crate::UI_SCALE_MAX);
+    // The size is a factor (1.25), not a percentage: 125 is far past the end and stops there.
+    assert_eq!(s.execute("pref.uiScale", &json!({"scale": 125})).unwrap()["scale"], crate::UI_SCALE_MAX);
+    s.prefs.ui_scale = 1.5;
+    for junk in [json!({"scale": "NaN"}), json!({"scale": "big"}), json!({"scale": [1]}), json!({"scale": {"x": 1}})] {
+        assert!(s.execute("pref.uiScale", &junk).is_err(), "{junk}");
+        assert_eq!(s.prefs.ui_scale, 1.5, "{junk}");
+    }
+}
+
+#[test]
+fn a_settings_file_without_or_with_a_wrong_interface_size_reads_as_the_systems_size_and_keeps_the_rest() {
+    let old: crate::Prefs = serde_json::from_value(json!({"theme": "dark"})).unwrap();
+    assert_eq!(old.ui_scale, 1.0);
+    for bad in [json!("big"), json!(null), json!([2]), json!(true)] {
+        let p: crate::Prefs = serde_json::from_value(json!({"theme": "dark", "ui_scale": bad})).unwrap();
+        assert_eq!((p.ui_scale, p.theme.as_str()), (1.0, "dark"), "{bad}");
+    }
+    // A number out of range is clamped rather than refused.
+    let p: crate::Prefs = serde_json::from_value(json!({"ui_scale": 99, "theme": "dark"})).unwrap();
+    assert_eq!((p.ui_scale, p.theme.as_str()), (crate::UI_SCALE_MAX, "dark"));
+}
diff --git a/crates/engine/src/al_behaviour_tests.rs b/crates/engine/src/al_behaviour_tests.rs
index 5d34d5860..4659a5973 100644
--- a/crates/engine/src/al_behaviour_tests.rs
+++ b/crates/engine/src/al_behaviour_tests.rs
@@ -180,6 +180,23 @@ fn vertical_wrap_columns_take_arrows_and_drops() {
     assert_eq!(line, Some([30.0, 48.0, 50.0, 48.0]));
 }
 
+#[test]
+fn adding_auto_layout_to_a_frame_keeps_its_size() {
+    // An existing frame with content hugs it (padding inferred, so the size is preserved);
+    // an empty one keeps its size instead of collapsing to its padding.
+    let mut s = Session::new();
+    let f = id(s.execute("frame.create", &json!({"x": 0, "y": 0, "width": 300, "height": 200})).unwrap());
+    rect(&mut s, f, 40.0, 20.0, "#FF0000");
+    s.execute("layout.add", &json!({"ids": [f]})).unwrap();
+    assert_eq!(sizing(&s, f), (Sizing::Hug, Sizing::Hug));
+    assert_eq!(size(&s, f), (300.0, 200.0));
+    // An empty frame keeps its size too.
+    let e = id(s.execute("frame.create", &json!({"x": 0, "y": 0, "width": 300, "height": 200})).unwrap());
+    s.execute("layout.add", &json!({"ids": [e]})).unwrap();
+    assert_eq!(sizing(&s, e), (Sizing::Fixed, Sizing::Fixed));
+    assert_eq!(size(&s, e), (300.0, 200.0));
+}
+
 #[test]
 fn canvas_stacking_paints_and_exports_the_first_child_on_top() {
     // Documented: the last child is on top by default; "first on top" flips which one is drawn
diff --git a/crates/engine/src/annotations_tests.rs b/crates/engine/src/annotations_tests.rs
index 7fc7376f0..000650494 100644
--- a/crates/engine/src/annotations_tests.rs
+++ b/crates/engine/src/annotations_tests.rs
@@ -171,7 +171,7 @@ fn ready_for_dev_lists_frames_by_status() {
     };
     let ready = ex(&mut s, "inspect.readyForDev", json!({}));
     assert_eq!(names(&ready), vec!["Login", "Onboarding", "Profile"], "every page, page and layer order");
-    assert_eq!(ready["items"][0], json!({"id": a.0, "name": "Login", "page": page.0, "status": "readyForDev"}));
+    assert_eq!(ready["items"][0], json!({"id": a.0, "name": "Login", "page": page.0, "status": "readyForDev", "changed": false}));
     assert_eq!(names(&ex(&mut s, "inspect.readyForDev", json!({"status": "completed"}))), vec!["Signup"]);
     assert_eq!(names(&ex(&mut s, "inspect.readyForDev", json!({"status": "any", "page": page}))), vec!["Login", "Signup", "Onboarding"]);
     assert!(s.execute("inspect.readyForDev", &json!({"status": "none"})).is_err());
diff --git a/crates/engine/src/binding_lists_tests.rs b/crates/engine/src/binding_lists_tests.rs
index 493c8f60d..8b221efdd 100644
--- a/crates/engine/src/binding_lists_tests.rs
+++ b/crates/engine/src/binding_lists_tests.rs
@@ -97,3 +97,77 @@ fn effect_moves_and_removals_reject_junk() {
     ex(&mut s, "effect.remove", json!({"ids": [r], "index": 7}));
     assert_eq!(s.doc().unwrap().node(r).unwrap().effects.len(), 1);
 }
+
+fn fill_hex(s: &Session, r: NodeId) -> Vec<String> {
+    s.doc().unwrap().node(r).unwrap().fills.iter().filter_map(|p| p.solid_color()).map(|c| c.to_hex()).collect()
+}
+
+fn brand_id(s: &Session) -> String {
+    s.doc().unwrap().variables.get("brand").unwrap().id.clone()
+}
+
+#[test]
+fn explicit_paint_edits_detach_the_colour_binding() {
+    // An edit that reported success keeps its colour: the binding it overwrote lets go (as
+    // selection colours already do), instead of putting the variable's colour back.
+    let edits = [
+        ("fill.set", json!({"color": "#00FF00"})),
+        ("node.set", json!({"props": {"fill": "#00FF00"}})),
+        ("node.set", json!({"props": {"fills": ["#00FF00"]}})),
+    ];
+    for (cmd, mut p) in edits {
+        let (mut s, r) = setup();
+        ex(&mut s, "variable.bind", json!({"ids": [r], "field": "fill", "variable": "brand"}));
+        p["ids"] = json!([r]);
+        ex(&mut s, cmd, p.clone());
+        assert_eq!(fill_hex(&s, r), ["00FF00"], "{cmd} {p}");
+        assert!(bound(&s, r).is_empty(), "{cmd} {p}");
+        ex(&mut s, "variable.set", json!({"variable": "brand", "value": "#123456"}));
+        assert_eq!(fill_hex(&s, r), ["00FF00"], "{cmd} {p}: no longer follows the variable");
+    }
+    for (cmd, mut p) in [("stroke.set", json!({"color": "#00FF00"})), ("node.set", json!({"props": {"stroke": "#00FF00"}}))] {
+        let (mut s, r) = setup();
+        ex(&mut s, "node.set", json!({"ids": [r], "props": {"strokes": ["#000000"]}}));
+        ex(&mut s, "variable.bind", json!({"ids": [r], "field": "stroke", "variable": "brand"}));
+        p["ids"] = json!([r]);
+        ex(&mut s, cmd, p);
+        let n = s.doc().unwrap().node(r).unwrap();
+        assert_eq!(n.strokes[0].solid_color().map(|c| c.to_hex()).as_deref(), Some("00FF00"), "{cmd}");
+        assert!(n.bound.is_empty(), "{cmd}");
+    }
+}
+
+#[test]
+fn clearing_bound_fills_adds_no_paint_back() {
+    let (mut s, r) = setup();
+    ex(&mut s, "variable.bind", json!({"ids": [r], "field": "fill", "variable": "brand"}));
+    ex(&mut s, "node.set", json!({"ids": [r], "props": {"fills": []}}));
+    assert!(s.doc().unwrap().node(r).unwrap().fills.is_empty());
+    assert!(bound(&s, r).is_empty());
+    ex(&mut s, "variable.set", json!({"variable": "brand", "value": "#123456"}));
+    assert!(s.doc().unwrap().node(r).unwrap().fills.is_empty(), "the variable doesn't bring the fill back");
+}
+
+#[test]
+fn paint_opacity_edits_keep_the_colour_binding() {
+    let (mut s, r) = setup();
+    ex(&mut s, "variable.bind", json!({"ids": [r], "field": "fill", "variable": "brand"}));
+    ex(&mut s, "fill.set", json!({"ids": [r], "opacity": 0.5}));
+    ex(&mut s, "variable.set", json!({"variable": "brand", "value": "#0000FF"}));
+    assert_eq!(fill_hex(&s, r), ["0000FF"], "the colour still follows the variable");
+    assert_eq!(s.doc().unwrap().node(r).unwrap().fills[0].opacity, 0.5);
+    // The same colour with another opacity, through node.set, keeps it too.
+    ex(&mut s, "node.set", json!({"ids": [r], "props": {"fills": [{"type": "solid", "color": "#0000FF", "opacity": 0.25}]}}));
+    assert_eq!(bound(&s, r).len(), 1);
+    assert_eq!(s.doc().unwrap().node(r).unwrap().fills[0].opacity, 0.25);
+}
+
+#[test]
+fn paints_set_with_their_binding_in_the_same_call_keep_it() {
+    let (mut s, r) = setup();
+    ex(&mut s, "variable.bind", json!({"ids": [r], "field": "fill", "variable": "brand"}));
+    let brand = brand_id(&s);
+    ex(&mut s, "node.set", json!({"ids": [r], "props": {"fills": ["#00FF00"], "boundVariables": {"fill": brand}}}));
+    assert_eq!(bound(&s, r), [("fill".to_string(), brand)]);
+    assert_eq!(fill_hex(&s, r), ["FF0000"], "the binding given with the paints applies");
+}
diff --git a/crates/engine/src/board.rs b/crates/engine/src/board.rs
new file mode 100644
index 000000000..317b0889d
--- /dev/null
+++ b/crates/engine/src/board.rs
@@ -0,0 +1,1307 @@
+//! Boards: files for thinking together, with sticky notes, shapes with text, connectors, ink and
+//! stamps. Board objects are ordinary layers with a [`BoardItem`] on them; [`settle_text`] and
+//! [`settle_routes`] keep what follows from it (a sticky's text size, a shape's text room,
+//! connectors' routes and their labels) up to date in the normalize pass, so local edits, undo and
+//! live-session edits from others all end in the same geometry.
+
+use std::collections::{BTreeMap, BTreeSet};
+
+use figcraft_color::{BlendMode, Color, Paint};
+use figcraft_doc::{
+    AutoLayout, BOARD_COLORS, BoardItem, BoardShape, Connector, Constraints, CrossAlign, DocError, Document, Effect, EffectKind, End, FileKind,
+    HConstraint, LayoutMode, MainAlign, Node, NodeId, NodeKind, Routing, STAMP_SIZE, Shadow, Side, Sizing, Stamp, StrokeAlign, StrokeCap, StrokeJoin,
+    TextAlignH, TextAutoResize, TextData, VConstraint, VectorNetwork, board_color,
+};
+use figcraft_geom::{Affine, Point, Rect};
+use serde_json::{Value, json};
+
+use crate::cmd::CommandSpec;
+use crate::params::{boolean, color_of, get, id, id_of, num, num_or, opt_id, req_num, req_string, req_targets, string};
+use crate::tools::{Gesture, PointerEvent, ToolId};
+use crate::{EngineError, Result, Session, bad, spec, textedit};
+
+/// Why a board command refuses on a design file.
+pub const NEEDS_BOARD: &str = "this is for boards: make one with File ▸ New board";
+/// Why prototyping and Dev Mode refuse on a board.
+pub const NOT_ON_BOARDS: &str = "boards have no prototypes or Dev Mode: use a design file for those";
+
+/// A sticky note's side (it grows taller for long notes).
+pub const STICKY: f64 = 200.0;
+const STICKY_PAD: f64 = 16.0;
+/// The room between a sticky and the next one made beside it.
+const STICKY_GAP: f64 = 24.0;
+/// A new shape's size.
+const SHAPE: f64 = 160.0;
+/// Text on board objects, and the author line under a sticky's note.
+const INK: Color = Color::from_rgb8_const(0x1E, 0x1E, 0x1E);
+const AUTHOR_INK: Color = Color::from_rgb8_const(0x5C, 0x5A, 0x55);
+/// Connectors' default colour and weight.
+const LINE: Color = Color::from_rgb8_const(0x3A, 0x39, 0x36);
+const LINE_WEIGHT: f64 = 2.0;
+/// Marker and highlighter strokes: (weight, opacity).
+const MARKER: (f64, f32) = (4.0, 1.0);
+const HIGHLIGHTER: (f64, f32) = (20.0, 0.45);
+/// How far the eraser reaches around the pointer (screen pixels).
+const ERASER_PX: f64 = 8.0;
+/// The text sizes the contextual bar offers.
+pub const TEXT_SIZES: [(&str, f64); 4] = [("S", 12.0), ("M", 16.0), ("L", 24.0), ("XL", 36.0)];
+
+/// The board tools' choices: the colour new stickies get, the shape and stamp the tools place,
+/// how new connectors run and the marker's and highlighter's colours.
+#[derive(Clone, Debug)]
+pub struct BoardTool {
+    pub sticky: Color,
+    pub shape: BoardShape,
+    pub stamp: Stamp,
+    pub routing: Routing,
+    pub marker: Color,
+    pub highlighter: Color,
+}
+
+impl Default for BoardTool {
+    fn default() -> Self {
+        let first = BOARD_COLORS.first().map_or(Color::WHITE, |c| c.1);
+        Self {
+            sticky: first,
+            shape: BoardShape::Rectangle,
+            stamp: Stamp::ThumbsUp,
+            routing: Routing::Elbow,
+            marker: INK,
+            highlighter: Color::from_rgb8_const(0xFF, 0xD2, 0x1F),
+        }
+    }
+}
+
+pub fn specs() -> Vec<CommandSpec> {
+    vec![
+        spec!(
+            "board.sticky",
+            "Sticky note",
+            "{x, y (its top-left, in the parent), text?, color? (yellow|orange|red|pink|violet|blue|green|gray or hex; default the sticky tool's), author? (a name, or false for none; default yours), parent?} → {id, text}",
+            true,
+            sticky_cmd
+        ),
+        spec!(
+            "board.nextSticky",
+            "Next sticky note",
+            "{id? (a sticky; default the selected or edited one), side?: right|below|left|above (default right), edit? (start typing in it; default false)} → {id, text}  a sticky of the same colour beside it",
+            true,
+            next_sticky
+        ),
+        spec!(
+            "board.shape",
+            "Shape with text",
+            "{shape: rectangle|roundedRectangle|ellipse|diamond|triangle|speechBubble|chevron, x, y, width?, height? (default 160), text?, color?, parent?} → {id, text}",
+            true,
+            shape_cmd
+        ),
+        spec!(
+            "board.connector",
+            "Connector",
+            "{from, to (each a layer id or {x, y} on the page), fromSide?, toSide? (auto|top|right|bottom|left), style?: straight|elbow, startCap?, endCap? (none|lineArrow|triangleArrow|circleFilled|diamondFilled…; default an arrow at the end), label?} → {id, label?}  a line that follows the layers it joins",
+            true,
+            connector_cmd
+        ),
+        spec!("board.label", "Connector label", "{id (a connector; default the selection), text (empty removes it)} → {id, label}", true, label_cmd),
+        spec!(
+            "board.stamp",
+            "Stamp",
+            "{x, y (its centre on the page), stamp: thumbsUp|heart|plusOne|star|question|check} → {id}  a badge with your name on hover",
+            true,
+            stamp_cmd
+        ),
+        spec!(
+            "board.ink",
+            "Marker stroke",
+            "{path (SVG path data on the page) | points [[x,y],..], highlighter? (wide and see-through), color?, select? (default true)} → {id}",
+            true,
+            ink_cmd
+        ),
+        spec!(
+            "board.setColor",
+            "Board color",
+            "{ids?, color (a board colour name or hex)}  stickies and shapes take it as their fill, connectors and ink as their line",
+            true,
+            set_color
+        ),
+        spec!(
+            "board.setStyle",
+            "Board style",
+            "{ids?, shape? (shapes with text), fontSize? (their text), style?: straight|elbow, startCap?, endCap? (connectors)}",
+            true,
+            set_style
+        ),
+        spec!("tool.sticky", "Sticky note", "{color?} (a click places a sticky and starts typing in it)", false, |s, p| {
+            if let Some(c) = color_param("tool.sticky", p)? {
+                s.tool.board.sticky = c;
+            }
+            board_tool(s, ToolId::Sticky)
+        }),
+        spec!("tool.shape", "Shapes", "{shape?} (a click places a shape with text)", false, |s, p| {
+            if let Some(v) = string(p, "shape") {
+                s.tool.board.shape = shape_of("tool.shape", &v)?;
+            }
+            board_tool(s, ToolId::BoardShape)
+        }),
+        spec!("tool.connector", "Connector", "{style?: straight|elbow} (drag from one object to another)", false, |s, p| {
+            if let Some(v) = string(p, "style") {
+                s.tool.board.routing = routing_of("tool.connector", &v)?;
+            }
+            board_tool(s, ToolId::Connector)
+        }),
+        spec!("tool.marker", "Marker", "{color?}", false, |s, p| {
+            if let Some(c) = color_param("tool.marker", p)? {
+                s.tool.board.marker = c;
+            }
+            board_tool(s, ToolId::Marker)
+        }),
+        spec!("tool.highlighter", "Highlighter", "{color?}", false, |s, p| {
+            if let Some(c) = color_param("tool.highlighter", p)? {
+                s.tool.board.highlighter = c;
+            }
+            board_tool(s, ToolId::Highlighter)
+        }),
+        spec!("tool.eraser", "Eraser", "{} (drag over marker and highlighter strokes to remove them)", false, |s, _| board_tool(s, ToolId::Eraser)),
+        spec!("tool.stamp", "Stamp", "{stamp?} (a click places the stamp)", false, |s, p| {
+            if let Some(v) = string(p, "stamp") {
+                s.tool.board.stamp = stamp_of("tool.stamp", &v)?;
+            }
+            board_tool(s, ToolId::Stamp)
+        }),
+    ]
+}
+
+pub fn is_board(doc: &Document) -> bool {
+    doc.kind == FileKind::Board
+}
+
+/// Refuse `cmd` unless the active file is a board.
+pub(crate) fn require(s: &Session, cmd: &str) -> Result<()> {
+    if s.doc().is_ok_and(is_board) { Ok(()) } else { Err(EngineError::Disabled(cmd.into(), NEEDS_BOARD.into())) }
+}
+
+/// Prototyping and Dev Mode: not on boards.
+fn design_only(cmd: &str) -> bool {
+    cmd.starts_with("proto.") || cmd.starts_with("dev.") || matches!(cmd, "view.prototype" | "view.designPrototype" | "view.devMode")
+}
+
+/// Refuse `cmd` on a board when it is prototyping or Dev Mode.
+pub(crate) fn refuse_on_board(s: &Session, cmd: &str) -> Result<()> {
+    if design_only(cmd) && s.doc().is_ok_and(is_board) { Err(EngineError::Disabled(cmd.into(), NOT_ON_BOARDS.into())) } else { Ok(()) }
+}
+
+fn board_tool(s: &mut Session, t: ToolId) -> Result<Value> {
+    require(s, &format!("tool.{}", t.id()))?;
+    crate::cmd::view::tool(s, t)
+}
+
+fn shape_of(cmd: &str, v: &str) -> Result<BoardShape> {
+    BoardShape::from_id(v)
+        .ok_or_else(|| bad(cmd, format!("unknown shape `{v}` (rectangle|roundedRectangle|ellipse|diamond|triangle|speechBubble|chevron)")))
+}
+
+fn stamp_of(cmd: &str, v: &str) -> Result<Stamp> {
+    Stamp::from_id(v).ok_or_else(|| bad(cmd, format!("unknown stamp `{v}` (thumbsUp|heart|plusOne|star|question|check)")))
+}
+
+fn routing_of(cmd: &str, v: &str) -> Result<Routing> {
+    Routing::from_id(v).ok_or_else(|| bad(cmd, format!("`style` is straight or elbow, not `{v}`")))
+}
+
+fn cap_of(cmd: &str, p: &Value, key: &str) -> Result<Option<StrokeCap>> {
+    match get(p, key) {
+        None | Some(Value::Null) => Ok(None),
+        Some(v) => crate::cmd::props::enum_of::<StrokeCap>(v).map(Some).ok_or_else(|| bad(cmd, format!("`{key}`: unknown cap"))),
+    }
+}
+
+/// `color`: a board colour's name, or any colour.
+fn color_param(cmd: &str, p: &Value) -> Result<Option<Color>> {
+    match get(p, "color") {
+        None | Some(Value::Null) => Ok(None),
+        Some(Value::String(s)) if board_color(s).is_some() => Ok(board_color(s)),
+        Some(v) => color_of(v).map(Some).ok_or_else(|| bad(cmd, "`color` is a board colour (yellow, blue…) or a colour such as #FFE78A")),
+    }
+}
+
+/// The deeper shade of a board colour lines are drawn in (light tints are too faint as lines).
+fn line_shade(c: Color) -> Color {
+    let palette = BOARD_COLORS.iter().any(|(_, b)| *b == c);
+    if palette { Color::new(c.r * 0.55, c.g * 0.55, c.b * 0.55, c.a) } else { c }
+}
+
+/// Your name on what you make: the name from Preferences, else the one a live session gave you
+/// (none for the default name outside a session).
+fn author(s: &Session) -> String {
+    let name = crate::live::display_name(&s.prefs);
+    if name.is_empty() { s.live().info.as_ref().map(|i| i.name.clone()).unwrap_or_default() } else { name }
+}
+
+/// The parent a command places into, and that parent's page-to-local transform.
+fn parent_of(cmd: &str, s: &Session, p: &Value) -> Result<NodeId> {
+    let page = s.page()?;
+    let parent = opt_id(cmd, p, "parent")?.unwrap_or(page);
+    let doc = s.doc()?;
+    let n = doc.get(parent)?;
+    let takes = n.is_page() || matches!(n.kind, NodeKind::Section { .. }) || (n.kind.is_frame_like() && !n.is_board_atom());
+    if !takes {
+        return Err(bad(cmd, "`parent` is the page, a section or a frame"));
+    }
+    Ok(parent)
+}
+
+/// A new layer at the top of `parent`, at `at` in it, made by `f`.
+fn add(
+    doc: &mut Document,
+    parent: NodeId,
+    kind: NodeKind,
+    name: &str,
+    at: (f64, f64),
+    size: (f64, f64),
+    f: impl FnOnce(&mut Node),
+) -> Result<NodeId> {
+    let id = doc.alloc_id();
+    let mut n = Node::new(id, kind, name, size.0, size.1);
+    n.transform = Affine::translate(at);
+    f(&mut n);
+    doc.insert(n, parent, None)?;
+    Ok(id)
+}
+
+/// A soft shadow under stickies and stamps.
+fn soft_shadow() -> Effect {
+    Effect {
+        kind: EffectKind::DropShadow(Shadow { color: Color::new(0.0, 0.0, 0.0, 0.16), offset: (0.0, 2.0), radius: 6.0, ..Shadow::default() }),
+        visible: true,
+    }
+}
+
+/// A text layer filling its frame's width (the frame's auto layout places it).
+fn add_text(doc: &mut Document, parent: NodeId, text: &str, size: f64, color: Color, align: TextAlignH, width: f64) -> Result<NodeId> {
+    let first: String = text.lines().next().unwrap_or("").chars().take(64).collect();
+    let name = if first.trim().is_empty() { "Text" } else { first.as_str() };
+    let mut td = TextData {
+        characters: crate::cmd::props::normalize_line_endings(text),
+        auto_resize: TextAutoResize::Height,
+        align_h: align,
+        ..TextData::default()
+    };
+    td.style.font_size = size;
+    let id = add(doc, parent, NodeKind::Text(td), name, (0.0, 0.0), (width.max(1.0), size * 1.4), |n| {
+        n.fills = vec![Paint::solid(color)];
+        n.child_layout.sizing_h = Sizing::Fill;
+    })?;
+    if let Some(n) = doc.node(id)
+        && let Some((w, h)) = figcraft_text::auto_size(n)
+        && let Some(n) = doc.node_mut(id)
+    {
+        (n.width, n.height) = (w, h);
+    }
+    Ok(id)
+}
+
+/// The text size a sticky's note gets: smaller the more it holds (by characters and lines, so
+/// every copy of the file picks the same size whatever fonts it has).
+pub fn sticky_font_size(text: &str) -> f64 {
+    let weight = text.chars().count() + 24 * text.matches('\n').count();
+    match weight {
+        0..=24 => 24.0,
+        25..=64 => 20.0,
+        65..=140 => 16.0,
+        141..=280 => 13.0,
+        _ => 11.0,
+    }
+}
+
+/// A sticky note's layers: the frame, the note and (when known) its author.
+fn make_sticky(doc: &mut Document, parent: NodeId, at: (f64, f64), text: &str, color: Color, author: &str) -> Result<(NodeId, NodeId)> {
+    let id = add(doc, parent, NodeKind::Frame, "Sticky", at, (STICKY, STICKY), |n| {
+        n.fills = vec![Paint::solid(color)];
+        n.corners.radii = [2.0; 4];
+        n.effects = vec![soft_shadow()];
+        n.clip = false;
+        n.layout = Some(AutoLayout {
+            mode: LayoutMode::Vertical,
+            gap: 8.0,
+            padding: [STICKY_PAD; 4],
+            main_align: MainAlign::SpaceBetween,
+            ..AutoLayout::default()
+        });
+        n.child_layout.sizing_v = Sizing::Hug;
+        n.child_layout.min_h = Some(STICKY);
+        n.board = Some(BoardItem::Sticky { author: author.to_string() });
+    })?;
+    let inner = STICKY - 2.0 * STICKY_PAD;
+    let note = add_text(doc, id, text, sticky_font_size(text), INK, TextAlignH::Left, inner)?;
+    if !author.is_empty() {
+        let a = add_text(doc, id, author, 10.0, AUTHOR_INK, TextAlignH::Left, inner)?;
+        if let Some(n) = doc.node_mut(a) {
+            n.name = "Author".into();
+        }
+    }
+    Ok((id, note))
+}
+
+fn sticky_cmd(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "board.sticky";
+    require(s, cmd)?;
+    let color = color_param(cmd, p)?.unwrap_or(s.tool.board.sticky);
+    let author = match get(p, "author") {
+        Some(Value::String(a)) => a.trim().chars().filter(|c| !c.is_control()).take(64).collect(),
+        Some(Value::Bool(false)) => String::new(),
+        _ => author(s),
+    };
+    let parent = parent_of(cmd, s, p)?;
+    let text = string(p, "text").unwrap_or_default();
+    let at = (num_or(p, "x", 0.0), num_or(p, "y", 0.0));
+    let (id, note) = make_sticky(s.doc_mut()?, parent, at, &text, color, &author)?;
+    s.set_selection(vec![id]);
+    Ok(json!({"id": id, "text": note}))
+}
+
+/// The first text layer inside board object `id` (its note or label).
+pub fn text_of(doc: &Document, id: NodeId) -> Option<NodeId> {
+    let n = doc.node(id)?;
+    n.board.as_ref().filter(|b| b.has_text())?;
+    n.children.iter().copied().find(|c| doc.node(*c).is_some_and(|k| matches!(k.kind, NodeKind::Text(_))))
+}
+
+/// The board object whose text `text` is, if any.
+pub fn owner_of_text(doc: &Document, text: NodeId) -> Option<NodeId> {
+    let p = doc.node(text)?.parent?;
+    (text_of(doc, p) == Some(text)).then_some(p)
+}
+
+/// Start typing in board object `id`'s text (all of it selected). False when it has none.
+pub fn edit_text(s: &mut Session, id: NodeId) -> Result<bool> {
+    let Some(t) = s.doc().ok().and_then(|d| text_of(d, id)) else { return Ok(false) };
+    textedit::begin(s, t, None, false)?;
+    textedit::key(s, "SelectAll", false, false, false)?;
+    Ok(true)
+}
+
+fn next_sticky(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "board.nextSticky";
+    require(s, cmd)?;
+    let editing = s.ds()?.text_edit.as_ref().map(|t| t.id);
+    let doc = s.doc()?;
+    let from = id(p, "id")
+        .or_else(|| editing.and_then(|t| owner_of_text(doc, t)))
+        .or_else(|| s.selection().first().copied().map(|i| owner_of_text(doc, i).unwrap_or(i)))
+        .ok_or_else(|| EngineError::Disabled(cmd.into(), "select a sticky first".into()))?;
+    let n = doc.get(from)?;
+    if !matches!(n.board, Some(BoardItem::Sticky { .. })) {
+        return Err(bad(cmd, "that isn't a sticky"));
+    }
+    let color = n.fills.iter().find_map(Paint::solid_color).unwrap_or(s.tool.board.sticky);
+    let parent = n.parent.ok_or_else(|| bad(cmd, "that sticky has no parent"))?;
+    let at = n.transform.translation();
+    let (dx, dy) = match string(p, "side").as_deref().unwrap_or("right") {
+        "right" => (n.width + STICKY_GAP, 0.0),
+        "left" => (-(STICKY + STICKY_GAP), 0.0),
+        "below" => (0.0, n.height + STICKY_GAP),
+        "above" => (0.0, -(STICKY + STICKY_GAP)),
+        other => return Err(bad(cmd, format!("`side` is right, below, left or above, not `{other}`"))),
+    };
+    let author = author(s);
+    if editing.is_some() {
+        textedit::end(s)?;
+    }
+    let (id, note) = make_sticky(s.doc_mut()?, parent, (at.x + dx, at.y + dy), "", color, &author)?;
+    s.set_selection(vec![id]);
+    if boolean(p, "edit") == Some(true) {
+        // Typing goes on in the new sticky once this step is recorded.
+        s.request_ui("board.editText", json!({"id": id}));
+    }
+    Ok(json!({"id": id, "text": note}))
+}
+
+/// A shape with text's layers: the frame, its outline and its text.
+fn make_shape(
+    doc: &mut Document,
+    parent: NodeId,
+    at: (f64, f64),
+    size: (f64, f64),
+    shape: BoardShape,
+    text: &str,
+    color: Color,
+) -> Result<(NodeId, NodeId)> {
+    let (w, h) = size;
+    let id = add(doc, parent, NodeKind::Frame, shape.label(), at, size, |n| {
+        n.fills.clear();
+        n.clip = false;
+        n.layout = Some(AutoLayout {
+            mode: LayoutMode::Vertical,
+            padding: shape_padding(shape, w, h),
+            main_align: MainAlign::Center,
+            cross_align: CrossAlign::Center,
+            ..AutoLayout::default()
+        });
+        n.board = Some(BoardItem::Shape { shape });
+    })?;
+    add(doc, id, NodeKind::Vector { network: VectorNetwork::from_path(&shape.path(w, h)) }, "Outline", (0.0, 0.0), size, |n| {
+        n.fills = vec![Paint::solid(color)];
+        n.strokes = vec![Paint::solid(line_shade(color))];
+        n.stroke.weight = 1.5;
+        n.stroke.align = StrokeAlign::Inside;
+        n.child_layout.absolute = true;
+        n.constraints = Constraints { horizontal: HConstraint::Scale, vertical: VConstraint::Scale };
+    })?;
+    let [_, r, _, l] = shape_padding(shape, w, h);
+    let label = add_text(doc, id, text, 16.0, INK, TextAlignH::Center, (w - l - r).max(1.0))?;
+    Ok((id, label))
+}
+
+fn shape_padding(shape: BoardShape, w: f64, h: f64) -> [f64; 4] {
+    let [t, r, b, l] = shape.text_insets();
+    [t * h, r * w, b * h, l * w]
+}
+
+fn shape_cmd(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "board.shape";
+    require(s, cmd)?;
+    let shape = match string(p, "shape") {
+        Some(v) => shape_of(cmd, &v)?,
+        None => s.tool.board.shape,
+    };
+    let size = |k| {
+        num(p, k)
+            .map_or(Ok(SHAPE), |v| if (1.0..=100_000.0).contains(&v) { Ok(v) } else { Err(bad(cmd, format!("`{k}` is a size from 1 to 100000"))) })
+    };
+    let (w, h) = (size("width")?, size("height")?);
+    let color = color_param(cmd, p)?.unwrap_or(s.tool.board.sticky);
+    let parent = parent_of(cmd, s, p)?;
+    let text = string(p, "text").unwrap_or_default();
+    let at = (num_or(p, "x", 0.0), num_or(p, "y", 0.0));
+    let (id, label) = make_shape(s.doc_mut()?, parent, at, (w, h), shape, &text, color)?;
+    s.set_selection(vec![id]);
+    Ok(json!({"id": id, "text": label}))
+}
+
+fn stamp_cmd(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "board.stamp";
+    require(s, cmd)?;
+    let stamp = match string(p, "stamp") {
+        Some(v) => stamp_of(cmd, &v)?,
+        None => s.tool.board.stamp,
+    };
+    let (x, y) = (req_num(cmd, p, "x")?, req_num(cmd, p, "y")?);
+    let author = author(s);
+    let page = s.page()?;
+    let half = STAMP_SIZE / 2.0;
+    let doc = s.doc_mut()?;
+    let id = add(doc, page, NodeKind::Frame, stamp.label(), (x - half, y - half), (STAMP_SIZE, STAMP_SIZE), |n| {
+        n.fills = vec![Paint::solid(stamp.color())];
+        n.corners.radii = [half; 4];
+        n.effects = vec![soft_shadow()];
+        n.clip = false;
+        n.board = Some(BoardItem::Stamp { stamp, author });
+    })?;
+    for part in stamp.mark() {
+        let path = figcraft_geom::BezPath::from_svg(part.d).map_err(|e| EngineError::Other(format!("stamp mark: {e}")))?;
+        add(doc, id, NodeKind::Vector { network: VectorNetwork::from_path(&path) }, "Mark", (0.0, 0.0), (STAMP_SIZE, STAMP_SIZE), |n| {
+            if part.filled {
+                n.fills = vec![Paint::solid(Color::WHITE)];
+            } else {
+                n.fills.clear();
+                n.strokes = vec![Paint::solid(Color::WHITE)];
+                n.stroke.weight = 3.0;
+                (n.stroke.cap_start, n.stroke.cap_end) = (StrokeCap::Round, StrokeCap::Round);
+                n.stroke.join = StrokeJoin::Round;
+                n.stroke.align = StrokeAlign::Center;
+            }
+        })?;
+    }
+    s.set_selection(vec![id]);
+    Ok(json!({"id": id}))
+}
+
+fn ink_cmd(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "board.ink";
+    require(s, cmd)?;
+    let high = boolean(p, "highlighter").unwrap_or(false);
+    let color = color_param(cmd, p)?.unwrap_or(if high { s.tool.board.highlighter } else { s.tool.board.marker });
+    let (weight, opacity) = if high { HIGHLIGHTER } else { MARKER };
+    if get(p, "path").is_none() && get(p, "points").is_none() {
+        return Err(bad(cmd, "`path` or `points` is required"));
+    }
+    let page = s.page()?;
+    let select = boolean(p, "select").unwrap_or(true);
+    let mut q = json!({"type": "vector", "parent": page, "closed": false, "select": select, "name": if high { "Highlight" } else { "Ink" }, "props": {
+        "fills": [], "strokes": [color.to_css_hex()], "strokeWeight": weight, "strokeCap": "round", "strokeJoin": "round", "strokeAlign": "center",
+    }});
+    for k in ["path", "points"] {
+        if let (Some(v), Some(o)) = (get(p, k), q.as_object_mut()) {
+            o.insert(k.into(), v.clone());
+        }
+    }
+    let made = crate::cmd::create::create(s, &q)?;
+    let id = made.get("id").and_then(id_of).ok_or_else(|| EngineError::Other("no stroke made".into()))?;
+    let n = s.doc_mut()?.get_mut(id)?;
+    n.opacity = opacity;
+    if high {
+        n.blend = BlendMode::Multiply;
+    }
+    n.board = Some(BoardItem::Ink);
+    Ok(json!({"id": id}))
+}
+
+/// One connector end from the params: a layer on this page, or a point.
+fn end_param(cmd: &str, s: &Session, p: &Value, key: &str, side_key: &str) -> Result<End> {
+    let side = match string(p, side_key) {
+        Some(v) => Side::from_id(&v).ok_or_else(|| bad(cmd, format!("`{side_key}` is auto, top, right, bottom or left")))?,
+        None => Side::Auto,
+    };
+    match get(p, key) {
+        Some(Value::Object(o)) if o.contains_key("x") => {
+            let (x, y) = (num(&Value::Object(o.clone()), "x"), num(&Value::Object(o.clone()), "y"));
+            match (x, y) {
+                (Some(x), Some(y)) if x.is_finite() && y.is_finite() => Ok(End::Point { x, y }),
+                _ => Err(bad(cmd, format!("`{key}` needs finite x and y"))),
+            }
+        }
+        Some(v) => {
+            let node = id_of(v).ok_or_else(|| bad(cmd, format!("`{key}` is a layer id or {{x, y}}")))?;
+            let doc = s.doc()?;
+            let n = doc.get(node)?;
+            if n.is_page() || doc.page_of(node) != Some(s.page()?) {
+                return Err(bad(cmd, format!("`{key}` must be a layer on this page")));
+            }
+            if matches!(n.board, Some(BoardItem::Connector(_))) {
+                return Err(bad(cmd, format!("`{key}` can't be another connector")));
+            }
+            Ok(End::Node { node, side })
+        }
+        None => Err(bad(cmd, format!("`{key}` is required"))),
+    }
+}
+
+fn connector_cmd(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "board.connector";
+    require(s, cmd)?;
+    let from = end_param(cmd, s, p, "from", "fromSide")?;
+    let to = end_param(cmd, s, p, "to", "toSide")?;
+    if from.node().is_some() && from.node() == to.node() {
+        return Err(bad(cmd, "connect two different layers"));
+    }
+    let routing = match string(p, "style") {
+        Some(v) => routing_of(cmd, &v)?,
+        None => s.tool.board.routing,
+    };
+    let start = cap_of(cmd, p, "startCap")?.unwrap_or(StrokeCap::None);
+    let end = cap_of(cmd, p, "endCap")?.unwrap_or(StrokeCap::TriangleArrow);
+    let c = Connector { from, to, routing };
+    let page = s.page()?;
+    let doc = s.doc_mut()?;
+    let pts = route(doc, &c).ok_or_else(|| bad(cmd, "the ends can't be placed"))?;
+    if pts.windows(2).all(|w| w.first() == w.get(1)) {
+        return Err(bad(cmd, "the ends are in the same place"));
+    }
+    let id = add(doc, page, NodeKind::Vector { network: VectorNetwork::default() }, "Connector", (0.0, 0.0), (0.0, 0.0), |n| {
+        n.fills.clear();
+        n.strokes = vec![Paint::solid(LINE)];
+        n.stroke.weight = LINE_WEIGHT;
+        n.stroke.join = StrokeJoin::Round;
+        n.stroke.cap_start = start;
+        n.stroke.cap_end = end;
+        n.board = Some(BoardItem::Connector(c));
+    })?;
+    place_route(doc, id, &pts);
+    let mut out = json!({"id": id});
+    if let Some(text) = string(p, "label").filter(|t| !t.trim().is_empty()) {
+        out["label"] = json!(set_label(doc, id, &text)?);
+    }
+    s.set_selection(vec![id]);
+    Ok(out)
+}
+
+/// The label of connector `id`, if it has one.
+pub fn label_of(doc: &Document, id: NodeId) -> Option<NodeId> {
+    let parent = doc.node(id)?.parent?;
+    doc.node(parent)?.children.iter().copied().find(|c| doc.node(*c).is_some_and(|n| n.board == Some(BoardItem::Label { connector: id })))
+}
+
+/// Give connector `id` the label `text` (empty removes it); the label's id.
+fn set_label(doc: &mut Document, id: NodeId, text: &str) -> Result<Option<NodeId>> {
+    let existing = label_of(doc, id);
+    if text.trim().is_empty() {
+        if let Some(l) = existing {
+            doc.remove(l)?;
+        }
+        return Ok(None);
+    }
+    if let Some(l) = existing {
+        if let Some(t) = text_of(doc, l)
+            && let Some(NodeKind::Text(td)) = doc.node_mut(t).map(|n| &mut n.kind)
+        {
+            let len = td.char_count();
+            td.replace_range(0, len, text);
+        }
+        return Ok(Some(l));
+    }
+    let parent = doc.node(id).and_then(|n| n.parent).ok_or(DocError::NoNode(id))?;
+    let l = add(doc, parent, NodeKind::Frame, "Label", (0.0, 0.0), (40.0, 24.0), |n| {
+        n.fills = vec![Paint::solid(Color::WHITE)];
+        n.corners.radii = [4.0; 4];
+        n.clip = false;
+        n.layout = Some(AutoLayout { padding: [3.0, 6.0, 3.0, 6.0], ..AutoLayout::default() });
+        n.child_layout.sizing_h = Sizing::Hug;
+        n.child_layout.sizing_v = Sizing::Hug;
+        n.board = Some(BoardItem::Label { connector: id });
+    })?;
+    let t = add_text(doc, l, text, 12.0, INK, TextAlignH::Center, 40.0)?;
+    if let Some(n) = doc.node_mut(t)
+        && let NodeKind::Text(td) = &mut n.kind
+    {
+        // The label hugs its text: one line per paragraph.
+        td.auto_resize = TextAutoResize::WidthAndHeight;
+        n.child_layout.sizing_h = Sizing::Hug;
+    }
+    Ok(Some(l))
+}
+
+fn label_cmd(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "board.label";
+    require(s, cmd)?;
+    let id = req_targets(cmd, s, p)?.first().copied().ok_or_else(|| bad(cmd, "select a connector"))?;
+    let doc = s.doc()?;
+    let id = match doc.node(id).and_then(|n| n.board.clone()) {
+        Some(BoardItem::Connector(_)) => id,
+        Some(BoardItem::Label { connector }) => connector,
+        _ => return Err(bad(cmd, "that isn't a connector")),
+    };
+    let text = req_string(cmd, p, "text")?;
+    let label = set_label(s.doc_mut()?, id, &text)?;
+    Ok(json!({"id": id, "label": label}))
+}
+
+/// The board objects among `ids`, each with its item (a label counts as its connector's text).
+fn items(doc: &Document, ids: &[NodeId]) -> Vec<(NodeId, BoardItem)> {
+    ids.iter().filter_map(|i| doc.node(*i).and_then(|n| n.board.clone()).map(|b| (*i, b))).collect()
+}
+
+fn set_color(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "board.setColor";
+    require(s, cmd)?;
+    let ids = req_targets(cmd, s, p)?;
+    let color = color_param(cmd, p)?.ok_or_else(|| bad(cmd, "`color` is required"))?;
+    let doc = s.doc_mut()?;
+    let mut changed = Vec::new();
+    for (id, item) in items(doc, &ids) {
+        match item {
+            BoardItem::Sticky { .. } => doc.get_mut(id)?.fills = vec![Paint::solid(color)],
+            BoardItem::Shape { .. } => {
+                let Some(outline) = doc.get(id)?.children.first().copied() else { continue };
+                let n = doc.get_mut(outline)?;
+                n.fills = vec![Paint::solid(color)];
+                n.strokes = vec![Paint::solid(line_shade(color))];
+            }
+            BoardItem::Connector(_) | BoardItem::Ink => doc.get_mut(id)?.strokes = vec![Paint::solid(line_shade(color))],
+            BoardItem::Label { .. } | BoardItem::Stamp { .. } => continue,
+        }
+        changed.push(id);
+    }
+    if changed.is_empty() {
+        return Err(bad(cmd, "select stickies, shapes, connectors or ink"));
+    }
+    Ok(json!({"ids": changed}))
+}
+
+/// What `board.setStyle` changes (each `None` leaves it).
+struct Restyle {
+    shape: Option<BoardShape>,
+    routing: Option<Routing>,
+    size: Option<f64>,
+    start: Option<StrokeCap>,
+    end: Option<StrokeCap>,
+}
+
+impl Restyle {
+    fn of(cmd: &str, p: &Value) -> Result<Restyle> {
+        let size = num(p, "fontSize")
+            .map(|v| if v.is_finite() && (1.0..=1000.0).contains(&v) { Ok(v) } else { Err(bad(cmd, "`fontSize` is from 1 to 1000")) })
+            .transpose()?;
+        Ok(Restyle {
+            shape: string(p, "shape").map(|v| shape_of(cmd, &v)).transpose()?,
+            routing: string(p, "style").map(|v| routing_of(cmd, &v)).transpose()?,
+            size,
+            start: cap_of(cmd, p, "startCap")?,
+            end: cap_of(cmd, p, "endCap")?,
+        })
+    }
+
+    /// Restyle board object `id` (`item`); whether anything about it changed.
+    fn apply(&self, doc: &mut Document, id: NodeId, item: BoardItem) -> Result<bool> {
+        let changed = match item {
+            BoardItem::Shape { shape } => match self.shape.filter(|n| *n != shape) {
+                Some(new) => {
+                    reshape(doc, id, new)?;
+                    true
+                }
+                None => false,
+            },
+            BoardItem::Connector(c) => self.restyle_connector(doc, id, c)?,
+            _ => false,
+        };
+        // Text sizes: shapes' and labels' text (stickies size theirs to fit).
+        let sized = match (self.size, &item) {
+            (Some(size), BoardItem::Shape { .. } | BoardItem::Label { .. }) => resize_text(doc, id, size),
+            _ => false,
+        };
+        Ok(changed || sized)
+    }
+
+    fn restyle_connector(&self, doc: &mut Document, id: NodeId, mut c: Connector) -> Result<bool> {
+        let n = doc.get_mut(id)?;
+        if let Some(r) = self.routing {
+            c.routing = r;
+            n.board = Some(BoardItem::Connector(c));
+        }
+        if let Some(cap) = self.start {
+            n.stroke.cap_start = cap;
+        }
+        if let Some(cap) = self.end {
+            n.stroke.cap_end = cap;
+        }
+        Ok(self.routing.is_some() || self.start.is_some() || self.end.is_some())
+    }
+}
+
+/// Shape with text `id` takes outline `new` (its text room too).
+fn reshape(doc: &mut Document, id: NodeId, new: BoardShape) -> Result<()> {
+    let n = doc.get_mut(id)?;
+    n.board = Some(BoardItem::Shape { shape: new });
+    n.name = new.label().into();
+    let (w, h) = (n.width, n.height);
+    if let Some(l) = n.layout.as_mut() {
+        l.padding = shape_padding(new, w, h);
+    }
+    if let Some(o) = doc.get(id)?.children.first().copied()
+        && let Some(on) = doc.node_mut(o)
+    {
+        on.kind = NodeKind::Vector { network: VectorNetwork::from_path(&new.path(w, h)) };
+        (on.width, on.height, on.transform) = (w, h, Affine::IDENTITY);
+    }
+    Ok(())
+}
+
+/// Board object `id`'s text at `size`; whether it has text.
+fn resize_text(doc: &mut Document, id: NodeId, size: f64) -> bool {
+    let Some(t) = text_of(doc, id) else { return false };
+    if let Some(NodeKind::Text(td)) = doc.node_mut(t).map(|n| &mut n.kind) {
+        set_font_size(td, size);
+        return true;
+    }
+    false
+}
+
+fn set_style(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "board.setStyle";
+    require(s, cmd)?;
+    let ids = req_targets(cmd, s, p)?;
+    let restyle = Restyle::of(cmd, p)?;
+    let doc = s.doc_mut()?;
+    let mut changed = Vec::new();
+    for (id, item) in items(doc, &ids) {
+        if restyle.apply(doc, id, item)? {
+            changed.push(id);
+        }
+    }
+    if changed.is_empty() {
+        return Err(bad(cmd, "nothing selected takes these (shapes with text, connectors, labels)"));
+    }
+    Ok(json!({"ids": changed}))
+}
+
+fn set_font_size(td: &mut TextData, size: f64) {
+    td.style.font_size = size;
+    for r in &mut td.runs {
+        r.style.font_size = size;
+    }
+}
+
+/// Each layer of `sources` (copied one by one, in order, as `copies`) and its copy: the whole
+/// subtrees pair up when they have the same shape (an instance made of a main component may not;
+/// then only the roots do).
+pub(crate) fn copy_map(doc: &Document, sources: &[NodeId], copies: &[NodeId]) -> BTreeMap<NodeId, NodeId> {
+    let mut map = BTreeMap::new();
+    for (s, c) in sources.iter().zip(copies) {
+        let (a, b) = (doc.subtree(*s), doc.subtree(*c));
+        if a.len() == b.len() {
+            map.extend(a.into_iter().zip(b));
+        } else {
+            map.insert(*s, *c);
+        }
+    }
+    map
+}
+
+/// The connectors and labels among copied layers, as `(copy, the original's board item)`, from the
+/// originals in `doc` (`map`: original → copy).
+pub(crate) fn copied_items(doc: &Document, map: &BTreeMap<NodeId, NodeId>) -> Vec<(NodeId, BoardItem)> {
+    map.iter().filter_map(|(o, c)| doc.node(*o).and_then(|n| n.board.clone()).map(|b| (*c, b))).collect()
+}
+
+/// After a copy (`map`: each copied original → its copy; `originals`: the copies' items as the
+/// originals had them), copied connectors join the copies of what they joined and labels follow
+/// the copies of their connectors. From another file (`foreign`), what wasn't copied isn't here: a
+/// connector's end there stays where it is drawn, as a point, and a label without its connector
+/// goes.
+pub(crate) fn rejoin(doc: &mut Document, originals: &[(NodeId, BoardItem)], map: &BTreeMap<NodeId, NodeId>, foreign: bool) {
+    for (copy, item) in originals {
+        let mut item = item.clone();
+        let copied = |n: NodeId| map.contains_key(&n);
+        match &mut item {
+            BoardItem::Connector(c) if foreign => {
+                let ends = ends_now(doc, *copy);
+                for (end, at) in [(&mut c.from, ends.map(|e| e.0)), (&mut c.to, ends.map(|e| e.1))] {
+                    if let (End::Node { node, .. }, Some(p)) = (*end, at)
+                        && !copied(node)
+                    {
+                        *end = End::Point { x: p.x, y: p.y };
+                    }
+                }
+            }
+            BoardItem::Label { connector } if foreign && !copied(*connector) => {
+                let _ = doc.remove(*copy);
+                continue;
+            }
+            BoardItem::Connector(_) | BoardItem::Label { .. } => {}
+            _ => continue,
+        }
+        item.remap(map);
+        if let Some(n) = doc.node_mut(*copy) {
+            n.board = Some(item);
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------------------------
+// Derived data (the normalize pass).
+
+/// Before text is measured: a sticky's note takes the size its length calls for, and a resized
+/// shape keeps its text inside its outline.
+pub(crate) fn settle_text(doc: &mut Document, before: &Document, touched: &BTreeSet<NodeId>) {
+    if !is_board(doc) {
+        return;
+    }
+    for &id in touched {
+        let Some(n) = doc.node(id) else { continue };
+        if let Some(owner) =
+            owner_of_text(doc, id).or(Some(id)).filter(|o| doc.node(*o).is_some_and(|k| matches!(k.board, Some(BoardItem::Sticky { .. }))))
+            && let Some(t) = text_of(doc, owner)
+            && let Some(NodeKind::Text(td)) = doc.node(t).map(|k| &k.kind)
+        {
+            let size = sticky_font_size(&td.characters);
+            let off = td.style.font_size != size || td.runs.iter().any(|r| r.style.font_size != size);
+            if off && let Some(NodeKind::Text(td)) = doc.node_mut(t).map(|k| &mut k.kind) {
+                set_font_size(td, size);
+            }
+            continue;
+        }
+        if let Some(BoardItem::Shape { shape }) = n.board
+            && before.node(id).is_none_or(|b| (b.width, b.height) != (n.width, n.height))
+        {
+            let pad = shape_padding(shape, n.width, n.height);
+            if n.layout.as_ref().is_some_and(|l| l.padding != pad)
+                && let Some(l) = doc.node_mut(id).and_then(|k| k.layout.as_mut())
+            {
+                l.padding = pad;
+            }
+        }
+    }
+}
+
+/// After layout: connectors run between their ends again (an end whose layer is gone stays where
+/// it was), one moved on its own takes its free ends along, and labels sit at their middles. Only
+/// the connectors and labels an edit can have moved are looked at: touched themselves, or with a
+/// touched (or gone) end, connector or layer around them.
+pub(crate) fn settle_routes(doc: &mut Document, before: &Document, touched: &BTreeSet<NodeId>) {
+    if !is_board(doc) || touched.is_empty() {
+        return;
+    }
+    let hit = |doc: &Document, id: NodeId| touched.contains(&id) || doc.ancestors(id).iter().any(|a| touched.contains(a));
+    let (mut connectors, mut labels) = (Vec::new(), Vec::new());
+    for n in doc.nodes() {
+        match &n.board {
+            Some(BoardItem::Connector(c)) => {
+                let ends = [c.from.node(), c.to.node()].into_iter().flatten();
+                if hit(doc, n.id) || ends.into_iter().any(|e| !doc.contains(e) || hit(doc, e)) {
+                    connectors.push((n.id, *c));
+                }
+            }
+            Some(BoardItem::Label { connector }) => labels.push((n.id, *connector)),
+            _ => {}
+        }
+    }
+    let rerouted: BTreeSet<NodeId> = connectors.iter().map(|(id, _)| *id).collect();
+    for (id, mut c) in connectors {
+        let changed = detach_gone_ends(doc, id, &mut c) | carry_free_ends(doc, before, touched, id, &mut c);
+        if changed && let Some(n) = doc.node_mut(id) {
+            n.board = Some(BoardItem::Connector(c));
+        }
+        if let Some(pts) = route(doc, &c) {
+            place_route(doc, id, &pts);
+        }
+    }
+    for (label, connector) in labels {
+        if rerouted.contains(&connector) || touched.contains(&connector) || hit(doc, label) {
+            place_label(doc, label, connector);
+        }
+    }
+}
+
+/// The ends of connector `id` (as `c`) whose layer is gone or on another page stay where they are
+/// drawn, as points. Whether any did.
+fn detach_gone_ends(doc: &Document, id: NodeId, c: &mut Connector) -> bool {
+    let (page, ends) = (doc.page_of(id), ends_now(doc, id));
+    let mut detached = false;
+    for (end, at) in [(&mut c.from, ends.map(|e| e.0)), (&mut c.to, ends.map(|e| e.1))] {
+        if let (End::Node { node, .. }, Some(p)) = (*end, at)
+            && (!doc.contains(node) || doc.page_of(node) != page)
+        {
+            *end = End::Point { x: p.x, y: p.y };
+            detached = true;
+        }
+    }
+    detached
+}
+
+/// Connector `id` (as `c`) moved by itself (a drag, a nudge: its place changed but not what it
+/// joins): its free ends move with it. Whether they did.
+fn carry_free_ends(doc: &Document, before: &Document, touched: &BTreeSet<NodeId>, id: NodeId, c: &mut Connector) -> bool {
+    let (Some(b), Some(n)) = (before.node(id), doc.node(id)) else { return false };
+    if !touched.contains(&id) || b.transform == n.transform || b.board != n.board {
+        return false;
+    }
+    let Some(expected) = route(doc, c).and_then(|pts| figcraft_geom::points_bounds(pts.iter().copied())).map(|b| b.origin()) else { return false };
+    let d = (doc.world_transform(id) * Point::ZERO) - expected;
+    if d.hypot() <= 1e-9 {
+        return false;
+    }
+    let mut moved = false;
+    for end in [&mut c.from, &mut c.to] {
+        if let End::Point { x, y } = end {
+            (*x, *y) = (*x + d.x, *y + d.y);
+            moved = true;
+        }
+    }
+    moved
+}
+
+/// Label `label` at the middle of connector `connector`; gone with it when it is gone.
+fn place_label(doc: &mut Document, label: NodeId, connector: NodeId) {
+    let Some(mid) = doc.node(connector).and_then(|_| route_mid(doc, connector)) else {
+        let _ = doc.remove(label);
+        return;
+    };
+    let Some(n) = doc.node(label) else { return };
+    let pw = n.parent.map_or(Affine::IDENTITY, |p| doc.world_transform(p));
+    let local = pw.inverse() * mid;
+    let t = Affine::translate((local.x - n.width / 2.0, local.y - n.height / 2.0));
+    if n.transform != t
+        && let Some(n) = doc.node_mut(label)
+    {
+        n.transform = t;
+    }
+}
+
+/// Connector `id`'s first and last points on the page as it is drawn now.
+fn ends_now(doc: &Document, id: NodeId) -> Option<(Point, Point)> {
+    let NodeKind::Vector { network } = &doc.node(id)?.kind else { return None };
+    let w = doc.world_transform(id);
+    Some((w * network.vertices.first()?.point(), w * network.vertices.last()?.point()))
+}
+
+/// The middle of connector `id`'s route by length, on the page.
+fn route_mid(doc: &Document, id: NodeId) -> Option<Point> {
+    let NodeKind::Vector { network } = &doc.node(id)?.kind else { return None };
+    let w = doc.world_transform(id);
+    let pts: Vec<Point> = network.vertices.iter().map(|v| w * v.point()).collect();
+    let total: f64 = pts.windows(2).map(|s| (s[1] - s[0]).hypot()).sum();
+    let mut left = total / 2.0;
+    for s in pts.windows(2) {
+        let (a, b) = (s[0], s[1]);
+        let l = (b - a).hypot();
+        if l >= left && l > 0.0 {
+            return Some(a.lerp(b, left / l));
+        }
+        left -= l;
+    }
+    pts.first().copied()
+}
+
+/// Write the route `pts` (page points) into connector `id`: its box, place and path. Untouched
+/// when it already runs there, so a connector that didn't move isn't an edit.
+fn place_route(doc: &mut Document, id: NodeId, pts: &[Point]) {
+    let Some(n) = doc.node(id) else { return };
+    let pw = n.parent.map_or(Affine::IDENTITY, |p| doc.world_transform(p));
+    let inv = pw.inverse();
+    let local: Vec<Point> = pts.iter().map(|p| inv * *p).collect();
+    let Some(b) = figcraft_geom::points_bounds(local.iter().copied()) else { return };
+    if !(b.x0.is_finite() && b.y0.is_finite() && b.x1.is_finite() && b.y1.is_finite()) {
+        return;
+    }
+    let rel: Vec<Point> = local.iter().map(|p| Point::new(p.x - b.x0, p.y - b.y0)).collect();
+    let network = VectorNetwork::from_points(&rel, false);
+    let t = Affine::translate((b.x0, b.y0));
+    let same =
+        n.transform == t && n.width == b.width() && n.height == b.height() && matches!(&n.kind, NodeKind::Vector { network: old } if *old == network);
+    if same {
+        return;
+    }
+    if let Some(n) = doc.node_mut(id) {
+        n.kind = NodeKind::Vector { network };
+        n.transform = t;
+        (n.width, n.height) = (b.width(), b.height());
+    }
+}
+
+/// The page points connector `c` runs through: from the middle of the side of each attached layer
+/// facing the other end (or the side it names), straight or in right angles.
+pub fn route(doc: &Document, c: &Connector) -> Option<Vec<Point>> {
+    let bounds = |e: &End| e.node().and_then(|n| doc.world_bounds(n));
+    let centre = |e: &End, b: Option<Rect>| match e {
+        End::Point { x, y } => Some(Point::new(*x, *y)),
+        End::Node { .. } => b.map(|b| b.center()),
+    };
+    let (fb, tb) = (bounds(&c.from), bounds(&c.to));
+    let (fc, tc) = (centre(&c.from, fb)?, centre(&c.to, tb)?);
+    let (p0, h0) = attach(&c.from, fb, tc)?;
+    let (p1, h1) = attach(&c.to, tb, fc)?;
+    let mut pts = match c.routing {
+        Routing::Straight => vec![p0, p1],
+        Routing::Elbow => elbow(p0, h0, p1, h1),
+    };
+    pts.dedup();
+    // A turn that doesn't turn (the ends in line) is no point of the route.
+    let in_line = |i: usize, b: &Point| match (i.checked_sub(1).and_then(|j| pts.get(j)), pts.get(i + 1)) {
+        (Some(a), Some(c)) => (a.x == b.x && b.x == c.x) || (a.y == b.y && b.y == c.y),
+        _ => false,
+    };
+    let pts: Vec<Point> = pts.iter().enumerate().filter(|(i, b)| !in_line(*i, b)).map(|(_, b)| *b).collect();
+    pts.iter().all(|p| p.x.is_finite() && p.y.is_finite()).then_some(pts)
+}
+
+/// Where end `e` attaches (its point, or the middle of its layer's side facing `other`) and
+/// whether that side faces sideways (`None`: a free point).
+fn attach(e: &End, b: Option<Rect>, other: Point) -> Option<(Point, Option<bool>)> {
+    match e {
+        End::Point { x, y } => Some((Point::new(*x, *y), None)),
+        End::Node { side, .. } => {
+            let b = b?;
+            let side = match side {
+                Side::Auto => {
+                    let d = other - b.center();
+                    // Compare against the box's proportions: a wide box takes the sides more.
+                    if d.x.abs() * b.height().max(1e-9) >= d.y.abs() * b.width().max(1e-9) {
+                        if d.x >= 0.0 { Side::Right } else { Side::Left }
+                    } else if d.y >= 0.0 {
+                        Side::Bottom
+                    } else {
+                        Side::Top
+                    }
+                }
+                s => *s,
+            };
+            Some((side.point(b), Some(side.horizontal())))
+        }
+    }
+}
+
+/// A right-angled route from `p0` to `p1`, leaving and arriving along the sides' normals
+/// (`h`: sideways; a free end follows the other).
+fn elbow(p0: Point, h0: Option<bool>, p1: Point, h1: Option<bool>) -> Vec<Point> {
+    let h0 = h0.or(h1).unwrap_or((p1.x - p0.x).abs() >= (p1.y - p0.y).abs());
+    let h1 = h1.unwrap_or(h0);
+    match (h0, h1) {
+        (true, true) => {
+            let mx = (p0.x + p1.x) / 2.0;
+            vec![p0, Point::new(mx, p0.y), Point::new(mx, p1.y), p1]
+        }
+        (false, false) => {
+            let my = (p0.y + p1.y) / 2.0;
+            vec![p0, Point::new(p0.x, my), Point::new(p1.x, my), p1]
+        }
+        (true, false) => vec![p0, Point::new(p1.x, p0.y), p1],
+        (false, true) => vec![p0, Point::new(p0.x, p1.y), p1],
+    }
+}
+
+// ---------------------------------------------------------------------------------------------
+// The board tools.
+
+impl Session {
+    /// A press with a board tool: place a sticky, shape or stamp, start a connector or a stroke,
+    /// or start erasing.
+    pub(crate) fn board_down(&mut self, ev: &PointerEvent) -> Result<()> {
+        // A board tool kept while a design file came to the front: back to Move for this press.
+        if !is_board(self.doc()?) {
+            self.tool.tool = ToolId::Move;
+            return self.pointer(ev);
+        }
+        // A sticky still being typed in ends first, so the next object is an undo step of its own.
+        if self.ds()?.text_edit.is_some() {
+            crate::textedit::end(self)?;
+        }
+        match self.tool.tool {
+            ToolId::Sticky => {
+                let half = STICKY / 2.0;
+                let r = self.execute("board.sticky", &json!({"x": ev.x - half, "y": ev.y - half}))?;
+                self.board_placed();
+                if let Some(id) = r.get("id").and_then(id_of) {
+                    edit_text(self, id)?;
+                }
+                Ok(())
+            }
+            ToolId::BoardShape => {
+                let half = SHAPE / 2.0;
+                self.execute("board.shape", &json!({"x": ev.x - half, "y": ev.y - half}))?;
+                self.board_placed();
+                Ok(())
+            }
+            ToolId::Stamp => {
+                // Stamps go on one after another: the tool stays.
+                self.execute("board.stamp", &json!({"x": ev.x, "y": ev.y}))?;
+                Ok(())
+            }
+            ToolId::Marker | ToolId::Highlighter => {
+                self.tool.gesture = Gesture::Pencil { points: vec![ev.p()], pressure: vec![ev.pressure] };
+                Ok(())
+            }
+            ToolId::Connector => {
+                let from = self.end_at(ev);
+                self.tool.gesture = Gesture::Connect { from, start: ev.p() };
+                Ok(())
+            }
+            ToolId::Eraser => {
+                self.begin_interaction("Erase")?;
+                self.tool.gesture = Gesture::Erase { gone: Vec::new() };
+                self.erase_at(ev)
+            }
+            _ => Ok(()),
+        }
+    }
+
+    /// After placing an object: back to the Move tool unless tools stay on.
+    fn board_placed(&mut self) {
+        if !self.prefs.keep_tool {
+            self.set_tool(ToolId::Move);
+        }
+    }
+
+    /// What a connector end at the pointer attaches to: the object there, or the point.
+    fn end_at(&self, ev: &PointerEvent) -> End {
+        let hit = (|| {
+            let doc = self.doc().ok()?;
+            let leaf = self.hit(doc, self.page().ok()?, ev.p(), 2.0 / ev.zoom.max(1e-6))?;
+            let t = figcraft_doc::geometry::select_target(doc, leaf, &[], false);
+            let n = doc.node(t)?;
+            (!matches!(n.board, Some(BoardItem::Connector(_)) | Some(BoardItem::Label { .. }) | Some(BoardItem::Ink))).then_some(t)
+        })();
+        match hit {
+            Some(node) => End::Node { node, side: Side::Auto },
+            None => End::Point { x: ev.x, y: ev.y },
+        }
+    }
+
+    pub(crate) fn connect_drag(&mut self, ev: &PointerEvent, from: End, start: Point) {
+        let a = match from {
+            End::Point { x, y } => Point::new(x, y),
+            End::Node { .. } => start,
+        };
+        self.tool.overlay.rubber = Some([a.x, a.y, ev.x, ev.y]);
+        self.tool.overlay.drop_target = from.node();
+        self.tool.gesture = Gesture::Connect { from, start };
+        if let Ok(ds) = self.ds_mut() {
+            ds.revision += 1;
+        }
+    }
+
+    pub(crate) fn connect_up(&mut self, ev: &PointerEvent, from: End, start: Point) -> Result<()> {
+        self.tool.overlay.rubber = None;
+        self.tool.overlay.drop_target = None;
+        // A click, not a drag: nothing to join.
+        if (ev.p() - start).hypot() * ev.zoom.max(1e-6) < 4.0 {
+            return Ok(());
+        }
+        let to = self.end_at(ev);
+        if to.node().is_some() && to.node() == from.node() {
+            return Ok(());
+        }
+        let json_end = |e: End| match e {
+            End::Node { node, .. } => json!(node),
+            End::Point { x, y } => json!({"x": x, "y": y}),
+        };
+        let style = self.tool.board.routing.id();
+        self.execute("board.connector", &json!({"from": json_end(from), "to": json_end(to), "style": style}))?;
+        self.board_placed();
+        Ok(())
+    }
+
+    /// The eraser at the pointer: the marker and highlighter strokes it touches go (until the
+    /// gesture ends, which is one undo step).
+    pub(crate) fn erase_at(&mut self, ev: &PointerEvent) -> Result<()> {
+        let Gesture::Erase { mut gone } = std::mem::take(&mut self.tool.gesture) else { return Ok(()) };
+        let tol = ERASER_PX / ev.zoom.max(1e-6);
+        self.tool.overlay.brush = Some([ev.x, ev.y, tol]);
+        let (doc, page) = (self.doc()?.clone(), self.page()?);
+        if let Some(hit) =
+            doc.hit_test(page, ev.p(), tol, None).filter(|h| doc.node(*h).is_some_and(|n| n.board == Some(BoardItem::Ink)) && !gone.contains(h))
+        {
+            gone.push(hit);
+            let ids = gone.clone();
+            self.preview(|d, sel| {
+                for i in &ids {
+                    let _ = d.remove(*i);
+                }
+                sel.retain(|s| !ids.contains(s));
+                Ok(())
+            })?;
+        }
+        self.tool.gesture = Gesture::Erase { gone };
+        if let Ok(ds) = self.ds_mut() {
+            ds.revision += 1;
+        }
+        Ok(())
+    }
+
+    pub(crate) fn erase_up(&mut self) -> Result<()> {
+        self.tool.overlay.brush = None;
+        self.commit_interaction()
+    }
+
+    /// A finished marker or highlighter stroke (page points).
+    pub(crate) fn ink_finish(&mut self, path: &str) -> Result<()> {
+        let high = self.tool.tool == ToolId::Highlighter;
+        self.execute("board.ink", &json!({"path": path, "highlighter": high, "select": false}))?;
+        // Strokes come one after another: the selection stays as it was.
+        Ok(())
+    }
+}
+
+impl Session {
+    /// A double-click with the Move tool on a board object: type in its text (a connector gets a
+    /// label to type in). True when it was one.
+    pub(crate) fn board_double_click(&mut self, doc: &Document, leaf: NodeId, sel: &[NodeId]) -> Result<bool> {
+        let whole = figcraft_doc::geometry::select_target(doc, leaf, sel, false);
+        let editing = self.ds()?.text_edit.as_ref().is_some_and(|te| owner_of_text(doc, te.id) == Some(whole));
+        let Some(item) = doc.node(whole).and_then(|n| n.board.clone()).filter(|_| !editing) else { return Ok(false) };
+        self.tool.gesture = Gesture::None;
+        self.cancel_interaction()?;
+        match item {
+            BoardItem::Connector(_) => {
+                let label = match label_of(doc, whole) {
+                    Some(l) => l,
+                    None => {
+                        let r = self.execute("board.label", &json!({"id": whole, "text": "Label"}))?;
+                        r.get("label").and_then(id_of).ok_or_else(|| EngineError::Other("no label made".into()))?
+                    }
+                };
+                edit_text(self, label)
+            }
+            b if b.has_text() => edit_text(self, whole),
+            _ => Ok(false),
+        }
+    }
+}
diff --git a/crates/engine/src/board_tests.rs b/crates/engine/src/board_tests.rs
new file mode 100644
index 000000000..5b8cbbf90
--- /dev/null
+++ b/crates/engine/src/board_tests.rs
@@ -0,0 +1,363 @@
+//! Boards: the file kind, sticky notes, shapes with text, connectors that follow what they join
+//! (locally, through undo and in live sessions), stamps, ink and the eraser, and refusals.
+
+use figcraft_doc::{
+    BOARD_PAGE, BoardItem, BoardShape, Connector, End, FileKind, Node, NodeId, NodeKind, Routing, Side, Stamp, StrokeCap, board_color,
+};
+use figcraft_geom::Point;
+use serde_json::{Value, json};
+
+use crate::board::{route, sticky_font_size};
+use crate::collab_live_tests::Room;
+use crate::tools::{PointerEvent, PointerKind, ToolId};
+use crate::{EngineError, Session};
+
+pub(crate) fn board() -> Session {
+    let mut s = Session::new();
+    s.execute("file.newBoard", &json!({"name": "Ideas"})).unwrap();
+    s
+}
+
+pub(crate) fn id(v: &Value, key: &str) -> NodeId {
+    v[key].as_u64().map(NodeId).unwrap_or_else(|| panic!("no {key} in {v}"))
+}
+
+pub(crate) fn node(s: &Session, id: NodeId) -> Node {
+    s.doc().unwrap().node(id).unwrap().clone()
+}
+
+pub(crate) fn connector(s: &Session, id: NodeId) -> Connector {
+    match node(s, id).board {
+        Some(BoardItem::Connector(c)) => c,
+        other => panic!("not a connector: {other:?}"),
+    }
+}
+
+/// Connector `id`'s points on the page.
+pub(crate) fn drawn(s: &Session, id: NodeId) -> Vec<Point> {
+    let doc = s.doc().unwrap();
+    let NodeKind::Vector { network } = &doc.node(id).unwrap().kind else { panic!("not a vector") };
+    let w = doc.world_transform(id);
+    network.vertices.iter().map(|v| w * v.point()).collect()
+}
+
+pub(crate) fn near(a: Point, b: Point) -> bool {
+    (a - b).hypot() < 1e-6
+}
+
+#[test]
+fn a_board_is_a_kind_of_file_that_saves_and_reopens() {
+    let s = board();
+    let doc = s.doc().unwrap();
+    assert_eq!(doc.kind, FileKind::Board);
+    assert!(matches!(doc.node(doc.pages[0]).unwrap().kind, NodeKind::Page { background, .. } if background == BOARD_PAGE));
+    let (back, _) = figcraft_format::from_json(&figcraft_format::to_json(doc).unwrap().to_string()).unwrap();
+    assert_eq!(back.kind, FileKind::Board);
+    // Files from before boards (no kind) are design files, and design files don't write one.
+    let mut d = Session::new();
+    d.execute("file.new", &json!({})).unwrap();
+    let json = figcraft_format::to_json(d.doc().unwrap()).unwrap();
+    assert!(json.get("kind").is_none());
+    assert_eq!(figcraft_format::from_json(&json.to_string()).unwrap().0.kind, FileKind::Design);
+    assert_eq!(crate::inspect::document(&s, 0, false)["kind"], "board", "inspect shows the kind");
+}
+
+#[test]
+fn board_commands_refuse_on_design_files_and_prototyping_refuses_on_boards() {
+    let mut d = Session::new();
+    d.execute("file.new", &json!({})).unwrap();
+    for (cmd, p) in [("board.sticky", json!({"x": 0, "y": 0})), ("tool.sticky", json!({})), ("tool.set", json!({"tool": "marker"}))] {
+        assert!(matches!(d.execute(cmd, &p), Err(EngineError::Disabled(..))), "{cmd} on a design file");
+    }
+    let mut s = board();
+    for cmd in ["view.devMode", "view.prototype", "proto.present", "proto.flow.add", "dev.focus"] {
+        let e = s.execute(cmd, &json!({})).unwrap_err();
+        assert!(e.to_string().contains("boards have no prototypes"), "{cmd}: {e}");
+    }
+}
+
+#[test]
+fn a_sticky_is_a_square_frame_whose_note_shrinks_as_it_grows() {
+    let mut s = board();
+    s.prefs.user_name = "Ada".into();
+    let r = s.execute("board.sticky", &json!({"x": 10, "y": 20, "text": "Hi", "color": "blue"})).unwrap();
+    let (st, note) = (id(&r, "id"), id(&r, "text"));
+    let n = node(&s, st);
+    assert!(n.is_board_atom() && matches!(&n.board, Some(BoardItem::Sticky { author }) if author == "Ada"));
+    assert_eq!((n.width, n.height), (200.0, 200.0));
+    assert_eq!(n.fills[0].solid_color(), board_color("blue"));
+    assert!(n.layout.is_some() && !n.effects.is_empty());
+    assert_eq!(n.children.len(), 2, "the note and its author");
+    assert_eq!(node(&s, note).kind.text().unwrap().style.font_size, 24.0);
+    // A click on the note picks the sticky whole.
+    let doc = s.doc().unwrap();
+    assert_eq!(figcraft_doc::geometry::select_target(doc, note, &[], false), st);
+    // A long note takes a smaller size; a very long one grows the sticky past its square.
+    let long = "word ".repeat(120);
+    s.execute("node.set", &json!({"id": note, "props": {"characters": long}})).unwrap();
+    assert_eq!(node(&s, note).kind.text().unwrap().style.font_size, sticky_font_size(&long));
+    assert!(sticky_font_size(&long) < 16.0);
+    assert!(node(&s, st).width == 200.0 && node(&s, st).height >= 200.0);
+    // Undo puts the short note and its size back.
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(node(&s, note).kind.text().unwrap().style.font_size, 24.0);
+}
+
+#[test]
+fn next_sticky_goes_beside_in_the_same_colour_and_emptied_notes_stay() {
+    let mut s = board();
+    let a = id(&s.execute("board.sticky", &json!({"x": 0, "y": 0, "color": "pink"})).unwrap(), "id");
+    let r = s.execute("board.nextSticky", &json!({})).unwrap();
+    let b = id(&r, "id");
+    let (na, nb) = (node(&s, a), node(&s, b));
+    assert_eq!(nb.transform.translation().x, na.width + 24.0);
+    assert_eq!(nb.fills, na.fills);
+    assert_eq!(s.selection(), vec![b]);
+    // Typing in it and emptying it again keeps its note; ending selects the sticky.
+    let note = id(&r, "text");
+    crate::board::edit_text(&mut s, b).unwrap();
+    crate::textedit::insert(&mut s, "x").unwrap();
+    crate::textedit::key(&mut s, "Backspace", false, false, false).unwrap();
+    crate::textedit::end(&mut s).unwrap();
+    assert!(s.doc().unwrap().contains(note));
+    assert_eq!(s.selection(), vec![b]);
+}
+
+#[test]
+fn shapes_carry_text_and_change_outline() {
+    let mut s = board();
+    let r = s.execute("board.shape", &json!({"shape": "diamond", "x": 0, "y": 0, "text": "Decide", "color": "green"})).unwrap();
+    let sh = id(&r, "id");
+    let n = node(&s, sh);
+    assert_eq!(n.board, Some(BoardItem::Shape { shape: BoardShape::Diamond }));
+    assert_eq!(n.children.len(), 2);
+    assert!(matches!(node(&s, n.children[0]).kind, NodeKind::Vector { .. }));
+    s.execute("board.setStyle", &json!({"ids": [sh], "shape": "speechBubble", "fontSize": 24})).unwrap();
+    assert_eq!(node(&s, sh).board, Some(BoardItem::Shape { shape: BoardShape::SpeechBubble }));
+    assert_eq!(node(&s, id(&r, "text")).kind.text().unwrap().style.font_size, 24.0);
+    s.execute("board.setColor", &json!({"ids": [sh], "color": "#FF0000"})).unwrap();
+    assert_eq!(node(&s, n.children[0]).fills[0].solid_color().map(|c| c.to_hex()), Some("FF0000".into()));
+    assert!(s.execute("board.shape", &json!({"shape": "blob", "x": 0, "y": 0})).is_err());
+}
+
+#[test]
+fn connectors_follow_what_they_join_and_undo_with_it() {
+    let mut s = board();
+    let a = id(&s.execute("board.sticky", &json!({"x": 0, "y": 0})).unwrap(), "id");
+    let b = id(&s.execute("board.sticky", &json!({"x": 400, "y": 0})).unwrap(), "id");
+    let c = id(&s.execute("board.connector", &json!({"from": a, "to": b, "style": "straight", "label": "then"})).unwrap(), "id");
+    let pts = drawn(&s, c);
+    assert!(near(pts[0], Point::new(200.0, 100.0)) && near(pts[1], Point::new(400.0, 100.0)), "{pts:?}");
+    assert_eq!(node(&s, c).stroke.cap_end, StrokeCap::TriangleArrow);
+    // Its label sits at the middle.
+    let label = crate::board::label_of(s.doc().unwrap(), c).unwrap();
+    let lb = s.doc().unwrap().world_bounds(label).unwrap();
+    assert!(near(lb.center(), Point::new(300.0, 100.0)), "{lb:?}");
+    // Move one end: the connector re-routes (elbow now, out of the facing sides).
+    s.execute("board.setStyle", &json!({"ids": [c], "style": "elbow"})).unwrap();
+    s.execute("transform.move", &json!({"ids": [b], "dx": 0, "dy": 300})).unwrap();
+    let pts = drawn(&s, c);
+    assert!(near(pts[0], Point::new(200.0, 100.0)) && near(*pts.last().unwrap(), Point::new(400.0, 400.0)), "{pts:?}");
+    assert!(pts.windows(2).all(|w| w[0].x == w[1].x || w[0].y == w[1].y), "right angles: {pts:?}");
+    // Undo takes the move back and the route with it.
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert!(near(*drawn(&s, c).last().unwrap(), Point::new(400.0, 100.0)));
+    // A deleted end stays where it was, as a point.
+    s.execute("edit.delete", &json!({"ids": [b]})).unwrap();
+    assert!(matches!(connector(&s, c).to, End::Point { .. }));
+    assert!(near(*drawn(&s, c).last().unwrap(), Point::new(400.0, 100.0)));
+    // A connector moved on its own takes its free end along; the attached one stays.
+    s.execute("transform.move", &json!({"ids": [c], "dx": 0, "dy": 50})).unwrap();
+    assert!(matches!(connector(&s, c).to, End::Point { x, y } if x == 400.0 && y == 150.0), "{:?}", connector(&s, c));
+    assert!(near(drawn(&s, c)[0], Point::new(200.0, 100.0)));
+    // Deleting the connector takes its label.
+    s.execute("edit.delete", &json!({"ids": [c]})).unwrap();
+    assert!(!s.doc().unwrap().contains(label));
+    assert!(s.execute("board.connector", &json!({"from": a, "to": a})).is_err());
+}
+
+#[test]
+fn routes_are_the_same_for_the_same_document() {
+    let mut s = board();
+    let a = id(&s.execute("board.shape", &json!({"x": 0, "y": 0})).unwrap(), "id");
+    let c = Connector { from: End::Node { node: a, side: Side::Bottom }, to: End::Point { x: 300.0, y: 500.0 }, routing: Routing::Elbow };
+    let doc = s.doc().unwrap();
+    let r = route(doc, &c).unwrap();
+    assert_eq!(r, route(&doc.clone(), &c).unwrap());
+    // Down out of the bottom, across halfway, down into the point.
+    assert_eq!(r, vec![Point::new(80.0, 160.0), Point::new(80.0, 330.0), Point::new(300.0, 330.0), Point::new(300.0, 500.0)]);
+}
+
+#[test]
+fn stamps_and_ink_and_the_eraser() {
+    let mut s = board();
+    s.prefs.user_name = "Grace".into();
+    let st = id(&s.execute("board.stamp", &json!({"x": 100, "y": 100, "stamp": "heart"})).unwrap(), "id");
+    let n = node(&s, st);
+    assert_eq!(n.board, Some(BoardItem::Stamp { stamp: Stamp::Heart, author: "Grace".into() }));
+    assert_eq!(s.doc().unwrap().world_bounds(st).unwrap().center(), Point::new(100.0, 100.0));
+    assert!(!n.children.is_empty());
+    // Marker and highlighter strokes through the tools; the eraser takes what it touches.
+    let draw = |s: &mut Session, tool: &str, y: f64| {
+        s.execute("tool.set", &json!({"tool": tool})).unwrap();
+        for (k, x) in [(PointerKind::Down, 0.0), (PointerKind::Move, 50.0), (PointerKind::Move, 100.0), (PointerKind::Up, 150.0)] {
+            s.pointer(&PointerEvent::at(k, x, y, 1.0)).unwrap();
+        }
+    };
+    draw(&mut s, "marker", 300.0);
+    draw(&mut s, "highlighter", 400.0);
+    let inks: Vec<Node> = s.doc().unwrap().nodes().filter(|n| n.board == Some(BoardItem::Ink)).cloned().collect();
+    assert_eq!(inks.len(), 2);
+    assert!(inks.iter().any(|n| n.opacity < 1.0 && n.stroke.weight > 10.0), "a highlighter stroke");
+    let undo = s.undo_depth().0;
+    s.execute("tool.eraser", &json!({})).unwrap();
+    for (k, x) in [(PointerKind::Down, 20.0), (PointerKind::Move, 60.0), (PointerKind::Up, 80.0)] {
+        s.pointer(&PointerEvent::at(k, x, 300.0, 1.0)).unwrap();
+    }
+    assert_eq!(s.doc().unwrap().nodes().filter(|n| n.board == Some(BoardItem::Ink)).count(), 1, "the marker stroke is gone");
+    assert_eq!(s.undo_depth().0, undo + 1, "one step");
+    assert_eq!(s.tool.tool, ToolId::Eraser);
+}
+
+#[test]
+fn the_sticky_and_connector_tools() {
+    let mut s = board();
+    s.execute("tool.sticky", &json!({"color": "orange"})).unwrap();
+    s.pointer(&PointerEvent::at(PointerKind::Down, 100.0, 100.0, 1.0)).unwrap();
+    s.pointer(&PointerEvent::at(PointerKind::Up, 100.0, 100.0, 1.0)).unwrap();
+    let te = s.ds().unwrap().text_edit.clone().expect("typing in the new sticky");
+    let a = crate::board::owner_of_text(s.doc().unwrap(), te.id).unwrap();
+    assert_eq!(node(&s, a).fills[0].solid_color(), board_color("orange"));
+    crate::textedit::insert(&mut s, "First").unwrap();
+    crate::textedit::end(&mut s).unwrap();
+    let b = id(&s.execute("board.sticky", &json!({"x": 500, "y": 0})).unwrap(), "id");
+    s.execute("tool.connector", &json!({})).unwrap();
+    s.pointer(&PointerEvent::at(PointerKind::Down, 100.0, 100.0, 1.0)).unwrap();
+    s.pointer(&PointerEvent::at(PointerKind::Move, 300.0, 100.0, 1.0)).unwrap();
+    s.pointer(&PointerEvent::at(PointerKind::Up, 600.0, 100.0, 1.0)).unwrap();
+    let c = s.doc().unwrap().nodes().find(|n| matches!(n.board, Some(BoardItem::Connector(_)))).map(|n| n.id).unwrap();
+    let k = connector(&s, c);
+    assert_eq!((k.from.node(), k.to.node()), (Some(a), Some(b)));
+}
+
+#[test]
+fn boards_sync_in_live_sessions() {
+    let mut s = board();
+    let a = id(&s.execute("board.sticky", &json!({"x": 0, "y": 0, "text": "A"})).unwrap(), "id");
+    let mut room = Room::new(s.doc().unwrap().clone(), 2, 7);
+    assert_eq!(room.s(1).doc().unwrap().kind, FileKind::Board, "joiners get a board");
+    let b = id(&room.s(1).execute("board.sticky", &json!({"x": 400, "y": 0, "text": "B"})).unwrap(), "id");
+    room.settle();
+    let c = id(&room.s(0).execute("board.connector", &json!({"from": a, "to": b})).unwrap(), "id");
+    room.s(1).execute("board.stamp", &json!({"x": 50, "y": 50, "stamp": "star"})).unwrap();
+    room.settle();
+    room.check();
+    // Person 1 moves the sticky person 0 connected: both see the connector follow it.
+    room.s(1).execute("transform.move", &json!({"ids": [b], "dx": 0, "dy": 250})).unwrap();
+    room.s(0).execute("board.setColor", &json!({"ids": [a], "color": "violet"})).unwrap();
+    room.settle();
+    room.check();
+    let doc = room.server.document();
+    let NodeKind::Vector { network } = &doc.node(c).unwrap().kind else { panic!("not a vector") };
+    let end = doc.world_transform(c) * network.vertices.last().unwrap().point();
+    assert_eq!(end, Point::new(400.0, 350.0), "to the moved sticky's facing side");
+    assert_eq!(doc.node(a).unwrap().fills[0].solid_color(), board_color("violet"));
+}
+
+#[test]
+fn board_commands_survive_junk() {
+    let junk = [
+        json!({}),
+        json!(null),
+        json!([1]),
+        json!({"x": "NaN", "y": 1e308, "text": 5, "color": [1], "author": {"x": 1}, "parent": "p"}),
+        json!({"x": -1e308, "y": 0, "color": "neon", "shape": 7, "width": -5, "height": 1e308, "stamp": "skull"}),
+        json!({"from": {"x": "a"}, "to": 99_999, "fromSide": "inside", "style": 3, "startCap": "spike", "endCap": 7, "label": [1]}),
+        json!({"from": {"x": 1e308, "y": -1e308}, "to": {"x": 0, "y": 0}, "style": "elbow", "label": "\u{0}"}),
+        json!({"ids": ["x", -1, 99_999], "color": "#GGG", "fontSize": -1, "side": "up", "edit": "yes"}),
+        json!({"id": 2, "text": "", "path": "M0 0 L", "points": [[1]], "highlighter": "yes"}),
+        json!({"path": "M0 0 L 1e308 1e308", "points": [[0, 0], [1e308, 1]]}),
+    ];
+    let ids: Vec<&str> = crate::cmd::all_commands()
+        .iter()
+        .map(|c| c.id)
+        .filter(|i| {
+            i.starts_with("board.")
+                || ["tool.sticky", "tool.shape", "tool.connector", "tool.marker", "tool.highlighter", "tool.eraser", "tool.stamp", "file.newBoard"]
+                    .contains(i)
+        })
+        .collect();
+    assert!(ids.len() >= 17, "{ids:?}");
+    for cmd in ids {
+        for j in &junk {
+            let mut s = board();
+            let a = s.execute("board.sticky", &json!({"x": 0, "y": 0})).unwrap()["id"].clone();
+            let b = s.execute("board.shape", &json!({"x": 300, "y": 0})).unwrap()["id"].clone();
+            let _ = s.execute("board.connector", &json!({"from": a, "to": b, "label": "x"}));
+            if let Err(EngineError::Internal { cmd, msg }) = s.execute(cmd, j) {
+                panic!("{cmd} panicked on {j}: {msg}");
+            }
+        }
+    }
+    // Every other command on a board with objects on it.
+    for spec in crate::cmd::all_commands() {
+        if spec.id.starts_with("file.") && spec.id != "file.newBoard" || spec.id == "text.rescanFonts" || spec.id == "image.place" {
+            continue;
+        }
+        for j in &junk[..3] {
+            let mut s = board();
+            let a = s.execute("board.sticky", &json!({"x": 0, "y": 0})).unwrap()["id"].clone();
+            let b = s.execute("board.stamp", &json!({"x": 300, "y": 0})).unwrap()["id"].clone();
+            let _ = s.execute("board.connector", &json!({"from": a, "to": b}));
+            if let Err(EngineError::Internal { cmd, msg }) = s.execute(spec.id, j) {
+                panic!("{cmd} panicked on {j}: {msg}");
+            }
+        }
+    }
+}
+
+#[test]
+fn a_press_on_a_stickys_background_picks_and_drags_it() {
+    let mut s = board();
+    let a = id(&s.execute("board.sticky", &json!({"x": 0, "y": 0, "text": "Hi"})).unwrap(), "id");
+    let b = id(&s.execute("board.sticky", &json!({"x": 400, "y": 0})).unwrap(), "id");
+    let c = id(&s.execute("board.connector", &json!({"from": a, "to": b})).unwrap(), "id");
+    s.execute("select.none", &json!({})).unwrap();
+    // Below the note, on the sticky's own fill (a top-level frame's background is the canvas).
+    s.pointer(&PointerEvent::at(PointerKind::Down, 100.0, 150.0, 1.0)).unwrap();
+    s.pointer(&PointerEvent::at(PointerKind::Move, 100.0, 250.0, 1.0)).unwrap();
+    s.pointer(&PointerEvent::at(PointerKind::Move, 100.0, 450.0, 1.0)).unwrap();
+    s.pointer(&PointerEvent::at(PointerKind::Up, 100.0, 450.0, 1.0)).unwrap();
+    assert_eq!(s.selection(), vec![a]);
+    assert_eq!(node(&s, a).transform.translation().y, 300.0);
+    assert!(near(drawn(&s, c)[0], Point::new(200.0, 400.0)), "the connector followed the drag: {:?}", drawn(&s, c));
+}
+
+#[test]
+fn a_copy_of_joined_objects_joins_the_copies() {
+    let mut s = board();
+    let a = id(&s.execute("board.sticky", &json!({"x": 0, "y": 0})).unwrap(), "id");
+    let b = id(&s.execute("board.sticky", &json!({"x": 400, "y": 0})).unwrap(), "id");
+    let c = id(&s.execute("board.connector", &json!({"from": a, "to": b, "label": "x"})).unwrap(), "id");
+    let label = crate::board::label_of(s.doc().unwrap(), c).unwrap();
+    s.execute("edit.duplicate", &json!({"ids": [a, b, c, label]})).unwrap();
+    let copies = s.selection();
+    assert_eq!(copies.len(), 4, "{copies:?}");
+    let k = copies.iter().find_map(|i| match node(&s, *i).board {
+        Some(BoardItem::Connector(k)) => Some(k),
+        _ => None,
+    });
+    let k = k.unwrap();
+    assert!(copies.contains(&k.from.node().unwrap()) && copies.contains(&k.to.node().unwrap()), "{k:?} {copies:?}");
+    // Copy and paste too.
+    s.execute("select.set", &json!({"ids": [a, b, c]})).unwrap();
+    s.execute("edit.copy", &json!({})).unwrap();
+    s.execute("edit.paste", &json!({})).unwrap();
+    let pasted = s.selection();
+    let k = pasted.iter().find_map(|i| match node(&s, *i).board {
+        Some(BoardItem::Connector(k)) => Some(k),
+        _ => None,
+    });
+    let k = k.unwrap();
+    assert!(pasted.contains(&k.from.node().unwrap()) && pasted.contains(&k.to.node().unwrap()), "{k:?} {pasted:?}");
+}
diff --git a/crates/engine/src/board_tools_tests.rs b/crates/engine/src/board_tools_tests.rs
new file mode 100644
index 000000000..4109addad
--- /dev/null
+++ b/crates/engine/src/board_tools_tests.rs
@@ -0,0 +1,277 @@
+//! Boards, continued: copies and pastes (within a file and from another), routes with named sides
+//! and free points, connectors inside moving sections, styles and labels with their refusals, and
+//! the shape, stamp, highlighter and connector tools with double-clicks.
+
+use figcraft_doc::{BoardItem, BoardShape, End, NodeId, Side, Stamp, StrokeCap, board_color};
+use figcraft_geom::Point;
+use serde_json::json;
+
+use crate::Session;
+use crate::board::route;
+use crate::board_tests::{board, connector, drawn, id, near, node};
+use crate::tools::{PointerEvent, PointerKind, ToolId};
+
+/// The connector among `ids`, if any.
+fn connector_in(s: &Session, ids: &[NodeId]) -> Option<figcraft_doc::Connector> {
+    let doc = s.doc().ok()?;
+    ids.iter().find_map(|i| match &doc.node(*i)?.board {
+        Some(BoardItem::Connector(k)) => Some(*k),
+        _ => None,
+    })
+}
+
+#[test]
+fn pasting_into_another_board_detaches_what_was_left_behind() {
+    let mut s = board();
+    let a = id(&s.execute("board.sticky", &json!({"x": 0, "y": 0})).unwrap(), "id");
+    let b = id(&s.execute("board.sticky", &json!({"x": 400, "y": 0})).unwrap(), "id");
+    let r = s.execute("board.connector", &json!({"from": a, "to": b, "style": "straight", "label": "x"})).unwrap();
+    let (c, label) = (id(&r, "id"), id(&r, "label"));
+    let first = s.active;
+    // A second board whose own ids are the same small numbers as the first's.
+    let second = s.execute("file.newBoard", &json!({})).unwrap()["index"].clone();
+    for x in [0, 300, 600, 900] {
+        s.execute("board.sticky", &json!({"x": x, "y": 500})).unwrap();
+    }
+    let others: Vec<NodeId> = s.doc().unwrap().nodes().map(|n| n.id).collect();
+    s.execute("doc.switch", &json!({"index": first})).unwrap();
+    s.execute("select.set", &json!({"ids": [a, c, label]})).unwrap();
+    s.execute("edit.copy", &json!({})).unwrap();
+    s.execute("doc.switch", &json!({"index": second})).unwrap();
+    s.execute("edit.paste", &json!({})).unwrap();
+    let doc = s.doc().unwrap();
+    let pasted = doc.nodes().find(|n| matches!(n.board, Some(BoardItem::Connector(_))) && !others.contains(&n.id)).unwrap().clone();
+    let k = connector(&s, pasted.id);
+    let from = k.from.node().unwrap();
+    assert!(!others.contains(&from) && matches!(doc.node(from).unwrap().board, Some(BoardItem::Sticky { .. })), "joins the pasted sticky");
+    let to = drawn(&s, pasted.id).last().copied().unwrap();
+    assert!(matches!(k.to, End::Point { x, y } if near(Point::new(x, y), to)), "the end left behind stays where it is drawn: {k:?}");
+    let pasted_label = crate::board::label_of(doc, pasted.id).expect("the label came with its connector");
+    assert!(!others.contains(&pasted_label));
+    // A label copied without its connector doesn't come.
+    s.execute("doc.switch", &json!({"index": first})).unwrap();
+    s.execute("select.set", &json!({"ids": [label]})).unwrap();
+    s.execute("edit.copy", &json!({})).unwrap();
+    s.execute("doc.switch", &json!({"index": second})).unwrap();
+    let labels = |s: &Session| s.doc().unwrap().nodes().filter(|n| matches!(n.board, Some(BoardItem::Label { .. }))).count();
+    let before = labels(&s);
+    s.execute("edit.paste", &json!({})).unwrap();
+    assert_eq!(labels(&s), before);
+    // Within its own file, a connector pasted alone stays joined to the same layers.
+    s.execute("doc.switch", &json!({"index": first})).unwrap();
+    s.execute("select.set", &json!({"ids": [c]})).unwrap();
+    s.execute("edit.copy", &json!({})).unwrap();
+    s.execute("edit.paste", &json!({})).unwrap();
+    let k = connector_in(&s, &s.selection()).unwrap();
+    assert_eq!((k.from.node(), k.to.node()), (Some(a), Some(b)));
+}
+
+#[test]
+fn duplicating_and_alt_dragging_keep_connections_inside_copied_sections() {
+    let mut s = board();
+    let sec = id(&s.execute("node.create", &json!({"type": "section", "x": -50, "y": -50, "width": 400, "height": 400})).unwrap(), "id");
+    let a = id(&s.execute("board.sticky", &json!({"x": 50, "y": 50, "parent": sec})).unwrap(), "id");
+    let b = id(&s.execute("board.sticky", &json!({"x": 600, "y": 0})).unwrap(), "id");
+    let c = id(&s.execute("board.connector", &json!({"from": a, "to": b})).unwrap(), "id");
+    s.execute("edit.duplicate", &json!({"ids": [sec, c]})).unwrap();
+    let copies = s.selection();
+    let from = connector_in(&s, &copies).unwrap().from.node().unwrap();
+    let doc = s.doc().unwrap();
+    assert!(from != a && copies.iter().any(|r| doc.is_ancestor(*r, from)), "the copy joins the sticky inside the copied section");
+    // Alt-drag copies the same way.
+    s.execute("select.set", &json!({"ids": [b, c]})).unwrap();
+    let press = |k, x| PointerEvent { alt: true, ..PointerEvent::at(k, x, 100.0, 1.0) };
+    for (k, x) in [(PointerKind::Down, 700.0), (PointerKind::Move, 760.0), (PointerKind::Move, 800.0), (PointerKind::Up, 800.0)] {
+        s.pointer(&press(k, x)).unwrap();
+    }
+    let copies = s.selection();
+    assert_eq!(copies.len(), 2);
+    let k = connector_in(&s, &copies).unwrap();
+    assert!(copies.contains(&k.to.node().unwrap()), "{k:?}");
+}
+
+#[test]
+fn routes_take_named_sides_and_free_points() {
+    let mut s = board();
+    let a = id(&s.execute("board.shape", &json!({"x": 0, "y": 0, "width": 100, "height": 100})).unwrap(), "id");
+    let b = id(&s.execute("board.shape", &json!({"x": 300, "y": 300, "width": 100, "height": 100})).unwrap(), "id");
+    let doc = s.doc().unwrap();
+    let elbow = |from, to| route(doc, &figcraft_doc::Connector { from, to, routing: figcraft_doc::Routing::Elbow }).unwrap();
+    let side = |n, side| End::Node { node: n, side };
+    let p = |x, y| End::Point { x, y };
+    let pt = Point::new;
+    // Side to side: out, across halfway, in.
+    assert_eq!(elbow(side(a, Side::Right), side(b, Side::Left)), vec![pt(100.0, 50.0), pt(200.0, 50.0), pt(200.0, 350.0), pt(300.0, 350.0)]);
+    // A side and a top or bottom: one turn.
+    assert_eq!(elbow(side(a, Side::Right), side(b, Side::Top)), vec![pt(100.0, 50.0), pt(350.0, 50.0), pt(350.0, 300.0)]);
+    assert_eq!(elbow(side(a, Side::Bottom), side(b, Side::Left)), vec![pt(50.0, 100.0), pt(50.0, 350.0), pt(300.0, 350.0)]);
+    // Two free points: the longer way first; in a line, no turns.
+    assert_eq!(elbow(p(0.0, 0.0), p(100.0, 40.0)), vec![pt(0.0, 0.0), pt(50.0, 0.0), pt(50.0, 40.0), pt(100.0, 40.0)]);
+    assert_eq!(elbow(p(0.0, 0.0), p(100.0, 0.0)), vec![pt(0.0, 0.0), pt(100.0, 0.0)]);
+    // An automatic side faces the other end.
+    let straight = route(doc, &figcraft_doc::Connector { from: side(a, Side::Auto), to: p(50.0, 500.0), routing: figcraft_doc::Routing::Straight });
+    assert_eq!(straight.unwrap(), vec![pt(50.0, 100.0), pt(50.0, 500.0)]);
+    assert_eq!(Side::from_id("TOP"), Some(Side::Top));
+    assert_eq!(Side::from_id("inside"), None);
+    // The same place twice is refused, as are a side that doesn't exist and a point without numbers.
+    assert!(s.execute("board.connector", &json!({"from": {"x": 5, "y": 5}, "to": {"x": 5, "y": 5}})).is_err());
+    assert!(s.execute("board.connector", &json!({"from": a, "to": b, "fromSide": "inside"})).is_err());
+    assert!(s.execute("board.connector", &json!({"from": a, "to": {"x": "a"}})).is_err());
+    assert!(s.execute("board.connector", &json!({"from": a})).is_err());
+}
+
+#[test]
+fn a_connector_follows_a_layer_whose_section_moves_and_ignores_unrelated_edits() {
+    let mut s = board();
+    let sec = id(&s.execute("node.create", &json!({"type": "section", "x": 0, "y": 0, "width": 300, "height": 300})).unwrap(), "id");
+    let a = id(&s.execute("board.sticky", &json!({"x": 50, "y": 50, "parent": sec})).unwrap(), "id");
+    let b = id(&s.execute("board.stamp", &json!({"x": 800, "y": 150})).unwrap(), "id");
+    let c = id(&s.execute("board.connector", &json!({"from": a, "to": b, "style": "straight"})).unwrap(), "id");
+    assert!(near(drawn(&s, c)[0], Point::new(250.0, 150.0)));
+    // Only the section is edited; the sticky inside it moves with it, and so does the connector.
+    s.execute("transform.move", &json!({"ids": [sec], "dx": 0, "dy": 100})).unwrap();
+    assert!(near(drawn(&s, c)[0], Point::new(250.0, 250.0)), "{:?}", drawn(&s, c));
+    // An edit that touches neither end leaves the connector as it was.
+    let before = s.doc().unwrap().node_arc(c).cloned().unwrap();
+    s.execute("board.sticky", &json!({"x": 0, "y": 900})).unwrap();
+    assert!(std::sync::Arc::ptr_eq(&before, s.doc().unwrap().node_arc(c).unwrap()));
+}
+
+#[test]
+fn styles_labels_and_their_refusals() {
+    let mut s = board();
+    let a = id(&s.execute("board.sticky", &json!({"x": 0, "y": 0, "author": false})).unwrap(), "id");
+    assert_eq!(node(&s, a).children.len(), 1, "no author line");
+    let b = id(&s.execute("board.sticky", &json!({"x": 400, "y": 0, "author": "  Lin  "})).unwrap(), "id");
+    assert!(matches!(node(&s, b).board, Some(BoardItem::Sticky { ref author }) if author == "Lin"));
+    let c = id(&s.execute("board.connector", &json!({"from": a, "to": b, "startCap": "circleFilled", "endCap": "none"})).unwrap(), "id");
+    assert_eq!((node(&s, c).stroke.cap_start, node(&s, c).stroke.cap_end), (StrokeCap::CircleFilled, StrokeCap::None));
+    // Labels: set, change, size, remove; named by the label itself too.
+    let l = id(&s.execute("board.label", &json!({"id": c, "text": "first"})).unwrap(), "label");
+    assert_eq!(id(&s.execute("board.label", &json!({"id": l, "text": "second"})).unwrap(), "label"), l, "the same label, new text");
+    let text = crate::board::text_of(s.doc().unwrap(), l).unwrap();
+    assert_eq!(node(&s, text).kind.text().unwrap().characters, "second");
+    s.execute("board.setStyle", &json!({"ids": [l], "fontSize": 36})).unwrap();
+    assert_eq!(node(&s, text).kind.text().unwrap().style.font_size, 36.0);
+    assert!(s.execute("board.label", &json!({"id": c, "text": ""})).unwrap()["label"].is_null());
+    assert!(!s.doc().unwrap().contains(l));
+    // What doesn't take a style or colour says so.
+    assert!(s.execute("board.setStyle", &json!({"ids": [a], "fontSize": 30})).is_err(), "stickies size their own text");
+    assert!(s.execute("board.setStyle", &json!({"ids": [c], "fontSize": 0})).is_err());
+    let st = id(&s.execute("board.stamp", &json!({"x": 0, "y": 0, "stamp": "check"})).unwrap(), "id");
+    assert!(s.execute("board.setColor", &json!({"ids": [st], "color": "blue"})).is_err());
+    assert!(s.execute("board.setColor", &json!({"ids": [a]})).is_err());
+    assert!(s.execute("board.label", &json!({"id": a, "text": "x"})).is_err());
+    // A palette colour on a line draws in its deeper shade; a hex colour as given.
+    s.execute("board.setColor", &json!({"ids": [c], "color": "blue"})).unwrap();
+    assert!(node(&s, c).strokes[0].solid_color().is_some() && node(&s, c).strokes[0].solid_color() != board_color("blue"));
+    s.execute("board.setColor", &json!({"ids": [c], "color": "#123456"})).unwrap();
+    assert_eq!(node(&s, c).strokes[0].solid_color().map(|c| c.to_hex()), Some("123456".into()));
+    // Next stickies on each side, and refusals.
+    for (side, dx, dy) in [("below", 0.0, 224.0), ("left", -224.0, 0.0), ("above", 0.0, -224.0)] {
+        let n = id(&s.execute("board.nextSticky", &json!({"id": a, "side": side})).unwrap(), "id");
+        let t = node(&s, n).transform.translation();
+        assert_eq!((t.x, t.y), (dx, dy), "{side}");
+    }
+    assert!(s.execute("board.nextSticky", &json!({"id": a, "side": "diagonal"})).is_err());
+    assert!(s.execute("board.nextSticky", &json!({"id": c})).is_err());
+    assert!(s.execute("board.ink", &json!({})).is_err());
+    assert!(s.execute("board.sticky", &json!({"x": 0, "y": 0, "parent": c})).is_err(), "a connector holds no layers");
+}
+
+#[test]
+fn the_shape_stamp_highlighter_and_connector_tools_and_double_clicks() {
+    let mut s = board();
+    let click = |s: &mut Session, x, y| {
+        s.pointer(&PointerEvent::at(PointerKind::Down, x, y, 1.0)).unwrap();
+        s.pointer(&PointerEvent::at(PointerKind::Up, x, y, 1.0)).unwrap();
+    };
+    s.execute("tool.shape", &json!({"shape": "roundedRectangle"})).unwrap();
+    click(&mut s, 100.0, 100.0);
+    let sh = s.selection()[0];
+    assert_eq!(node(&s, sh).board, Some(BoardItem::Shape { shape: BoardShape::RoundedRectangle }));
+    assert_eq!(s.tool.tool, ToolId::Move, "back to Move after placing");
+    s.execute("tool.stamp", &json!({"stamp": "question"})).unwrap();
+    click(&mut s, 400.0, 100.0);
+    click(&mut s, 450.0, 100.0);
+    let stamps = s.doc().unwrap().nodes().filter(|n| matches!(n.board, Some(BoardItem::Stamp { stamp: Stamp::Question, .. }))).count();
+    assert_eq!(stamps, 2);
+    assert_eq!(s.tool.tool, ToolId::Stamp, "stamps go on one after another");
+    assert!(s.execute("tool.stamp", &json!({"stamp": "skull"})).is_err());
+    s.execute("tool.highlighter", &json!({"color": "pink"})).unwrap();
+    assert_eq!(Some(s.tool.board.highlighter), board_color("pink"));
+    s.execute("tool.marker", &json!({"color": "#336699"})).unwrap();
+    assert_eq!(s.tool.board.marker.to_hex(), "336699");
+    // A connector drag that is only a click, or from an object to itself, makes nothing.
+    s.execute("tool.connector", &json!({"style": "straight"})).unwrap();
+    click(&mut s, 100.0, 100.0);
+    s.pointer(&PointerEvent::at(PointerKind::Down, 60.0, 120.0, 1.0)).unwrap();
+    s.pointer(&PointerEvent::at(PointerKind::Move, 100.0, 140.0, 1.0)).unwrap();
+    assert!(s.tool.overlay.rubber.is_some(), "the rubber band shows while dragging");
+    s.pointer(&PointerEvent::at(PointerKind::Up, 100.0, 140.0, 1.0)).unwrap();
+    assert!(!s.doc().unwrap().nodes().any(|n| matches!(n.board, Some(BoardItem::Connector(_)))));
+    // From the shape out to empty canvas: a connector to a free point.
+    s.pointer(&PointerEvent::at(PointerKind::Down, 80.0, 140.0, 1.0)).unwrap();
+    s.pointer(&PointerEvent::at(PointerKind::Up, 80.0, 600.0, 1.0)).unwrap();
+    let c = s.doc().unwrap().nodes().find(|n| matches!(n.board, Some(BoardItem::Connector(_)))).map(|n| n.id).unwrap();
+    assert!(matches!(connector(&s, c).to, End::Point { .. }));
+    // Double-clicks: on the shape its text, on the connector a new label, both typed into.
+    s.execute("tool.move", &json!({})).unwrap();
+    s.execute("select.none", &json!({})).unwrap();
+    s.pointer(&PointerEvent::at(PointerKind::DoubleClick, 80.0, 140.0, 1.0)).unwrap();
+    let te = s.ds().unwrap().text_edit.clone().expect("typing in the shape");
+    assert_eq!(crate::board::owner_of_text(s.doc().unwrap(), te.id), Some(sh));
+    crate::textedit::end(&mut s).unwrap();
+    let line = drawn(&s, c);
+    let m = line[0].midpoint(line[1]);
+    s.pointer(&PointerEvent::at(PointerKind::DoubleClick, m.x, m.y, 1.0)).unwrap();
+    let label = crate::board::label_of(s.doc().unwrap(), c).expect("a label was added");
+    let te = s.ds().unwrap().text_edit.clone().expect("typing in the label");
+    assert_eq!(crate::board::owner_of_text(s.doc().unwrap(), te.id), Some(label));
+}
+
+#[test]
+fn an_ink_stroke_ends_where_the_button_comes_up() {
+    let mut s = board();
+    s.execute("tool.marker", &json!({})).unwrap();
+    // Down and up with no move between: the stroke still runs from the press to the release.
+    s.pointer(&PointerEvent::at(PointerKind::Down, 0.0, 0.0, 1.0)).unwrap();
+    s.pointer(&PointerEvent::at(PointerKind::Up, 150.0, 0.0, 1.0)).unwrap();
+    let doc = s.doc().unwrap();
+    let ink = doc.nodes().find(|n| matches!(n.board, Some(BoardItem::Ink))).map(|n| n.id).expect("a stroke");
+    let b = doc.world_bounds(ink).unwrap();
+    assert!(b.x0.abs() < 6.0 && (b.x1 - 150.0).abs() < 6.0, "from 0 to 150 (stroke width aside): {b:?}");
+}
+
+#[test]
+fn a_second_sticky_ends_the_first_ones_typing_and_undoes_alone() {
+    let mut s = board();
+    s.execute("tool.sticky", &json!({})).unwrap();
+    s.prefs.keep_tool = true;
+    s.pointer(&PointerEvent::at(PointerKind::Down, 100.0, 100.0, 1.0)).unwrap();
+    s.pointer(&PointerEvent::at(PointerKind::Up, 100.0, 100.0, 1.0)).unwrap();
+    let text = s.ds().unwrap().text_edit.as_ref().expect("typing in the new sticky").id;
+    crate::textedit::insert(&mut s, "first note").unwrap();
+    s.pointer(&PointerEvent::at(PointerKind::Down, 500.0, 100.0, 1.0)).unwrap();
+    s.pointer(&PointerEvent::at(PointerKind::Up, 500.0, 100.0, 1.0)).unwrap();
+    let stickies = |s: &Session| s.doc().unwrap().nodes().filter(|n| matches!(n.board, Some(BoardItem::Sticky { .. }))).count();
+    let typed = |s: &Session| s.doc().unwrap().node(text).unwrap().kind.text().unwrap().characters.clone();
+    assert_eq!(stickies(&s), 2);
+    crate::textedit::end(&mut s).unwrap();
+    s.undo().unwrap();
+    assert_eq!(stickies(&s), 1, "the second sticky is its own undo step");
+    assert_eq!(typed(&s), "first note", "the first sticky keeps what was typed in it");
+}
+
+#[test]
+fn a_board_tool_left_on_presses_as_move_in_a_design_file() {
+    let mut s = board();
+    s.execute("tool.sticky", &json!({})).unwrap();
+    s.execute("file.new", &json!({})).unwrap();
+    let r = id(&s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 100, "height": 100})).unwrap(), "id");
+    s.execute("select.none", &json!({})).unwrap();
+    s.pointer(&PointerEvent::at(PointerKind::Down, 50.0, 50.0, 1.0)).unwrap();
+    s.pointer(&PointerEvent::at(PointerKind::Up, 50.0, 50.0, 1.0)).unwrap();
+    assert_eq!(s.tool.tool, ToolId::Move);
+    assert_eq!(s.selection(), vec![r], "the press selected as Move does");
+}
diff --git a/crates/engine/src/booleans.rs b/crates/engine/src/booleans.rs
index 87d901533..c3de51cbe 100644
--- a/crates/engine/src/booleans.rs
+++ b/crates/engine/src/booleans.rs
@@ -124,7 +124,7 @@ pub(crate) fn apply(s: &mut Session, cmd: &str, p: &Value, op: BoolOp) -> Result
         }
         return Ok(json!({"ids": ids, "operation": op}));
     }
-    let out = crate::cmd::structure::wrap_boolean(s, p, op)?;
+    let out = crate::cmd::structure::wrap_boolean(s, p, cmd, op)?;
     // Operands of a new group follow its operation.
     if let Some(g) = crate::params::id_of(&out["id"]) {
         let doc = s.doc_mut()?;
diff --git a/crates/engine/src/bound_alpha_tests.rs b/crates/engine/src/bound_alpha_tests.rs
new file mode 100644
index 000000000..c54f0fb7b
--- /dev/null
+++ b/crates/engine/src/bound_alpha_tests.rs
@@ -0,0 +1,153 @@
+//! A colour variable's alpha applies once to the paint it is bound to (#802): a `#RRGGBBAA` fill keeps
+//! its alpha in the paint opacity, and binding a variable with alpha hands the variable the whole
+//! colour, so the two alphas don't multiply (canvas, SVG, `.fig` round trips, mode switches).
+
+use figcraft_doc::NodeId;
+use serde_json::json;
+
+use crate::Session;
+
+/// 0x80 / 255 and 0x40 / 255.
+const HALF: f32 = 128.0 / 255.0;
+const QUARTER: f32 = 64.0 / 255.0;
+
+fn ex(s: &mut Session, cmd: &str, p: serde_json::Value) {
+    s.execute(cmd, &p).unwrap_or_else(|e| panic!("{cmd}: {e}"));
+}
+
+/// A rectangle filled `#0D6EFD80` and a colour variable `tint` (Light `light`, Dark `dark`).
+fn setup(light: &str, dark: &str) -> (Session, NodeId) {
+    let mut s = Session::new();
+    let r = s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 10, "height": 10, "props": {"fill": "#0D6EFD80"}})).unwrap();
+    let r = NodeId(r["id"].as_u64().unwrap());
+    ex(&mut s, "variable.createCollection", json!({"name": "Tokens", "modes": ["Light", "Dark"]}));
+    ex(&mut s, "variable.create", json!({"collection": "Tokens", "name": "tint", "type": "color", "value": light}));
+    ex(&mut s, "variable.set", json!({"variable": "tint", "mode": "Dark", "value": dark}));
+    (s, r)
+}
+
+/// The fill's effective alpha (colour alpha times paint opacity).
+fn alpha(s: &Session, r: NodeId) -> f32 {
+    s.doc().unwrap().node(r).unwrap().fills[0].solid_color().unwrap().a
+}
+
+/// The alpha byte of the rectangle rendered on its own (transparent backdrop).
+fn pixel_alpha(s: &Session, r: NodeId) -> u8 {
+    let pix = figcraft_render::render_node(s.doc().unwrap(), r, 1.0).unwrap();
+    let i = ((5 * pix.width() + 5) * 4 + 3) as usize;
+    pix.data()[i]
+}
+
+fn near(a: f32, b: f32) -> bool {
+    (a - b).abs() < 2e-3
+}
+
+#[test]
+fn a_hex_with_alpha_keeps_its_alpha_in_the_opacity() {
+    let (s, r) = setup("#0D6EFD80", "#0D6EFD40");
+    let p = &s.doc().unwrap().node(r).unwrap().fills[0];
+    assert_eq!(p.kind, figcraft_color::PaintKind::Solid { color: figcraft_color::Color::from_rgb8_const(0x0D, 0x6E, 0xFD) });
+    assert!(near(p.opacity, HALF));
+    assert_eq!(pixel_alpha(&s, r), 128);
+}
+
+#[test]
+fn a_bound_variable_alpha_applies_once() {
+    // The fill and the variable are both #0D6EFD80: the result is 50%, not 25%.
+    let (mut s, r) = setup("#0D6EFD80", "#0D6EFD40");
+    ex(&mut s, "variable.bind", json!({"ids": [r.0], "field": "fill", "variable": "tint"}));
+    assert!(near(alpha(&s, r), HALF), "{}", alpha(&s, r));
+    assert_eq!(pixel_alpha(&s, r), 128);
+    let svg = figcraft_svg::export_svg(s.doc().unwrap(), &[r], &figcraft_svg::SvgOptions::default()).unwrap();
+    assert!(svg.contains("fill=\"#0D6EFD\" fill-opacity=\"0.502\""), "{svg}");
+    // Binding the same variable again changes nothing.
+    ex(&mut s, "variable.bind", json!({"ids": [r.0], "field": "fill", "variable": "tint"}));
+    assert!(near(alpha(&s, r), HALF));
+}
+
+#[test]
+fn unbinding_keeps_the_colour_with_its_alpha_in_the_opacity() {
+    let (mut s, r) = setup("#0D6EFD40", "#0D6EFD");
+    ex(&mut s, "variable.bind", json!({"ids": [r.0], "field": "fill", "variable": "tint"}));
+    assert_eq!(pixel_alpha(&s, r), 64);
+    ex(&mut s, "variable.bind", json!({"ids": [r.0], "field": "fill", "variable": null}));
+    let p = &s.doc().unwrap().node(r).unwrap().fills[0];
+    assert_eq!(p.kind, figcraft_color::PaintKind::Solid { color: figcraft_color::Color::from_rgb8_const(0x0D, 0x6E, 0xFD) });
+    assert!(near(p.opacity, QUARTER), "{}", p.opacity);
+    assert_eq!(pixel_alpha(&s, r), 64);
+    // Undo restores the binding and its paint.
+    ex(&mut s, "edit.undo", json!({}));
+    assert!(!s.doc().unwrap().node(r).unwrap().bound.is_empty());
+    assert_eq!(pixel_alpha(&s, r), 64);
+}
+
+#[test]
+fn modes_switch_the_alpha_without_accumulating() {
+    let (mut s, r) = setup("#0D6EFD40", "#0D6EFD80");
+    ex(&mut s, "variable.bind", json!({"ids": [r.0], "field": "fill", "variable": "tint"}));
+    for (mode, want) in [("Dark", HALF), ("Light", QUARTER), ("Dark", HALF), ("Light", QUARTER)] {
+        ex(&mut s, "variable.setMode", json!({"collection": "Tokens", "mode": mode}));
+        assert!(near(alpha(&s, r), want), "{mode}: {}", alpha(&s, r));
+    }
+    // An opacity set while bound multiplies on top and survives mode switches.
+    ex(&mut s, "fill.set", json!({"ids": [r.0], "index": 0, "opacity": 0.5}));
+    ex(&mut s, "variable.setMode", json!({"collection": "Tokens", "mode": "Dark"}));
+    assert!(near(alpha(&s, r), HALF * 0.5));
+}
+
+#[test]
+fn node_set_and_style_bindings_apply_the_alpha_once() {
+    let (mut s, r) = setup("#0D6EFD80", "#0D6EFD40");
+    let var = s.doc().unwrap().variables.get("tint").unwrap().id.clone();
+    ex(&mut s, "node.set", json!({"id": r.0, "props": {"boundVariables": {"fill": var}}}));
+    assert!(near(alpha(&s, r), HALF));
+    ex(&mut s, "node.set", json!({"id": r.0, "props": {"boundVariables": {"fill": null}}}));
+    assert!(near(s.doc().unwrap().node(r).unwrap().fills[0].opacity, HALF));
+    // A paint style made from a `#RRGGBBAA` colour, bound to the variable.
+    let st = s.execute("style.create", &json!({"type": "paint", "name": "Tint", "value": "#0D6EFD80"})).unwrap()["id"].clone();
+    ex(&mut s, "style.bind", json!({"style": st, "field": "fills/0/color", "variable": "tint"}));
+    ex(&mut s, "style.apply", json!({"ids": [r.0], "style": st}));
+    assert!(near(alpha(&s, r), HALF), "{}", alpha(&s, r));
+}
+
+#[test]
+fn a_fig_round_trip_keeps_the_alpha_once() {
+    let (mut s, r) = setup("#0D6EFD80", "#0D6EFD40");
+    ex(&mut s, "variable.bind", json!({"ids": [r.0], "field": "fill", "variable": "tint"}));
+    ex(&mut s, "fill.set", json!({"ids": [r.0], "index": 0, "opacity": 0.5}));
+    let (bytes, _) = figcraft_format::fig::export(s.doc().unwrap(), None).unwrap();
+    let back = crate::cmd::file::load_fig(&bytes, "x").unwrap().unwrap().doc;
+    let n = back.nodes().find(|n| !n.bound.is_empty()).unwrap();
+    let a = n.fills[0].solid_color().unwrap().a;
+    assert!(near(a, HALF * 0.5), "{a}");
+}
+
+#[test]
+fn code_gives_a_translucent_stroke_its_alpha_once() {
+    let (mut s, r) = setup("#0D6EFD80", "#0D6EFD40");
+    ex(&mut s, "stroke.add", json!({"ids": [r.0], "color": "#FF000080"}));
+    let code = s.execute("inspect.code", &json!({"id": r.0})).unwrap()["code"].as_str().unwrap_or_default().to_string();
+    assert!(code.contains("solid rgba(255, 0, 0, 0.50)"), "{code}");
+}
+
+#[test]
+fn binding_keeps_an_opacity_set_on_the_paint() {
+    // A 15% tint whose colour comes from a variable (#923): the bind replaces the colour only.
+    let mut s = Session::new();
+    ex(&mut s, "variable.createCollection", json!({"name": "Tokens", "modes": ["Light"]}));
+    ex(&mut s, "variable.create", json!({"collection": "Tokens", "name": "red", "type": "color", "value": "#FF0000"}));
+    let props = json!({"fills": [{"type": "solid", "color": "#000000", "opacity": 0.15}]});
+    let r = s.execute("node.create", &json!({"type": "rectangle", "x": 0, "y": 0, "width": 10, "height": 10, "props": props})).unwrap();
+    let r = NodeId(r["id"].as_u64().unwrap());
+    ex(&mut s, "variable.bind", json!({"ids": [r.0], "field": "fill", "variable": "red"}));
+    let p = s.doc().unwrap().node(r).unwrap().fills[0].clone();
+    assert_eq!(p.kind, figcraft_color::PaintKind::Solid { color: figcraft_color::Color::from_rgb8_const(0xFF, 0, 0) });
+    assert!(near(p.opacity, 0.15), "{}", p.opacity);
+    ex(&mut s, "variable.bind", json!({"ids": [r.0], "field": "fill", "variable": null}));
+    assert!(near(s.doc().unwrap().node(r).unwrap().fills[0].opacity, 0.15));
+    // An opacity set on a `#RRGGBBAA` fill is the user's too, and stays.
+    let (mut s, r) = setup("#FF0000", "#FF0000");
+    ex(&mut s, "fill.set", json!({"ids": [r.0], "index": 0, "opacity": 0.25}));
+    ex(&mut s, "variable.bind", json!({"ids": [r.0], "field": "fill", "variable": "tint"}));
+    assert!(near(alpha(&s, r), 0.25), "{}", alpha(&s, r));
+}
diff --git a/crates/engine/src/catalog.rs b/crates/engine/src/catalog.rs
index c8f34fc15..5180b3400 100644
--- a/crates/engine/src/catalog.rs
+++ b/crates/engine/src/catalog.rs
@@ -21,8 +21,9 @@ pub const SEP: &str = "-";
 pub static MENU: &[MenuItem] = &[
     // File
     m!("File", "New design file", "file.new"),
-    // FigCraft's own: starter templates (not counted by `parity`, like the other items of its own
-    // listed in `OWN`).
+    m!("File", "New board", "file.newBoard"),
+    // FigCraft's own: boards and starter templates (not counted by `parity`, like the other items
+    // of its own listed in `OWN`).
     m!("File", "New from template…", "file.newFromTemplate"),
     m!("File", "New window", "window.new"),
     m!("File", "Open…", "file.open"),
@@ -213,6 +214,8 @@ pub static MENU: &[MenuItem] = &[
     m!("Text/Case", "Uppercase", "text.caseUpper"),
     m!("Text/Case", "Lowercase", "text.caseLower"),
     m!("Text/Case", "Title case", "text.caseTitle"),
+    m!("Text", SEP, ""),
+    m!("Text", "Missing fonts…", "text.missingFonts"),
     // Arrange
     m!("Arrange", "Align left", "align.left"),
     m!("Arrange", "Align horizontal centers", "align.hcenter"),
@@ -287,7 +290,7 @@ pub fn items() -> impl Iterator<Item = &'static MenuItem> {
 }
 
 /// Items of FigCraft's own that the parity count leaves out (as it does the `collab.` ones).
-const OWN: [&str; 2] = ["file.newFromTemplate", "help.gettingStarted"];
+const OWN: [&str; 4] = ["file.newFromTemplate", "file.newBoard", "help.gettingStarted", "text.missingFonts"];
 
 /// Coverage: (implemented, total, missing ids). `extra` lists ids implemented by the UI layer.
 pub fn parity(extra: &[&str]) -> (usize, usize, Vec<&'static str>) {
diff --git a/crates/engine/src/cmd/arrange.rs b/crates/engine/src/cmd/arrange.rs
index 43cfcf3c0..10ad13e54 100644
--- a/crates/engine/src/cmd/arrange.rs
+++ b/crates/engine/src/cmd/arrange.rs
@@ -19,7 +19,21 @@ pub fn specs() -> Vec<CommandSpec> {
         spec!("align.bottom", "Align bottom", "{ids?}", true, |s, p| align(s, p, Al::Bottom)),
         spec!("distribute.horizontal", "Distribute horizontal spacing", "{ids?, spacing?}", true, |s, p| distribute(s, p, true)),
         spec!("distribute.vertical", "Distribute vertical spacing", "{ids?, spacing?}", true, |s, p| distribute(s, p, false)),
+        spec!(
+            "arrange.spacing",
+            "Spacing",
+            "{ids?, horizontal?, vertical?, fromGesture?} (page units; fromGesture uses the interaction snapshot)",
+            true,
+            spacing
+        ),
         spec!("arrange.tidy", "Tidy up", "{ids?, spacing?}", true, tidy),
+        spec!(
+            "arrange.reorder",
+            "Reorder selection",
+            "{ids?, source, target, swap?, fromGesture?} (insert at target's visual slot; no hierarchy changes)",
+            true,
+            reorder
+        ),
         spec!("arrange.packH", "Pack horizontal", "{ids?}", true, |s, p| pack(s, p, true)),
         spec!("arrange.packV", "Pack vertical", "{ids?}", true, |s, p| pack(s, p, false)),
         spec!("arrange.roundToPixels", "Round to pixels", "{ids?}", true, round_px),
@@ -521,6 +535,7 @@ pub(crate) fn resize_cmd(s: &mut Session, p: &Value) -> Result<Value> {
     let (col, row) = string(p, "anchor").and_then(|a| crate::tools::anchor_of(&a)).unwrap_or((0, 0));
     let (ax, ay) = (f64::from(col) / 2.0, f64::from(row) / 2.0);
     let doc = s.doc_mut()?;
+    let before = super::styles::bound_before(doc, &ids);
     for i in ids {
         let n = doc.get(i)?;
         let (ow, oh) = (n.width, n.height);
@@ -544,5 +559,98 @@ pub(crate) fn resize_cmd(s: &mut Session, p: &Value) -> Result<Value> {
         }
         super::props::restore_worlds(doc, &kept)?;
     }
+    super::styles::detach_edited(doc, &before);
+    ok()
+}
+
+/// Reorder visual slots without rebuilding or reparenting layers.
+fn reorder(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "arrange.reorder";
+    let ids = req_targets(cmd, s, p)?;
+    let source = req_id(cmd, p, "source")?;
+    let target = req_id(cmd, p, "target")?;
+    let ds = s.ds()?;
+    let base = ds.interaction.as_ref().filter(|_| boolean(p, "fromGesture") == Some(true)).map(|i| i.doc.clone()).unwrap_or_else(|| ds.doc.clone());
+    let layout =
+        crate::selection_reorder::ReorderLayout::new(&base, &ids).ok_or_else(|| bad(cmd, "select a regular row, column or complete aligned grid"))?;
+    let positions = layout
+        .positions(source, target, boolean(p, "swap") == Some(true))
+        .ok_or_else(|| bad(cmd, "source and target must belong to the selection"))?;
+    // Validate every delta before editing; absolute targets always come from the gesture's
+    // snapshot so crossing several slots and returning to the start does not accumulate edits.
+    let doc = s.doc()?;
+    let mut moves = Vec::new();
+    for (id, at) in positions {
+        let now = doc.world_bounds(id).ok_or_else(|| bad(cmd, "layer is no longer available"))?;
+        let (dx, dy) = (at.x - now.x0, at.y - now.y0);
+        if !dx.is_finite() || !dy.is_finite() {
+            return Err(bad(cmd, "non-finite reorder result"));
+        }
+        if dx.abs() > 1e-9 || dy.abs() > 1e-9 {
+            let node = doc.get(id)?;
+            let parent = node.parent.map(|p| doc.world_transform(p)).unwrap_or(Affine::IDENTITY);
+            let transform = parent.inverse() * Affine::translate((dx, dy)) * parent * node.transform;
+            if !transform.as_coeffs().iter().all(|v| v.is_finite()) {
+                return Err(bad(cmd, "non-finite local transform"));
+            }
+            moves.push((id, dx, dy));
+        }
+    }
+    if !moves.is_empty() {
+        let doc = s.doc_mut()?;
+        for (id, dx, dy) in moves {
+            move_world(doc, id, dx, dy)?;
+        }
+    }
+    ok()
+}
+
+/// Set the distances between smart-selection tracks without rebuilding/reparenting the layers.
+fn spacing(s: &mut Session, p: &Value) -> Result<Value> {
+    let ids = req_targets("arrange.spacing", s, p)?;
+    // A scrub is absolute from the interaction snapshot, even if tracks overlap or cross.
+    let ds = s.ds()?;
+    let base = ds.interaction.as_ref().filter(|_| boolean(p, "fromGesture") == Some(true)).map(|i| i.doc.clone()).unwrap_or_else(|| ds.doc.clone());
+    let layout = crate::selection_spacing::selection_spacing(&base, &ids);
+    let mut offsets = std::collections::BTreeMap::<NodeId, (Option<f64>, Option<f64>)>::new();
+    let mut any = false;
+    for (key, axis, vertical) in [("horizontal", &layout.horizontal, false), ("vertical", &layout.vertical, true)] {
+        if get(p, key).is_none() {
+            continue;
+        }
+        let value = req_num("arrange.spacing", p, key)?;
+        if value.abs() > 1_000_000.0 {
+            return Err(bad("arrange.spacing", "spacing out of range"));
+        }
+        let axis = axis.as_ref().ok_or_else(|| bad("arrange.spacing", "selection has no spacing on this axis"))?;
+        any = true;
+        for (id, delta) in axis.offsets(value) {
+            if !delta.is_finite() {
+                return Err(bad("arrange.spacing", "non-finite spacing result"));
+            }
+            let pair = offsets.entry(id).or_default();
+            if vertical {
+                pair.1 = Some(delta);
+            } else {
+                pair.0 = Some(delta);
+            }
+        }
+    }
+    if !any {
+        return Err(bad("arrange.spacing", "pass horizontal or vertical spacing"));
+    }
+    let doc = s.doc_mut()?;
+    let mut moves = Vec::new();
+    for (id, (dx, dy)) in offsets {
+        let (Some(before), Some(now)) = (base.world_bounds(id), doc.world_bounds(id)) else { continue };
+        let (dx, dy) = (dx.map_or(0.0, |d| before.x0 + d - now.x0), dy.map_or(0.0, |d| before.y0 + d - now.y0));
+        if !dx.is_finite() || !dy.is_finite() {
+            return Err(bad("arrange.spacing", "non-finite spacing result"));
+        }
+        moves.push((id, dx, dy));
+    }
+    for (id, dx, dy) in moves {
+        move_world(doc, id, dx, dy)?;
+    }
     ok()
 }
diff --git a/crates/engine/src/cmd/component.rs b/crates/engine/src/cmd/component.rs
index 0fb648167..01914640a 100644
--- a/crates/engine/src/cmd/component.rs
+++ b/crates/engine/src/cmd/component.rs
@@ -56,11 +56,17 @@ pub fn specs() -> Vec<CommandSpec> {
             s.set_selection(out.iter().filter_map(id_of).collect());
             Ok(json!({"ids": out}))
         }),
-        spec!("component.combineVariants", "Combine as variants", "{ids? (components)}", true, combine),
+        spec!(
+            "component.combineVariants",
+            "Combine as variants",
+            "{ids? (main components; none already a variant, a library copy or inside an instance)}  (wraps them in a new component set; names without `=` become \"Property 1=Default\", \"Property 1=VariantN\")",
+            true,
+            combine
+        ),
         spec!(
             "component.addVariant",
             "Add variant",
-            "{id? (component set or variant), property?, value?}  (duplicates the variant; `property`=`value` names the new one)",
+            "{id? (component set, variant, or a main component not in a set yet: it becomes a set of itself and the new variant), property?, value?}  (duplicates the variant; `property`=`value` names the new one)",
             true,
             add_variant
         ),
@@ -68,7 +74,7 @@ pub fn specs() -> Vec<CommandSpec> {
             let cmd = "instance.create";
             let c = req_id(cmd, p, "component")?;
             let page = s.page()?;
-            let parent = id(p, "parent").unwrap_or(page);
+            let parent = crate::params::opt_id(cmd, p, "parent")?.unwrap_or(page);
             let doc = s.doc_mut()?;
             let c = main_of(doc, c).ok_or_else(|| bad(cmd, "`component` must be a component or component set"))?;
             let (x, y) = match (num(p, "x"), num(p, "y")) {
@@ -159,7 +165,7 @@ pub fn specs() -> Vec<CommandSpec> {
         spec!(
             "component.resetOverride",
             "Reset override",
-            "{id?, group? (fills|strokes|effects|opacity|visible|name|corners|characters|textStyle|padding|gap|alignment|grids|exports|interactions|size|position|component|props|slot; all when omitted)}",
+            "{id?, group? (fills|strokes|effects|opacity|visible|name|corners|characters|textStyle|padding|gap|alignment|grids|exports|interactions|size|position|modes|component|props|slot; all when omitted)}",
             true,
             reset_override
         ),
@@ -330,23 +336,25 @@ fn create(s: &mut Session, p: &Value) -> Result<Value> {
     Ok(json!({"id": target}))
 }
 
+/// The name a new component set takes from its first variant: the path before the last '/'
+/// ("Button/State=Hover" → "Button"), or a plain name as is ("Button"). A bare "prop=value" name
+/// ("State=Default, Size=Small") names no set.
+fn set_name_from(variant: &str) -> Option<String> {
+    let base = variant.rsplit_once('/').map_or(variant, |(path, _)| path).trim();
+    (!base.is_empty() && !base.contains('=')).then(|| base.to_string())
+}
+
 /// Wrap components in a new component set (named after the first) placed around them.
-fn wrap_in_set(doc: &mut Document, ids: &[NodeId]) -> Result<NodeId> {
-    let cmd = "component.combineVariants";
+fn wrap_in_set(cmd: &str, doc: &mut Document, ids: &[NodeId]) -> Result<NodeId> {
     let top = *ids.last().ok_or_else(|| bad(cmd, "nothing selected"))?;
     let parent = doc.get(top)?.parent.ok_or_else(|| bad(cmd, "page"))?;
     if inside_instance(doc, top) || owning_instance(doc, parent).is_some() {
-        return Err(EngineError::Disabled(cmd.into(), "components inside an instance can't be combined".into()));
+        return Err(EngineError::Disabled(cmd.into(), INSIDE_INSTANCE.into()));
     }
     let bounds = doc.bounds_of(ids).unwrap_or_default();
     let pw = doc.world_transform(parent);
     let local = figcraft_geom::transform_rect_bbox(pw.inverse(), bounds.inflate(20.0, 20.0));
-    let base = ids
-        .first()
-        .and_then(|i| doc.node(*i))
-        .map(|n| n.name.split(['/', '=']).next().unwrap_or("Component").trim().to_string())
-        .filter(|n| !n.is_empty() && !n.contains(','))
-        .unwrap_or_else(|| "Component".into());
+    let base = ids.first().and_then(|i| doc.node(*i)).and_then(|n| set_name_from(&n.name)).unwrap_or_else(|| doc.next_name("Component"));
     let set = doc.alloc_id();
     let mut n = Node::new(set, NodeKind::ComponentSet { description: String::new() }, base, local.width(), local.height());
     n.transform = figcraft_geom::Affine::translate((local.x0, local.y0));
@@ -358,22 +366,71 @@ fn wrap_in_set(doc: &mut Document, ids: &[NodeId]) -> Result<NodeId> {
     Ok(set)
 }
 
-fn combine(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "component.combineVariants";
-    let ids = req_targets(cmd, s, p)?;
-    let doc = s.doc_mut()?;
+const INSIDE_INSTANCE: &str = "components inside an instance can't become variants";
+
+/// Why `ids` (distinct) can't become the variants of a new component set, or `None` when they
+/// can: anything but main components, components that are variants already (combining them would
+/// put a set in a set), library copies, components inside an instance, and a component inside
+/// another one of `ids`.
+fn combine_refusal(doc: &Document, ids: &[NodeId]) -> Option<&'static str> {
     if !ids.iter().all(|i| doc.node(*i).is_some_and(|n| matches!(n.kind, NodeKind::Component { .. }))) {
-        return Err(bad(cmd, "select components only"));
+        Some("select components only")
+    } else if ids.iter().any(|i| variant_set(doc, *i).is_some()) {
+        Some("components that are variants already can't be combined again")
+    } else if ids.iter().any(|i| doc.is_remote(*i)) {
+        Some(crate::library::READ_ONLY)
+    } else if ids.iter().any(|i| inside_instance(doc, *i)) {
+        Some(INSIDE_INSTANCE)
+    } else if roots(doc, ids).len() != ids.len() {
+        Some("a component can't be combined with one inside it")
+    } else {
+        None
     }
-    let ids = z_sorted(doc, &ids);
-    let set = wrap_in_set(doc, &ids)?;
+}
+
+/// Whether "Combine as variants" is on offer for `ids` (menus and the Design panel): two or more
+/// main components that [`combine_refusal`] lets through.
+pub fn can_combine_variants(doc: &Document, ids: &[NodeId]) -> bool {
+    ids.len() >= 2 && combine_refusal(doc, ids).is_none() && ids.iter().collect::<BTreeSet<_>>().len() == ids.len()
+}
+
+/// Whether "Add variant" is on offer for `id`: a component set with variants, a variant, or a main
+/// component not in a set yet (it becomes one); never a library copy or inside an instance.
+pub fn can_add_variant(doc: &Document, id: NodeId) -> bool {
+    let Some(n) = doc.node(id) else { return false };
+    let local = !doc.is_remote(id) && !inside_instance(doc, id);
+    match n.kind {
+        NodeKind::ComponentSet { .. } => {
+            local && n.children.iter().any(|c| doc.node(*c).is_some_and(|c| matches!(c.kind, NodeKind::Component { .. })))
+        }
+        NodeKind::Component { .. } => local,
+        _ => false,
+    }
+}
+
+/// Wrap `ids` (z-sorted main components) in a new component set, naming them "Property 1=Default",
+/// "Property 1=VariantN" unless already in prop=value form. Returns the set.
+fn make_variant_set(cmd: &str, doc: &mut Document, ids: &[NodeId]) -> Result<NodeId> {
+    let set = wrap_in_set(cmd, doc, ids)?;
     for (k, i) in ids.iter().enumerate() {
-        // Name variants "Property 1=Variant N" unless already in prop=value form.
         let node = doc.get_mut(*i)?;
         if !node.name.contains('=') {
             node.name = format!("Property 1={}", if k == 0 { "Default".to_string() } else { format!("Variant{}", k + 1) });
         }
     }
+    Ok(set)
+}
+
+fn combine(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "component.combineVariants";
+    let mut seen = BTreeSet::new();
+    let ids: Vec<NodeId> = req_targets(cmd, s, p)?.into_iter().filter(|i| seen.insert(*i)).collect();
+    let doc = s.doc_mut()?;
+    if let Some(why) = combine_refusal(doc, &ids) {
+        return Err(EngineError::Disabled(cmd.into(), why.into()));
+    }
+    let ids = z_sorted(doc, &ids);
+    let set = make_variant_set(cmd, doc, &ids)?;
     s.set_selection(vec![set]);
     Ok(json!({"id": set}))
 }
@@ -397,15 +454,19 @@ fn fit_set(doc: &mut Document, set: NodeId) {
 
 fn add_variant(s: &mut Session, p: &Value) -> Result<Value> {
     let cmd = "component.addVariant";
-    let t = targets(s, p).first().copied().ok_or_else(|| bad(cmd, "select a component set or variant"))?;
+    let t = targets(s, p).first().copied().ok_or_else(|| bad(cmd, "select a component set or component"))?;
     let doc = s.doc_mut()?;
     let (set, base) = match doc.get(t)?.kind {
         NodeKind::ComponentSet { .. } => {
             let last = doc.get(t)?.children.last().copied().ok_or_else(|| bad(cmd, "the component set is empty"))?;
             (t, last)
         }
-        NodeKind::Component { .. } => (variant_set(doc, t).ok_or_else(|| bad(cmd, "the component isn't a variant (combine as variants first)"))?, t),
-        _ => return Err(bad(cmd, "select a component set or variant")),
+        NodeKind::Component { .. } => match variant_set(doc, t) {
+            Some(set) => (set, t),
+            // A main component on its own becomes a set of itself, then gains the new variant.
+            None => (make_variant_set(cmd, doc, &[t])?, t),
+        },
+        _ => return Err(bad(cmd, "select a component set or component")),
     };
     let options = variant_options(doc, set);
     let mut pairs = variant_props(&doc.get(base)?.name);
@@ -472,6 +533,7 @@ fn detach(s: &mut Session, p: &Value) -> Result<Value> {
         // Own layers lose their link (slot content stays as it is); nested instances stay
         // instances of their own mains.
         let nested = unlink_layers(doc, i, Some(i));
+        keep_main_modes(doc, i)?;
         let n = doc.get_mut(i)?;
         n.kind = NodeKind::Frame;
         n.source = None;
@@ -491,6 +553,19 @@ fn detach(s: &mut Session, p: &Value) -> Result<Value> {
     Ok(json!({"ids": out}))
 }
 
+/// Make the variable modes instance `i` takes from its main its own (it's being detached).
+fn keep_main_modes(doc: &mut Document, i: NodeId) -> Result<()> {
+    let modes = match doc.get(i)?.kind {
+        NodeKind::Instance { component, .. } => doc.node(component).map(|m| m.var_modes.clone()).unwrap_or_default(),
+        _ => return Ok(()),
+    };
+    let own = &mut doc.get_mut(i)?.var_modes;
+    for (c, m) in modes {
+        own.entry(c).or_insert(m);
+    }
+    Ok(())
+}
+
 fn reset_instance(s: &mut Session, p: &Value) -> Result<Value> {
     let cmd = "component.resetInstance";
     let ids = req_targets(cmd, s, p)?;
@@ -608,7 +683,7 @@ fn make_slot(s: &mut Session, p: &Value) -> Result<Value> {
     let owner = Owner::resolve(doc, id).ok_or_else(|| bad(cmd, "the frame isn't inside a component"))?;
     let name = string(p, "name").unwrap_or_else(|| fresh_prop_name(doc, &owner, &n.name));
     let preferred = get(p, "preferred").cloned().unwrap_or(Value::Null);
-    add_prop(s, &json!({"id": id, "layer": id, "name": name, "type": "slot", "preferred": preferred}))
+    add_prop_for(cmd, s, &json!({"id": id, "layer": id, "name": name, "type": "slot", "preferred": preferred}))
 }
 
 fn remove_slot(s: &mut Session, p: &Value) -> Result<Value> {
@@ -678,8 +753,8 @@ fn push_changes(s: &mut Session, p: &Value) -> Result<Value> {
     if !doc.contains(component) {
         return Err(EngineError::Disabled(cmd.into(), "the main component was deleted (use component.restoreMain)".into()));
     }
-    // Copy every overridden layer's values to its source in the main (geometry, swaps, property
-    // values and slot content stay with the instance).
+    // Copy every overridden layer's values to its source in the main (geometry, resizing, swaps,
+    // property values and slot content stay with the instance).
     let mut pushed = 0;
     for d in doc.subtree(inst) {
         let Some(n) = doc.node(d).cloned() else { continue };
@@ -691,7 +766,7 @@ fn push_changes(s: &mut Session, p: &Value) -> Result<Value> {
         let groups: BTreeSet<String> = n
             .overrides
             .iter()
-            .filter(|g| !matches!(g.as_str(), "size" | "position" | "component" | "props" | SLOT) && !(d == inst && g.as_str() == "name"))
+            .filter(|g| !(matches!(g.as_str(), "size" | "resizing" | "position" | "component" | "props" | SLOT) || d == inst && g.as_str() == "name"))
             .cloned()
             .collect();
         for g in &groups {
@@ -1039,7 +1114,12 @@ fn valid_prop_name(cmd: &str, name: &str) -> Result<String> {
 }
 
 fn add_prop(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "component.addProperty";
+    add_prop_for("component.addProperty", s, p)
+}
+
+/// Add a component property for command `cmd`, which errors name (`component.makeSlot` adds its
+/// slot property here).
+fn add_prop_for(cmd: &str, s: &mut Session, p: &Value) -> Result<Value> {
     let target = targets(s, p).first().copied().ok_or_else(|| bad(cmd, "select a component"))?;
     let name = valid_prop_name(cmd, &req_string(cmd, p, "name")?)?;
     let t = req_string(cmd, p, "type")?;
@@ -1084,7 +1164,7 @@ fn add_prop(s: &mut Session, p: &Value) -> Result<Value> {
                 .unwrap_or_else(|| "Default".into());
             let set = match owner {
                 Owner::Set(s) => s,
-                Owner::Comp(c) => wrap_in_set(doc, &[c])?,
+                Owner::Comp(c) => wrap_in_set(cmd, doc, &[c])?,
             };
             for c in Owner::Set(set).components(doc) {
                 let cn = doc.get_mut(c)?;
diff --git a/crates/engine/src/cmd/create.rs b/crates/engine/src/cmd/create.rs
index 2150701a9..33c611a97 100644
--- a/crates/engine/src/cmd/create.rs
+++ b/crates/engine/src/cmd/create.rs
@@ -7,7 +7,7 @@ use serde_json::{Value, json};
 
 use super::{CommandSpec, ok};
 use crate::params::*;
-use crate::{EngineError, Result, Session, bad, spec};
+use crate::{Result, Session, bad, spec};
 
 /// Frame presets shown by the Frame tool (category, name, width, height).
 pub const FRAME_PRESETS: &[(&str, &str, f64, f64)] = &[
@@ -73,9 +73,13 @@ pub fn specs() -> Vec<CommandSpec> {
         spec!("text.create", "Text", "{text, x, y, parent?, width? (fixed width wraps), props? (fontSize, fontFamily, …)}", true, |s, p| {
             create_kind(s, p, "text")
         }),
-        spec!("vector.create", "Vector", "{path (SVG path data) | points [[x,y],..], closed?, x?, y?, parent?, props?}", true, |s, p| create_kind(
-            s, p, "vector"
-        )),
+        spec!(
+            "vector.create",
+            "Vector",
+            "{path (SVG path data) | points [[x,y],..], closed?, x?, y?, width?, height? (scale the path; one keeps its proportion), parent?, props?}",
+            true,
+            |s, p| create_kind(s, p, "vector")
+        ),
         spec!(
             "image.place",
             "Place image",
@@ -107,7 +111,8 @@ pub fn frame_at(doc: &Document, page: NodeId, pt: Point, exclude: &[NodeId]) ->
             return None;
         }
         let n = doc.node(id)?;
-        if !n.visible || n.locked {
+        // Board objects (stickies, shapes with text) never take layers in.
+        if !n.visible || n.locked || n.is_board_atom() {
             return None;
         }
         let is_container = n.kind.is_frame_like() || matches!(n.kind, NodeKind::Section { .. });
@@ -162,12 +167,43 @@ pub fn parse_path_data(d: &str) -> Option<figcraft_geom::BezPath> {
     figcraft_geom::BezPath::from_svg(d).ok()
 }
 
+/// How much a vector's path is scaled to take the size asked for: with both sides, each scales
+/// independently (as resizing a vector does); with one, the other keeps its proportion. A size on
+/// an axis the geometry has none of is an error unless it is 0 (a line's height), and a size of 0
+/// or less on an axis it has is refused rather than flattening it.
+fn vector_scale(width: Option<f64>, height: Option<f64>, bw: f64, bh: f64, what: &str) -> std::result::Result<(f64, f64), String> {
+    let fit = |asked: Option<f64>, have: f64, axis: &str| match asked {
+        None => Ok(1.0),
+        Some(a) if have <= 1e-9 => {
+            if a == 0.0 {
+                Ok(1.0)
+            } else {
+                Err(format!("`{axis}` can't size {what} with no {} extent", if axis == "width" { "horizontal" } else { "vertical" }))
+            }
+        }
+        Some(a) if a > 0.0 && (a / have).is_finite() => Ok(a / have),
+        Some(_) => Err(format!("`{axis}` must be a positive, finite size: 0 or less would flatten {what}")),
+    };
+    Ok(match (width, height) {
+        (Some(_), Some(_)) => (fit(width, bw, "width")?, fit(height, bh, "height")?),
+        (Some(_), None) => {
+            let s = fit(width, bw, "width")?;
+            (s, s)
+        }
+        (None, Some(_)) => {
+            let s = fit(height, bh, "height")?;
+            (s, s)
+        }
+        (None, None) => (1.0, 1.0),
+    })
+}
+
 pub fn create(s: &mut Session, p: &Value) -> Result<Value> {
     let cmd = "node.create";
     let t = string(p, "type").ok_or_else(|| bad(cmd, "`type` is required"))?;
     let (mut kind, base) = kind_for(&t).ok_or_else(|| bad(cmd, format!("unknown type `{t}`")))?;
     let page = s.page()?;
-    let parent = id(p, "parent").unwrap_or(page);
+    let parent = crate::params::opt_id(cmd, p, "parent")?.unwrap_or(page);
     let doc = s.doc()?;
     let pn = doc.get(parent)?;
     if !pn.kind.is_container() {
@@ -187,20 +223,32 @@ pub fn create(s: &mut Session, p: &Value) -> Result<Value> {
         "Section" => (num_or(p, "width", 400.0), num_or(p, "height", 300.0)),
         _ => (num_or(p, "width", 100.0), num_or(p, "height", 100.0)),
     };
-    // Vectors: path data or points define the shape and its box.
+    // Vectors: path data or points define the shape and its box. `width`/`height`, when asked
+    // for, scale the geometry: both sides independently, one side proportionally.
     let mut offset = (0.0, 0.0);
+    let asked = (num(p, "width"), num(p, "height"));
     if let NodeKind::Vector { network } = &mut kind {
         if let Some(d) = string(p, "path") {
             let mut path = parse_path_data(&d).ok_or_else(|| bad(cmd, "`path` is not valid SVG path data"))?;
             use figcraft_geom::Shape;
             let bb = path.bounding_box();
+            if bb.width() <= 1e-9 && bb.height() <= 1e-9 {
+                return Err(bad(cmd, "`path` draws nothing: a vector needs a visible line or area"));
+            }
             path.apply_affine(figcraft_geom::Affine::translate((-bb.x0, -bb.y0)));
+            let (sx, sy) = vector_scale(asked.0, asked.1, bb.width(), bb.height(), "a path").map_err(|e| bad(cmd, e))?;
+            if sx != 1.0 || sy != 1.0 {
+                path.apply_affine(figcraft_geom::Affine::scale_non_uniform(sx, sy));
+            }
             *network = VectorNetwork::from_path(&path);
+            if network.segments.is_empty() {
+                return Err(bad(cmd, "`path` draws nothing: a vector needs a visible line or area"));
+            }
             if boolean(p, "closed") == Some(false) {
                 network.regions.clear();
             }
-            w = bb.width();
-            h = bb.height();
+            w = bb.width() * sx;
+            h = bb.height() * sy;
             offset = (bb.x0, bb.y0);
         } else if let Some(Value::Array(pts)) = get(p, "points") {
             let pts: Vec<Point> = pts.iter().filter_map(|v| Some(Point::new(f64_of(v.get(0)?)?, f64_of(v.get(1)?)?))).collect();
@@ -208,10 +256,14 @@ pub fn create(s: &mut Session, p: &Value) -> Result<Value> {
                 return Err(bad(cmd, "`points` needs at least two [x, y] pairs"));
             }
             let bb = figcraft_geom::points_bounds(pts.iter().copied()).unwrap_or_default();
-            let local: Vec<Point> = pts.iter().map(|q| Point::new(q.x - bb.x0, q.y - bb.y0)).collect();
+            if bb.width() <= 1e-9 && bb.height() <= 1e-9 {
+                return Err(bad(cmd, "`points` draws nothing: a vector needs a visible line or area"));
+            }
+            let (sx, sy) = vector_scale(asked.0, asked.1, bb.width(), bb.height(), "a point set").map_err(|e| bad(cmd, e))?;
+            let local: Vec<Point> = pts.iter().map(|q| Point::new((q.x - bb.x0) * sx, (q.y - bb.y0) * sy)).collect();
             *network = VectorNetwork::from_points(&local, boolean(p, "closed").unwrap_or(false));
-            w = bb.width();
-            h = bb.height();
+            w = bb.width() * sx;
+            h = bb.height() * sy;
             offset = (bb.x0, bb.y0);
         }
     }
@@ -255,7 +307,7 @@ pub fn create(s: &mut Session, p: &Value) -> Result<Value> {
         node.width = tw;
         node.height = th;
     }
-    let index = num(p, "index").map(|i| i.max(0.0) as usize);
+    let index = crate::params::opt_index(cmd, p, "index")?;
     doc.insert(node, parent, index)?;
     if let Some(Value::Object(props)) = get(p, "props") {
         super::props::apply(cmd, doc, nid, props)?;
@@ -313,12 +365,12 @@ fn free_spot(s: &Session, w: f64, h: f64) -> Result<(f64, f64)> {
 
 #[cfg(not(target_arch = "wasm32"))]
 fn read_path(path: &str) -> Result<Vec<u8>> {
-    std::fs::read(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))
+    crate::file_access::read(path)
 }
 
 #[cfg(target_arch = "wasm32")]
 fn read_path(path: &str) -> Result<Vec<u8>> {
-    Err(EngineError::Other(format!("{path}: files can't be read in the browser")))
+    Err(crate::EngineError::Other(format!("{path}: files can't be read in the browser")))
 }
 
 /// Place an image as a rectangle with an image fill (Figma's image layer).
@@ -340,7 +392,7 @@ pub fn place_image(s: &mut Session, p: &Value) -> Result<Value> {
         _ => ImageScaleMode::Fill,
     };
     let page = s.page()?;
-    let parent = id(p, "parent").unwrap_or(page);
+    let parent = crate::params::opt_id(cmd, p, "parent")?.unwrap_or(page);
     let ds = s.ds_mut()?;
     let doc = ds.doc_mut();
     let (hash, iw, ih) = figcraft_format::add_image(doc, bytes).map_err(|e| bad(cmd, e.to_string()))?;
diff --git a/crates/engine/src/cmd/edit.rs b/crates/engine/src/cmd/edit.rs
index 2c767b933..60a96b313 100644
--- a/crates/engine/src/cmd/edit.rs
+++ b/crates/engine/src/cmd/edit.rs
@@ -18,13 +18,26 @@ pub fn specs() -> Vec<CommandSpec> {
         spec!(
             "edit.duplicate",
             "Duplicate",
-            "{ids?, dx?, dy? (page offset; default: the offset of the last duplicate when ids are its copies, still selected; else top-level frames to the right with a 100 gap, everything else in place)}",
+            "{ids?, dx?, dy? (page offset; default: the offset of the last duplicate when ids are its copies, still selected; else top-level frames to the right with a 100 gap, everything else in place)}  a main component's copy is an instance of it (a variant stays a new variant in its set)",
             true,
             duplicate
         ),
         spec!("edit.copy", "Copy", "{ids?}", false, copy),
         spec!("edit.cut", "Cut", "{ids?}", true, cut),
-        spec!("edit.paste", "Paste", "{parent?, x?, y? (page coordinates of the pasted top-left)}", true, paste),
+        spec!(
+            "edit.paste",
+            "Paste",
+            "{parent?, x?, y? (page coordinates of the pasted top-left)}  a copied main component pastes as an instance of it within its file (cut ones, and pastes into other files, keep the component)",
+            true,
+            paste
+        ),
+        spec!(
+            "edit.pasteDesignLayers",
+            "Paste design layers",
+            "{html (the clipboard's HTML) | data (base64 of the clipboard's design data, at most 256 MB), parent?, x?, y?}  layers copied from another design app (a .fig canvas in the clipboard's HTML), read like a .fig file (best effort, with `warnings`), pasted as edit.paste pastes",
+            true,
+            paste_design_layers
+        ),
         spec!("edit.pasteOver", "Paste over selection", "{}", true, paste_over),
         spec!("edit.pasteReplace", "Paste to replace", "{ids?}", true, paste_replace),
         spec!("edit.copyProperties", "Copy properties", "{id?}", false, copy_props),
@@ -254,7 +267,7 @@ pub fn specs() -> Vec<CommandSpec> {
         }),
         spec!("effect.set", "Set effect", "{ids?, index, effect {..}}", true, |s, p| {
             let i = req_index("effect.set", p, "index")?;
-            let e: Effect = parse("effect.set", p, "effect")?.ok_or_else(|| bad("effect.set", "`effect` required"))?;
+            let e = super::props::effect_from("effect.set", p, "effect")?.ok_or_else(|| bad("effect.set", "`effect` required"))?;
             for id in req_targets("effect.set", s, p)? {
                 let n = s.doc_mut()?.get_mut(id)?;
                 if let Some(slot) = n.effects.get_mut(i) {
@@ -459,7 +472,7 @@ fn duplicate(s: &mut Session, p: &Value) -> Result<Value> {
         let top_frame = doc.node(parent).is_some_and(Node::is_page) && n.kind.is_frame_like();
         let idx = doc.index_in_parent(i).map(|x| x + 1);
         let w = n.width;
-        let nid = doc.duplicate_into(i, parent, idx)?;
+        let nid = crate::components::copy_in_file(doc, i, parent, idx)?;
         let (dx, dy) = match (num(p, "dx"), num(p, "dy")) {
             (Some(dx), dy) => (dx, dy.unwrap_or(0.0)),
             (None, Some(dy)) => (0.0, dy),
@@ -474,12 +487,16 @@ fn duplicate(s: &mut Session, p: &Value) -> Result<Value> {
                 nn.transform = Affine::translate((dx, dy)) * nn.transform;
             }
         }
-        if rename {
+        // An instance keeps the name instances get by default.
+        if rename && !matches!(doc.get(nid)?.kind, NodeKind::Instance { .. }) {
             let nn = doc.get_mut(nid)?;
             nn.name = bump_name(&nn.name);
         }
         out.push(nid);
     }
+    // Board connectors copied with what they join join the copies.
+    let map = crate::board::copy_map(doc, &ids, &out);
+    crate::board::rejoin(doc, &crate::board::copied_items(doc, &map), &map, false);
     s.set_selection(out.clone());
     s.ds_mut()?.last_duplicate = Some(Duplicated { sources: ids, copies: out.clone() });
     Ok(json!({"ids": out}))
@@ -496,9 +513,34 @@ fn bump_name(n: &str) -> String {
 }
 
 /// The copied form of the selection.
-pub fn copy_to_clipboard(s: &mut Session, ids: &[NodeId]) -> Result<()> {
+pub fn copy_to_clipboard(s: &mut Session, cmd: &str, ids: &[NodeId]) -> Result<()> {
     let ds = s.ds()?;
-    let doc = &ds.doc;
+    // Pages are not layers: they can't be pasted anywhere.
+    let layers: Vec<NodeId> = ids.iter().copied().filter(|i| !ds.doc.node(*i).is_some_and(Node::is_page)).collect();
+    if layers.is_empty() && !ids.is_empty() {
+        return Err(EngineError::Disabled(cmd.into(), "pages can't be copied; use page.duplicate".into()));
+    }
+    let (nodes, images, bounds) = copied(&ds.doc, &layers);
+    let (source, source_path, uid) = (ds.doc.clone(), ds.path.clone(), ds.uid);
+    s.clipboard.source = Some(source);
+    s.clipboard.source_path = source_path;
+    s.clipboard.source_doc = uid;
+    s.clipboard.copied_components = nodes
+        .iter()
+        .filter(|(_, sub)| {
+            cmd == "edit.copy" && sub.first().is_some_and(|n| matches!(n.kind, NodeKind::Component { .. } | NodeKind::ComponentSet { .. }))
+        })
+        .map(|(root, _)| *root)
+        .collect();
+    s.clipboard.nodes = nodes;
+    s.clipboard.images = images;
+    s.clipboard.bounds = bounds;
+    Ok(())
+}
+
+type Copied = (Vec<(NodeId, Vec<Node>)>, BTreeMap<String, ImageData>, Option<figcraft_geom::Rect>);
+
+fn copied(doc: &Document, ids: &[NodeId]) -> Copied {
     let ids = z_sorted(doc, &roots(doc, ids));
     let mut nodes = Vec::new();
     let mut images = BTreeMap::new();
@@ -521,28 +563,74 @@ pub fn copy_to_clipboard(s: &mut Session, ids: &[NodeId]) -> Result<()> {
         nodes.push((*i, sub));
     }
     let bounds = doc.bounds_of(&ids);
-    let uid = ds.uid;
-    let source = Some(ds.doc.clone());
-    let source_path = ds.path.clone();
-    s.clipboard.source = source;
-    s.clipboard.source_path = source_path;
-    s.clipboard.nodes = nodes;
-    s.clipboard.images = images;
-    s.clipboard.bounds = bounds;
-    s.clipboard.source_doc = uid;
-    Ok(())
+    (nodes, images, bounds)
+}
+
+/// The markers around the copied layers in the clipboard's HTML, spelt as that format spells them.
+pub const CLIP_OPEN: &str = "(figma)";
+pub const CLIP_CLOSE: &str = "(/figma)";
+/// Largest design data read from the clipboard: the `.fig` import's own canvas cap (256 MB). Its
+/// base64 is checked first, so neither the text nor the decoded bytes can pass it.
+const MAX_CLIP_DATA: usize = 256 * 1024 * 1024;
+const MAX_CLIP_BASE64: usize = MAX_CLIP_DATA.div_ceil(3) * 4;
+
+/// Base64 `text` (whitespace ignored, padding optional) when it fits [`MAX_CLIP_DATA`].
+fn clip_base64(text: &str) -> Option<Vec<u8>> {
+    use base64::Engine as _;
+    if text.bytes().filter(|b| !b.is_ascii_whitespace()).count() > MAX_CLIP_BASE64 {
+        return None;
+    }
+    let b64: String = text.chars().filter(|c| !c.is_ascii_whitespace()).collect();
+    base64::engine::general_purpose::STANDARD.decode(&b64).or_else(|_| base64::engine::general_purpose::STANDARD_NO_PAD.decode(&b64)).ok()
+}
+
+/// Layers copied from another design app travel in the clipboard's HTML as a `.fig` canvas in
+/// base64 between [`CLIP_OPEN`] and [`CLIP_CLOSE`]. This gives those bytes, or `None` when the HTML
+/// holds no readable design data (it may just mention the marker).
+pub fn design_clipboard_buffer(html: &str) -> Option<Vec<u8>> {
+    let start = html.find(CLIP_OPEN)? + CLIP_OPEN.len();
+    let len = html.get(start..)?.find(CLIP_CLOSE)?;
+    let bytes = clip_base64(html.get(start..start + len)?)?;
+    figcraft_format::fig::is_fig(&bytes).then_some(bytes)
+}
+
+fn paste_design_layers(s: &mut Session, p: &Value) -> Result<Value> {
+    const CMD: &str = "edit.pasteDesignLayers";
+    let bytes = match (string(p, "html"), string(p, "data")) {
+        (Some(html), _) => design_clipboard_buffer(&html).ok_or_else(|| bad(CMD, "the HTML holds no copied design layers"))?,
+        (None, Some(d)) => clip_base64(&d).ok_or_else(|| bad(CMD, "`data` is not base64 of at most 256 MB"))?,
+        (None, None) => return Err(bad(CMD, "pass `html` or `data`")),
+    };
+    let other = super::file::load_fig(&bytes, "Pasted layers").ok_or_else(|| bad(CMD, "the data is not copied design layers"))??;
+    let doc = std::sync::Arc::new(other.doc);
+    let tops: Vec<NodeId> = doc.pages.iter().filter_map(|pg| doc.node(*pg)).flat_map(|pg| pg.children.iter().copied()).collect();
+    if tops.is_empty() {
+        return Err(EngineError::Disabled(CMD.into(), "the copied layers came in empty".into()));
+    }
+    let (nodes, images, bounds) = copied(&doc, &tops);
+    let props = s.clipboard.props.take();
+    // No open file has id 0. So paste treats this copy as a copy from a different file.
+    s.clipboard =
+        crate::Clipboard { nodes, images, props, bounds, source_doc: 0, source: Some(doc), source_path: None, copied_components: BTreeSet::new() };
+    let mut out = paste(s, p)?;
+    if !other.issues.is_empty() {
+        out["warnings"] = json!(other.issues);
+    }
+    Ok(out)
 }
 
 fn copy(s: &mut Session, p: &Value) -> Result<Value> {
     let ids = req_targets("edit.copy", s, p)?;
-    copy_to_clipboard(s, &ids)?;
+    copy_to_clipboard(s, "edit.copy", &ids)?;
     Ok(json!({"copied": s.clipboard.nodes.len()}))
 }
 
 fn cut(s: &mut Session, p: &Value) -> Result<Value> {
     let ids = req_targets("edit.cut", s, p)?;
-    copy_to_clipboard(s, &ids)?;
-    delete(s, &json!({"ids": ids}))
+    copy_to_clipboard(s, "edit.cut", &ids)?;
+    let doc = s.doc()?;
+    let layers: Vec<NodeId> = ids.into_iter().filter(|i| !doc.node(*i).is_some_and(Node::is_page)).collect();
+    delete(s, &json!({"ids": layers}))
 }
 
 /// Paste the clipboard under `parent` with the copied top-left moved to `at` (page coords).
@@ -553,6 +641,7 @@ pub fn paste_into(s: &mut Session, parent: NodeId, at: Option<(f64, f64)>) -> Re
     }
     // From another file: its instances follow the mains this file can have.
     let foreign = clip.source.as_ref().filter(|_| s.ds().is_ok_and(|d| d.uid != clip.source_doc));
+    let copy_local = s.ds()?.uid == clip.source_doc;
     let doc = s.doc_mut()?;
     for (k, v) in &clip.images {
         doc.images.entry(k.clone()).or_insert_with(|| v.clone());
@@ -566,6 +655,16 @@ pub fn paste_into(s: &mut Session, parent: NodeId, at: Option<(f64, f64)>) -> Re
     let mut out = Vec::new();
     let mut all = BTreeMap::new();
     for (root, nodes) in &clip.nodes {
+        if copy_local
+            && clip.copied_components.contains(root)
+            && let Some(n) = nodes.first().filter(|n| matches!(n.kind, NodeKind::Component { .. }))
+            && doc.node(*root).is_some_and(|n| matches!(n.kind, NodeKind::Component { .. }))
+        {
+            let instance = crate::components::create_instance(doc, *root, parent, 0.0, 0.0)?;
+            doc.get_mut(instance)?.transform = doc.world_transform(parent).inverse() * shift * n.transform;
+            out.push(instance);
+            continue;
+        }
         let mut map = BTreeMap::new();
         for n in nodes {
             map.insert(n.id, doc.alloc_id());
@@ -579,6 +678,10 @@ pub fn paste_into(s: &mut Session, parent: NodeId, at: Option<(f64, f64)>) -> Re
         out.push(doc.paste_nodes(&nodes, &map, *root, into, None)?);
         all.extend(map);
     }
+    // Board connectors pasted with what they join join the pasted copies.
+    let originals: Vec<(NodeId, figcraft_doc::BoardItem)> =
+        clip.nodes.iter().flat_map(|(_, nodes)| nodes).filter_map(|n| Some((*all.get(&n.id)?, n.board.clone()?))).collect();
+    crate::board::rejoin(doc, &originals, &all, !copy_local);
     if let Some(src) = foreign {
         crate::library::adopt_pasted(doc, src, clip.source_path.as_deref(), &all)?;
     }
@@ -591,10 +694,15 @@ fn paste(s: &mut Session, p: &Value) -> Result<Value> {
     // else in the frame's centre; otherwise in place on the page (or the viewport centre).
     let sel = s.selection();
     let doc = s.doc()?;
+    let copy_local = s.ds()?.uid == s.clipboard.source_doc;
     let target = id(p, "parent").or_else(|| {
         sel.first()
             .copied()
-            .filter(|i| sel.len() == 1 && doc.node(*i).is_some_and(|n| n.kind.is_frame_like() && !matches!(n.kind, NodeKind::Instance { .. })))
+            .filter(|i| {
+                sel.len() == 1
+                    && doc.node(*i).is_some_and(|n| n.kind.is_frame_like() && !matches!(n.kind, NodeKind::Instance { .. }) && !n.is_board_atom())
+            })
+            .filter(|i| !copy_local || !s.clipboard.copied_components.iter().any(|root| doc.is_ancestor(*root, *i)))
     });
     let parent = target.unwrap_or(page);
     let at = match (num(p, "x"), num(p, "y")) {
@@ -861,9 +969,13 @@ pub fn opacity_from_digits(digits: &str) -> Option<f32> {
 fn opacity_keys(s: &mut Session, p: &Value) -> Result<Value> {
     let digits = req_string("object.opacityKeys", p, "digits")?;
     let o = opacity_from_digits(&digits).ok_or_else(|| bad("object.opacityKeys", "`digits` must be one or two digits"))?;
-    for i in req_targets("object.opacityKeys", s, p)? {
-        s.doc_mut()?.get_mut(i)?.opacity = o;
+    let ids = req_targets("object.opacityKeys", s, p)?;
+    let doc = s.doc_mut()?;
+    let before = super::styles::bound_before(doc, &ids);
+    for i in ids {
+        doc.get_mut(i)?.opacity = o;
     }
+    super::styles::detach_edited(doc, &before);
     Ok(json!({"opacity": o}))
 }
 
@@ -1086,10 +1198,37 @@ fn set(s: &mut Session, p: &Value) -> Result<Value> {
             .collect(),
         None => Vec::new(),
     };
-    let doc = s.doc_mut()?;
-    for i in ids {
-        super::props::apply("node.set", doc, i, &props)?;
+    let mut warnings = font_style_warnings(&s.ds()?.doc, &ids, &props);
+    // Auto layout keys go to the layers that can have auto layout; with none among the targets,
+    // the first refuses them (`props::layout_mut`).
+    let layout_keys: Vec<&str> = props.keys().map(String::as_str).filter(|k| super::props::LAYOUT_KEYS.contains(k)).collect();
+    let mut without_layout = props.clone();
+    let mut skipped = BTreeSet::new();
+    if !layout_keys.is_empty() {
+        let doc = &s.ds()?.doc;
+        let frame_like = |i: &NodeId| doc.node(*i).is_some_and(|n| n.kind.is_frame_like());
+        if ids.iter().any(frame_like) {
+            skipped = ids.iter().copied().filter(|i| !frame_like(i)).collect();
+            without_layout.retain(|k, _| !layout_keys.contains(&k.as_str()));
+        }
+        if !skipped.is_empty() {
+            let names: Vec<String> =
+                skipped.iter().take(10).filter_map(|i| doc.node(*i)).map(|n| format!("{} “{}” ({})", n.id, n.name, n.kind.type_name())).collect();
+            let more = if skipped.len() > names.len() { format!(" and {} more", skipped.len() - names.len()) } else { String::new() };
+            warnings.push(format!(
+                "{} skipped on {}{more}: only frames, components and instances have auto layout",
+                layout_keys.iter().map(|k| format!("`{k}`")).collect::<Vec<_>>().join(", "),
+                names.join(", ")
+            ));
+        }
     }
+    let doc = s.doc_mut()?;
+    let before = super::styles::bound_before(doc, &ids);
+    for i in ids {
+        let props = if skipped.contains(&i) { &without_layout } else { &props };
+        super::props::apply("node.set", doc, i, props)?;
+    }
+    super::styles::detach_edited(doc, &before);
     if let Some(o) = pivot {
         for (i, q) in pinned {
             let d = o - doc.world_transform(i) * q;
@@ -1098,7 +1237,43 @@ fn set(s: &mut Session, p: &Value) -> Result<Value> {
             }
         }
     }
-    ok()
+    if warnings.is_empty() { ok() } else { Ok(json!({"ok": true, "warnings": warnings})) }
+}
+
+/// A `fontStyle` draws in the family's face nearest to it, as a text layer resolves it. When that
+/// face has another weight or slant than the name asks for ("Black" on a family whose heaviest is
+/// Bold), say which face it is. Families that aren't installed, and names that match a style or a
+/// named instance (spelled any way: "SemiBold", "Semi Bold"), say nothing.
+fn font_style_warnings(doc: &figcraft_doc::Document, ids: &[NodeId], props: &serde_json::Map<String, Value>) -> Vec<String> {
+    let Some(style) = props.get("fontStyle").and_then(Value::as_str) else { return Vec::new() };
+    let mut families: Vec<String> = match props.get("fontFamily").and_then(Value::as_str) {
+        Some(f) => vec![f.to_string()],
+        None => ids
+            .iter()
+            .filter_map(|i| doc.node(*i))
+            .filter_map(|n| n.kind.text())
+            .flat_map(|t| t.spans().into_iter().map(|(_, _, st)| st.font_family.clone()).collect::<Vec<_>>())
+            .collect(),
+    };
+    families.sort();
+    families.dedup();
+    let norm = |s: &str| s.to_lowercase().replace([' ', '-', '_'], "");
+    let (want_w, want_i) = (i32::from(figcraft_doc::style_weight(style)), style.to_lowercase().contains("italic"));
+    families
+        .into_iter()
+        .filter_map(|family| {
+            let styles = figcraft_text::family_styles(&family);
+            if styles.is_empty() || styles.iter().any(|x| norm(x) == norm(style)) {
+                return None;
+            }
+            let face = figcraft_text::find_face(&family, style).filter(|f| f.family.eq_ignore_ascii_case(&family))?;
+            let w = face.axis("wght").map_or(i32::from(face.weight), |a| a.clamp(f64::from(want_w)).round() as i32);
+            if face.instance(style).is_some() || (w == want_w && face.italic == want_i) {
+                return None;
+            }
+            Some(format!("{family} has no `{style}` style: it draws in {}, the nearest (it has: {})", face.style, styles.join(", ")))
+        })
+        .collect()
 }
 
 /// `stroke.widthProfile`: a preset or points (through `node.set`'s `widthProfile`, so instances
@@ -1177,7 +1352,7 @@ fn paint_list(s: &mut Session, p: &Value, fills: bool, add: bool) -> Result<Valu
 fn paint_set(s: &mut Session, p: &Value, fills: bool) -> Result<Value> {
     let cmd = if fills { "fill.set" } else { "stroke.set" };
     let ids = req_targets(cmd, s, p)?;
-    let idx = num(p, "index").map(|x| x.max(0.0) as usize);
+    let idx = opt_index(cmd, p, "index")?;
     let new_paint = match get(p, "paint") {
         Some(v) => Some(paint_of(v).ok_or_else(|| bad(cmd, "invalid paint"))?),
         None => None,
@@ -1200,10 +1375,12 @@ fn paint_set(s: &mut Session, p: &Value, fills: bool) -> Result<Value> {
             slot.kind = figcraft_color::PaintKind::Solid { color: c.with_alpha(1.0) };
             if c.a < 1.0 {
                 slot.opacity = c.a;
+                slot.color_alpha = true;
             }
         }
         if let Some(o) = num(p, "opacity") {
             slot.opacity = (if o > 1.0 { o / 100.0 } else { o }).clamp(0.0, 1.0) as f32;
+            slot.color_alpha = false;
         }
         if let Some(v) = boolean(p, "visible") {
             slot.visible = v;
@@ -1211,7 +1388,7 @@ fn paint_set(s: &mut Session, p: &Value, fills: bool) -> Result<Value> {
         if let Some(b) = blend(p, "blend") {
             slot.blend = b;
         }
-        super::lists::remap_stop_bindings(n, fills, at, &old);
+        super::lists::rebind_edited_paint(n, fills, at, &old);
         if fills {
             n.styles.fill = None;
         } else {
@@ -1225,7 +1402,7 @@ fn pattern_fill(s: &mut Session, p: &Value) -> Result<Value> {
     const CMD: &str = "fill.pattern";
     let src = req_id(CMD, p, "source")?;
     let doc = s.doc()?;
-    if !doc.node(src).is_some_and(|n| !n.is_page()) {
+    if doc.node(src).is_none_or(|n| n.is_page()) {
         return Err(bad(CMD, "`source` must be a layer"));
     }
     if req_targets(CMD, s, p)?.iter().any(|t| doc.is_ancestor(*t, src)) {
@@ -1245,8 +1422,8 @@ fn pattern_fill(s: &mut Session, p: &Value) -> Result<Value> {
 }
 
 fn effect_add(s: &mut Session, p: &Value) -> Result<Value> {
-    let e: Effect = match get(p, "effect") {
-        Some(v) => serde_json::from_value(v.clone()).map_err(|e| bad("effect.add", e.to_string()))?,
+    let e: Effect = match super::props::effect_from("effect.add", p, "effect")? {
+        Some(e) => e,
         None => {
             let ty = string(p, "type").unwrap_or_else(|| "dropShadow".into());
             Effect::of_type(&ty).ok_or_else(|| bad("effect.add", format!("unknown effect type `{ty}`")))?
diff --git a/crates/engine/src/cmd/file.rs b/crates/engine/src/cmd/file.rs
index 54348372f..5944d701e 100644
--- a/crates/engine/src/cmd/file.rs
+++ b/crates/engine/src/cmd/file.rs
@@ -11,26 +11,38 @@ use super::{CommandSpec, ok};
 use crate::params::*;
 use crate::{DocState, EngineError, Result, Session, bad, spec};
 
+/// A new file of `kind` in a tab of its own.
+fn new_file(s: &mut Session, p: &Value, kind: FileKind) -> Result<Value> {
+    let name = string(p, "name").unwrap_or_else(|| if kind == FileKind::Board { "Untitled board" } else { "Untitled" }.into());
+    let mut doc = Document::new(name);
+    doc.kind = kind;
+    // A property of the page from here on: a later change of theme leaves it alone. Boards are
+    // light whatever the theme.
+    let background = if kind == FileKind::Board { BOARD_PAGE } else { s.new_page_background() };
+    for page in doc.pages.clone() {
+        if let Some(NodeKind::Page { background: b, .. }) = doc.node_mut(page).map(|n| &mut n.kind) {
+            *b = background;
+        }
+    }
+    s.docs.push(DocState::new(doc, None));
+    s.active = s.docs.len() - 1;
+    Ok(json!({"index": s.active, "kind": kind.id()}))
+}
+
 pub fn specs() -> Vec<CommandSpec> {
     vec![
-        spec!("file.new", "New design file", "{name?}", false, |s, p| {
-            let name = string(p, "name").unwrap_or_else(|| "Untitled".into());
-            let mut doc = Document::new(name);
-            // A property of the page from here on: a later change of theme leaves it alone.
-            let background = s.new_page_background();
-            for page in doc.pages.clone() {
-                if let Some(NodeKind::Page { background: b, .. }) = doc.node_mut(page).map(|n| &mut n.kind) {
-                    *b = background;
-                }
-            }
-            s.docs.push(DocState::new(doc, None));
-            s.active = s.docs.len() - 1;
-            Ok(json!({"index": s.active}))
-        }),
+        spec!("file.new", "New design file", "{name?}", false, |s, p| new_file(s, p, FileKind::Design)),
+        spec!(
+            "file.newBoard",
+            "New board",
+            "{name?}  a board: sticky notes, shapes with text, connectors, marker and stamps on a light page",
+            false,
+            |s, p| new_file(s, p, FileKind::Board)
+        ),
         spec!(
             "file.open",
             "Open",
-            "{path, variables? (REST: the local variables JSON as an object, JSON text or a path; default `<name>.variables.json` or `variables.json` next to the file)} (.figcraft, .json: FigCraft or REST API file JSON, .fig (best effort), .svg, .png, .jpg …); REST and .fig imports return `warnings`",
+            "{path | data (base64) + name (tells the format; opens as a new unsaved document), variables? (REST: the local variables JSON as an object, JSON text or a path; default `<name>.variables.json` or `variables.json` next to the file)} (.figcraft, .json: FigCraft or REST API file JSON, .fig (best effort), .svg, .png, .jpg …); REST and .fig imports return `warnings`; a file opened anew returns `summary` {name, pages, layers, images} (one that was already open just returns its `index`)",
             false,
             open
         ),
@@ -41,8 +53,20 @@ pub fn specs() -> Vec<CommandSpec> {
             false,
             open_recent
         ),
-        spec!("file.save", "Save", "{path?} (programmatic saves need a path the first time)", false, save),
-        spec!("file.saveAs", "Save as", "{path}", false, save_as),
+        spec!(
+            "file.save",
+            "Save",
+            "{path?} (programmatic saves need a path the first time); a .fig path writes an experimental export copy of the shown document with `warnings`, keeping the native path, unsaved changes and version preview",
+            false,
+            save
+        ),
+        spec!(
+            "file.saveAs",
+            "Save as",
+            "{path} (no extension adds .figcraft); a .fig path writes an experimental export copy of the shown document with `warnings`, keeping the native path, unsaved changes and version preview",
+            false,
+            save_as
+        ),
         spec!(
             "file.export",
             "Export",
@@ -74,12 +98,26 @@ pub fn specs() -> Vec<CommandSpec> {
         spec!(
             "file.import",
             "Import",
-            "{path | data (base64) + name, x?, y?, center? (SVG: centre it on x, y), variables? (REST: the local variables JSON as an object, JSON text or a path)}  SVG becomes an editable frame (shapes, text, gradients, masks, effects; with `warnings` for what it left out), images become image layers, .figcraft, REST API file JSON and .fig pages are appended with their variables and flows (REST and .fig: with `warnings`)",
+            "{path | data (base64) + name, x?, y?, center? (SVG: centre it on x, y), variables? (REST: the local variables JSON as an object, JSON text or a path)}  SVG becomes an editable frame (shapes, text, gradients, masks, effects; with `warnings` for what it left out), images become image layers, .figcraft, REST API file JSON and .fig pages are appended with their variables and flows (REST and .fig: with `warnings`; those return `summary` {name, pages, layers, images} of the file read)",
             true,
             import
         ),
         spec!("file.placeImage", "Place image", "{path | data, x?, y?}", true, super::create::place_image),
         spec!("file.close", "Close tab", "{index?, force? (discard unsaved changes)}", false, close),
+        spec!("file.moveTab", "Move tab", "{from, to} (indices among open documents)", false, |s, p| {
+            let from = req_index("file.moveTab", p, "from")?;
+            let to = req_index("file.moveTab", p, "to")?;
+            if from >= s.docs.len() || to >= s.docs.len() {
+                return Err(bad("file.moveTab", "no such document"));
+            }
+            if from != to {
+                let active_uid = s.docs.get(s.active).map(|d| d.uid);
+                let doc = s.docs.remove(from);
+                s.docs.insert(to, doc);
+                s.active = active_uid.and_then(|uid| s.docs.iter().position(|d| d.uid == uid)).unwrap_or(0);
+            }
+            Ok(json!({"index": to}))
+        }),
         spec!(
             "file.recover",
             "Recover file",
@@ -340,7 +378,7 @@ fn version_index(cmd: &str, ds: &DocState, p: &Value) -> Result<usize> {
     if i < ds.versions.len() { Ok(i) } else { Err(bad(cmd, format!("no version at index {i}"))) }
 }
 
-fn read_version(v: &Version) -> Result<Arc<Document>> {
+pub(crate) fn read_version(v: &Version) -> Result<Arc<Document>> {
     v.document().map_err(|e| EngineError::Other(format!("version “{}” can't be read: {e}", v.name)))
 }
 
@@ -423,7 +461,7 @@ pub(crate) fn recovered(path: &str) -> Result<DocState> {
 
 #[cfg(not(target_arch = "wasm32"))]
 fn read(path: &str) -> Result<Vec<u8>> {
-    std::fs::read(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))
+    crate::file_access::read(path)
 }
 
 #[cfg(target_arch = "wasm32")]
@@ -433,11 +471,7 @@ fn read(path: &str) -> Result<Vec<u8>> {
 
 /// The bytes of file `path`, refused when it's larger than `max`.
 pub(crate) fn read_capped(path: &str, max: u64) -> Result<Vec<u8>> {
-    let meta = std::fs::metadata(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;
-    if !meta.is_file() || meta.len() > max {
-        return Err(EngineError::Other(format!("{path}: not a file of at most {max} bytes")));
-    }
-    read(path)
+    crate::file_access::read_capped(path, max)
 }
 
 /// Write `bytes` to `path` through a uniquely named, exclusively created staging file and one
@@ -445,7 +479,7 @@ pub(crate) fn read_capped(path: &str, max: u64) -> Result<Vec<u8>> {
 /// truncates `path`, and no file or symlink at a staging name is ever written through.
 #[cfg(not(target_arch = "wasm32"))]
 pub(crate) fn write(path: &str, bytes: &[u8]) -> Result<()> {
-    figcraft_format::write_file_atomic(std::path::Path::new(path), bytes).map_err(|e| EngineError::Other(format!("{path}: {e}")))
+    crate::file_access::write(path, bytes)
 }
 
 #[cfg(target_arch = "wasm32")]
@@ -461,6 +495,11 @@ fn file_stem(path: &str) -> String {
     std::path::Path::new(path).file_stem().and_then(|e| e.to_str()).unwrap_or("Untitled").to_string()
 }
 
+/// The counts the import report shows for a freshly loaded document.
+fn import_summary(doc: &Document) -> Value {
+    json!({"name": doc.name, "pages": doc.pages.len(), "layers": doc.nodes().filter(|n| !n.is_page()).count(), "images": doc.images.len()})
+}
+
 /// Load a document from any supported file (REST API file JSON images come from an `images`
 /// folder next to the file).
 pub fn load(path: &str) -> Result<(Document, Vec<String>)> {
@@ -506,10 +545,8 @@ fn load_with(
             Ok((doc.into(), false))
         }
         _ => {
-            if let Some(r) = figcraft_format::fig::try_import(bytes, &file_stem(name_hint)) {
-                let (mut doc, warnings) = r.map_err(|e| EngineError::Other(e.to_string()))?;
-                link_instances(&mut doc);
-                return Ok((figcraft_format::Loaded { issues: warnings, ..doc.into() }, true));
+            if let Some(r) = load_fig(bytes, &file_stem(name_hint)) {
+                return Ok((r?, true));
             }
             if let Some(r) = figcraft_format::rest::try_import_with(bytes, variables, images) {
                 let (mut doc, warnings) = r.map_err(|e| EngineError::Other(e.to_string()))?;
@@ -517,7 +554,8 @@ fn load_with(
                 return Ok((figcraft_format::Loaded { issues: warnings, ..doc.into() }, true));
             }
             let mut loaded = figcraft_format::load_bytes_with_versions(bytes).map_err(|e| EngineError::Other(e.to_string()))?;
-            if loaded.doc.name.is_empty() {
+            // Older files saved an untouched default title even after the user chose a filename.
+            if loaded.doc.name.is_empty() || loaded.doc.name == "Untitled" {
                 loaded.doc.name = file_stem(name_hint);
             }
             Ok((loaded, false))
@@ -525,10 +563,21 @@ fn load_with(
     }
 }
 
+/// Gives `None` when `bytes` are not a `.fig` file. Then other readers can try.
+pub(crate) fn load_fig(bytes: &[u8], name: &str) -> Option<Result<figcraft_format::Loaded>> {
+    let r = figcraft_format::fig::try_import(bytes, name)?;
+    Some(r.map_err(|e| EngineError::Other(e.to_string())).map(|(mut doc, warnings)| {
+        link_instances(&mut doc);
+        figcraft_format::Loaded { issues: warnings, ..doc.into() }
+    }))
+}
+
 /// Link imported instances to their mains (layer sources, overrides found by comparing values),
 /// innermost first so outer instances settle last.
 fn link_instances(doc: &mut Document) {
+    super::styles::unfold_imported_bound_alpha(doc);
     crate::style_vars::after_load(doc);
+    super::styles::apply_paint_bindings_on_load(doc);
     let mut insts: Vec<(usize, NodeId)> =
         doc.nodes().filter(|n| matches!(n.kind, NodeKind::Instance { .. })).map(|n| (doc.ancestors(n.id).len(), n.id)).collect();
     insts.sort_by_key(|a| std::cmp::Reverse(a.0));
@@ -552,11 +601,9 @@ fn rest_images(path: &str) -> impl Fn(&str) -> Option<Vec<u8>> {
             return None;
         }
         let dir = dir.as_ref()?;
-        ["", ".png", ".jpg", ".jpeg", ".gif", ".webp"].iter().find_map(|e| {
-            let p = dir.join(format!("{r}{e}"));
-            let meta = std::fs::metadata(&p).ok()?;
-            if meta.is_file() && meta.len() <= MAX_IMAGE_FILE { std::fs::read(&p).ok() } else { None }
-        })
+        ["", ".png", ".jpg", ".jpeg", ".gif", ".webp"]
+            .iter()
+            .find_map(|e| crate::file_access::read_capped(dir.join(format!("{r}{e}")), MAX_IMAGE_FILE).ok())
     }
 }
 
@@ -579,11 +626,7 @@ fn sibling_variables(path: &str) -> Option<Value> {
     let file = std::path::Path::new(path);
     let dir = file.parent()?;
     [format!("{}.variables.json", file_stem(path)), "variables.json".to_string()].iter().map(|n| dir.join(n)).filter(|c| c != file).find_map(|c| {
-        let meta = std::fs::metadata(&c).ok()?;
-        if !meta.is_file() || meta.len() > MAX_VARIABLES_FILE {
-            return None;
-        }
-        let v: Value = serde_json::from_slice(&std::fs::read(&c).ok()?).ok()?;
+        let v: Value = serde_json::from_slice(&crate::file_access::read_capped(c, MAX_VARIABLES_FILE).ok()?).ok()?;
         figcraft_format::rest::is_variables_json(&v).then_some(v)
     })
 }
@@ -621,20 +664,29 @@ fn remember(s: &mut Session, path: &str) {
 }
 
 fn open_recent(s: &mut Session, p: &Value) -> Result<Value> {
+    use crate::file_access::{Access, allow, allowed};
     const CMD: &str = "file.openRecent";
+    // Confined to automation roots, the recent files outside them are never listed, opened, removed
+    // or named: `index` counts the files listed.
+    let listed = |r: &String| allowed(r, Access::Read);
     if p.get("clear").and_then(Value::as_bool) == Some(true) {
-        s.prefs.recent_files.clear();
+        s.prefs.recent_files.retain(|r| !listed(r));
     }
     if let Some(gone) = string(p, "remove") {
-        s.prefs.recent_files.retain(|r| *r != gone);
+        s.prefs.recent_files.retain(|r| *r != gone || !listed(r));
     }
     let path = match (string(p, "path"), num(p, "index")) {
-        (Some(path), _) => Some(path),
-        (None, Some(i)) => Some(s.prefs.recent_files.get(i.max(0.0) as usize).cloned().ok_or_else(|| bad(CMD, "no such recent file"))?),
+        (Some(path), _) => {
+            allow(&path, Access::Read)?;
+            Some(path)
+        }
+        (None, Some(i)) => {
+            Some(s.prefs.recent_files.iter().filter(|r| listed(r)).nth(i.max(0.0) as usize).cloned().ok_or_else(|| bad(CMD, "no such recent file"))?)
+        }
         _ => None,
     };
     if let Some(path) = path {
-        if !std::path::Path::new(&path).exists() {
+        if !crate::file_access::exists(&path) {
             s.prefs.recent_files.retain(|r| *r != path);
             return Err(bad(CMD, format!("{path} no longer exists")));
         }
@@ -644,17 +696,23 @@ fn open_recent(s: &mut Session, p: &Value) -> Result<Value> {
         .prefs
         .recent_files
         .iter()
+        .filter(|r| listed(r))
         .map(|r| {
             let name = std::path::Path::new(r).file_name().map_or_else(|| r.clone(), |f| f.to_string_lossy().into_owned());
-            json!({"path": r, "name": name, "exists": std::path::Path::new(r).exists()})
+            json!({"path": r, "name": name, "exists": crate::file_access::exists(r)})
         })
         .collect();
     Ok(json!({"files": files}))
 }
 
 fn open(s: &mut Session, p: &Value) -> Result<Value> {
-    let path = req_string("file.open", p, "path")?;
     let variables = variables_param("file.open", p)?;
+    if string(p, "path").is_none()
+        && let Some(d) = string(p, "data")
+    {
+        return open_data(s, &d, p, variables.as_ref());
+    }
+    let path = req_string("file.open", p, "path")?;
     // Already open: switch to it.
     if let Some(i) = s.docs.iter().position(|d| d.path.as_deref() == Some(path.as_str())) {
         s.active = i;
@@ -672,9 +730,26 @@ fn open(s: &mut Session, p: &Value) -> Result<Value> {
             more => format!("{}: {} problems were repaired or left out while opening it, e.g. {}", file_stem(&path), more.len(), more[0]),
         });
     }
+    let summary = import_summary(&loaded.doc);
     s.docs.push(DocState::new(loaded.doc, native.then_some(path)).with_versions(loaded.versions).with_branches(loaded.branches));
     s.active = s.docs.len() - 1;
-    let mut out = json!({"index": s.active});
+    let mut out = json!({"index": s.active, "summary": summary});
+    out[if warnings { "warnings" } else { "repairs" }] = json!(loaded.issues);
+    Ok(out)
+}
+
+/// [`open`] for a file given as base64 `data` (a file dropped without a path on disk): `name` tells
+/// the format. It opens as a new document with no path, so the first save asks where to put it.
+fn open_data(s: &mut Session, data: &str, p: &Value, variables: Option<&Value>) -> Result<Value> {
+    let name = req_string("file.open", p, "name")?;
+    let data = data.split_once(',').map_or(data, |(_, b)| b);
+    let bytes = base64::engine::general_purpose::STANDARD.decode(data.trim()).map_err(|e| bad("file.open", e.to_string()))?;
+    let (loaded, rest) = load_with(&bytes, &name, variables, &figcraft_format::rest::no_images)?;
+    let warnings = rest || ext(&name) == "svg";
+    let summary = import_summary(&loaded.doc);
+    s.docs.push(DocState::new(loaded.doc, None).with_versions(loaded.versions).with_branches(loaded.branches));
+    s.active = s.docs.len() - 1;
+    let mut out = json!({"index": s.active, "summary": summary});
     out[if warnings { "warnings" } else { "repairs" }] = json!(loaded.issues);
     Ok(out)
 }
@@ -775,12 +850,30 @@ fn color_profile(s: &mut Session, p: &Value) -> Result<Value> {
     Ok(json!({"profile": profile.id(), "changed": changed}))
 }
 
-/// Save the file of the active tab (the main file for a branch tab, with its branches).
+/// Native saves act on the current document; a `.fig` copy exports the version shown, and a
+/// pending Save As choice must leave it shown until its destination is known.
+pub(crate) fn save_ends_preview(s: &Session, cmd: &str, p: &Value) -> bool {
+    let path =
+        string(p, "path").or_else(|| if cmd == "file.save" { s.docs.get(crate::branches::file_tab(s)).and_then(|ds| ds.path.clone()) } else { None });
+    path.is_some_and(|path| ext(&path) != "fig")
+}
+
+/// Save the file of the active tab (the main file for a branch tab, with its branches), or export
+/// the active document as an experimental `.fig` copy without changing its native save state.
 fn save_to(s: &mut Session, path: String) -> Result<Value> {
+    if ext(&path) == "fig" {
+        return export_fig(s, &json!({"path": path}));
+    }
     let i = crate::branches::file_tab(s);
     let ds = s.docs.get_mut(i).ok_or(EngineError::NoDocument)?;
-    let bytes = file_bytes(ds)?;
+    let mut snapshot = FileSnapshot::of(ds);
+    let follows_path = ds.path.as_deref().map_or(ds.doc.name == "Untitled", |old| ds.doc.name == file_stem(old));
+    if follows_path && ds.path.as_deref() != Some(path.as_str()) {
+        Arc::make_mut(&mut snapshot.doc).name = file_stem(&path);
+    }
+    let bytes = snapshot.encode()?;
     write(&path, &bytes)?;
+    ds.doc = snapshot.doc;
     ds.path = Some(path.clone());
     ds.mark_saved();
     ds.revision += 1;
@@ -795,6 +888,11 @@ fn save(s: &mut Session, p: &Value) -> Result<Value> {
         return save_to(s, path);
     }
     match s.docs.get(crate::branches::file_tab(s)).ok_or(EngineError::NoDocument)?.path.clone() {
+        // Earlier builds wrote native data under a .fig name: never overwrite that file with an export.
+        Some(path) if ext(&path) == "fig" => {
+            s.request_ui("dialog.saveAs", json!({}));
+            Err(EngineError::Disabled("file.save".into(), "the saved path ends in .fig: choose Save as or pass `path`".into()))
+        }
         Some(path) => save_to(s, path),
         None => {
             s.request_ui("dialog.saveAs", json!({}));
@@ -1083,8 +1181,11 @@ fn export_path(name: &str) -> String {
     if parts.is_empty() { "Untitled".into() } else { parts.join("/") }
 }
 
-/// `name` without path separators and characters file systems reject.
-fn safe_file_name(name: &str) -> String {
+/// `name` without path separators and characters file systems reject (`/ \ : * ? " < > |` and
+/// control characters become `_`); everything else is kept, up to the first 200 characters.
+/// `figcraft-cli export` names its files by this rule too (and keeps at most 100 characters before
+/// the number and extension it adds).
+pub fn safe_file_name(name: &str) -> String {
     name.chars().take(200).map(|c| if c.is_control() || "/\\:*?\"<>|".contains(c) { '_' } else { c }).collect()
 }
 
@@ -1119,7 +1220,7 @@ fn export_layers(s: &mut Session, p: &Value) -> Result<Value> {
                 let path = std::path::Path::new(d).join(&job.file);
                 // A layer name with slashes exports into folders.
                 if let Some(parent) = path.parent() {
-                    let _ = std::fs::create_dir_all(parent);
+                    let _ = crate::file_access::create_dir_all(parent);
                 }
                 let path = path.to_string_lossy().to_string();
                 write(&path, &bytes)?;
@@ -1215,8 +1316,9 @@ fn import(s: &mut Session, p: &Value) -> Result<Value> {
             };
             let sibling = if variables.is_none() { path.as_deref().and_then(sibling_variables) } else { None };
             let (other, rest) = load_with(&bytes, &name, variables.as_ref().or(sibling.as_ref()), images)?;
+            let summary = import_summary(&other.doc);
             let pages = append_pages(s.doc_mut()?, &other.doc)?;
-            let mut out = json!({"pages": pages});
+            let mut out = json!({"pages": pages, "summary": summary});
             if rest {
                 out["warnings"] = json!(other.issues);
             }
@@ -1252,6 +1354,19 @@ fn append_pages(doc: &mut Document, other: &Document) -> Result<Vec<NodeId>> {
             map.insert(id, doc.alloc_id());
         }
     }
+    // Library copies a .fig import keeps (cached definitions) have no library record to follow:
+    // the layers of its store come along into the store of `doc`. Recorded copies are left to
+    // `merge_store`, which shares them with copies `doc` already has.
+    let cached: Vec<NodeId> = other
+        .library_store()
+        .and_then(|s| other.node(s))
+        .map(|s| s.children.iter().copied().filter(|root| other.libraries.import_of(*root).is_none()).collect())
+        .unwrap_or_default();
+    for root in &cached {
+        for id in other.subtree(*root) {
+            map.insert(id, doc.alloc_id());
+        }
+    }
     let mut new_pages = Vec::new();
     for pg in &other.pages {
         let Some(pn) = other.node(*pg) else { continue };
@@ -1269,6 +1384,13 @@ fn append_pages(doc: &mut Document, other: &Document) -> Result<Vec<NodeId>> {
         }
         new_pages.push(np);
     }
+    if !cached.is_empty() {
+        let store = doc.ensure_library_store();
+        for root in &cached {
+            let nodes: Vec<Node> = other.subtree(*root).into_iter().filter_map(|i| other.node(i).cloned()).collect();
+            doc.paste_nodes(&nodes, &map, *root, store, None)?;
+        }
+    }
     for new in map.values() {
         let src = doc.node(*new).and_then(|n| n.source).and_then(|s| map.get(&s).copied());
         if let (Some(src), Some(n)) = (src, doc.node_mut(*new)) {
@@ -1280,7 +1402,7 @@ fn append_pages(doc: &mut Document, other: &Document) -> Result<Vec<NodeId>> {
 }
 
 fn close(s: &mut Session, p: &Value) -> Result<Value> {
-    let i = num(p, "index").map(|x| x as usize).unwrap_or(s.active);
+    let i = if get(p, "index").is_none() { s.active } else { req_index("file.close", p, "index")? };
     let Some(ds) = s.docs.get(i) else { return Err(bad("file.close", "no such document")) };
     // A branch tab's edits are in its main file already (which then has unsaved changes).
     if ds.branch_of.is_none() && ds.is_dirty() && !boolean(p, "force").unwrap_or(false) {
@@ -1288,14 +1410,36 @@ fn close(s: &mut Session, p: &Value) -> Result<Value> {
         return Err(EngineError::Disabled("file.close".into(), "the document has unsaved changes (pass force: true to discard)".into()));
     }
     let uid = ds.uid;
+    let active_uid = s.docs.get(s.active).map(|d| d.uid);
     s.docs.remove(i);
-    if s.active >= s.docs.len() {
-        s.active = s.docs.len().saturating_sub(1);
-    }
+    // Removing a tab before the active one shifts its index; keep the same document selected.
+    s.active = active_uid.and_then(|a| s.docs.iter().position(|d| d.uid == a)).unwrap_or(i.min(s.docs.len().saturating_sub(1)));
     crate::branches::close_tabs(s, uid, None);
     ok()
 }
 
+#[cfg(test)]
+mod tab_order_tests {
+    use super::*;
+
+    #[test]
+    fn moving_and_closing_inactive_tabs_preserves_the_active_document() {
+        let mut session = Session::new();
+        for name in ["Two", "Three", "Four"] {
+            session.execute("file.new", &json!({"name": name})).unwrap();
+        }
+        session.execute("doc.switch", &json!({"index": 2})).unwrap();
+        let active_uid = session.docs[session.active].uid;
+        let moved_uid = session.docs[0].uid;
+        session.execute("file.moveTab", &json!({"from": 0, "to": 2})).unwrap();
+        assert_eq!(session.docs[2].uid, moved_uid);
+        assert_eq!(session.docs[session.active].uid, active_uid);
+        session.execute("file.close", &json!({"index": 0})).unwrap();
+        assert_eq!(session.docs[session.active].uid, active_uid);
+        assert!(session.execute("file.moveTab", &json!({"from": 0, "to": 99})).is_err());
+    }
+}
+
 /// Ctrl+Tab / Ctrl+Shift+Tab: the next or previous open document, wrapping around.
 fn cycle_doc(s: &mut Session, dir: i64) -> Result<Value> {
     let n = s.docs.len() as i64;
@@ -1334,6 +1478,70 @@ mod rest_import_tests {
         doc.nodes().find(|n| matches!(n.kind, NodeKind::Instance { .. })).unwrap()
     }
 
+    /// What a .fig import with a cached library component leaves: the main in the hidden store, a
+    /// visible instance of it and a layer linked to the main's layer.
+    fn cached_import() -> Document {
+        let mut doc = Document::new("Cached");
+        let page = doc.first_page().unwrap();
+        let store = doc.ensure_library_store();
+        let main = doc
+            .create(store, NodeKind::Component { description: String::new(), props: Default::default() }, "Cached main", 0.0, 0.0, 20.0, 20.0)
+            .unwrap();
+        let body = doc.create(main, NodeKind::Rectangle, "Body", 0.0, 0.0, 20.0, 20.0).unwrap();
+        let inst =
+            doc.create(page, NodeKind::Instance { component: main, props: Default::default() }, "Cached instance", 0.0, 0.0, 20.0, 20.0).unwrap();
+        let mut copy = doc.node(body).unwrap().clone();
+        copy.id = doc.alloc_id();
+        copy.parent = None;
+        copy.source = Some(body);
+        let copy_id = copy.id;
+        doc.insert(copy, inst, None).unwrap();
+        assert!(doc.is_remote(main) && doc.node(copy_id).unwrap().source == Some(body));
+        doc
+    }
+
+    /// Pasting layers that use a cached main into another document leaves the main behind, as it
+    /// does for other mains that are not published: no link points at a layer of the target.
+    #[test]
+    fn pasting_instances_of_cached_components_leaves_no_dangling_links() {
+        let src = cached_import();
+        let mut doc = Document::new("Target");
+        let page = doc.first_page().unwrap();
+        for i in 0..8 {
+            doc.create(page, NodeKind::Rectangle, &format!("Filler {i}"), 0.0, 0.0, 5.0, 5.0).unwrap();
+        }
+        let inst = src.nodes().find(|n| n.name == "Cached instance").unwrap().id;
+        let ids = src.subtree(inst);
+        let map: std::collections::BTreeMap<NodeId, NodeId> = ids.iter().map(|i| (*i, doc.alloc_id())).collect();
+        let nodes: Vec<Node> = ids.iter().filter_map(|i| src.node(*i).cloned()).collect();
+        doc.paste_nodes(&nodes, &map, inst, page, None).unwrap();
+        crate::library::adopt_pasted(&mut doc, &src, None, &map).unwrap();
+        let pasted = doc.node(map[&inst]).unwrap();
+        let NodeKind::Instance { component, .. } = pasted.kind else { panic!() };
+        assert!(!doc.contains(component), "the main stays behind: {component:?}");
+        assert!(doc.node(pasted.children[0]).unwrap().source.is_none_or(|s| !doc.contains(s)));
+    }
+
+    #[test]
+    fn appending_pages_with_cached_library_components_brings_the_components() {
+        let other = cached_import();
+        let mut doc = Document::new("Target");
+        let page = doc.first_page().unwrap();
+        // Ids of the target that would collide with the other document's store.
+        for i in 0..8 {
+            doc.create(page, NodeKind::Rectangle, &format!("Filler {i}"), 0.0, 0.0, 5.0, 5.0).unwrap();
+        }
+        append_pages(&mut doc, &other).unwrap();
+        assert!(doc.validate().is_empty(), "{:?}", doc.validate());
+        assert!(crate::components::mirror_issues(&doc).is_empty(), "{:?}", crate::components::mirror_issues(&doc));
+        let inst = doc.nodes().find(|n| n.name == "Cached instance").unwrap();
+        let NodeKind::Instance { component, .. } = inst.kind else { panic!() };
+        assert_eq!(doc.node(component).unwrap().name, "Cached main");
+        assert!(doc.is_remote(component), "the main comes along into the store");
+        let layer = doc.node(inst.children[0]).unwrap();
+        assert_eq!(layer.source, doc.node(component).unwrap().children.first().copied());
+    }
+
     #[test]
     fn rest_json_loads_with_linked_instances() {
         let bytes = serde_json::to_vec(&kit()).unwrap();
@@ -1351,6 +1559,25 @@ mod rest_import_tests {
         assert!(thumbnail(&doc).is_some());
     }
 
+    #[test]
+    fn open_takes_data_and_a_name_as_a_new_unsaved_document() {
+        let mut saved = Session::new();
+        saved.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 10, "height": 10})).unwrap();
+        let bytes = file_bytes(saved.ds().unwrap()).unwrap();
+        let data = base64::engine::general_purpose::STANDARD.encode(&bytes);
+        let mut s = Session::new();
+        let recent = s.prefs.recent_files.clone();
+        let r = s.execute("file.open", &json!({"data": data, "name": "Dropped.figcraft"})).unwrap();
+        let open = s.docs.len();
+        assert_eq!(r["index"], open - 1, "a document of its own, made active");
+        assert_eq!(s.ds().unwrap().path, None, "no path to save over");
+        assert!(s.doc().unwrap().nodes().any(|n| matches!(n.kind, NodeKind::Rectangle)));
+        assert_eq!(s.prefs.recent_files, recent, "nothing on disk to remember");
+        assert!(s.execute("file.open", &json!({"data": data})).is_err(), "the name tells the format");
+        assert!(s.execute("file.open", &json!({"data": "not base64!", "name": "x.svg"})).is_err());
+        assert_eq!(s.docs.len(), open, "a refused open adds nothing");
+    }
+
     #[test]
     fn open_and_import_rest_json() {
         let dir = std::env::temp_dir().join(format!("figcraft-rest-{}", std::process::id()));
diff --git a/crates/engine/src/cmd/layout.rs b/crates/engine/src/cmd/layout.rs
index 5643ac706..da1301ec0 100644
--- a/crates/engine/src/cmd/layout.rs
+++ b/crates/engine/src/cmd/layout.rs
@@ -149,6 +149,35 @@ mod tests {
         assert!(s.execute("node.set", &json!({"id": b, "props": {"absolute": "maybe"}})).is_err());
     }
 
+    /// Each side key writes its own padding slot and leaves the other three alone.
+    #[test]
+    fn each_side_padding_sets_its_side_alone() {
+        let mut s = Session::new();
+        let (f, _, _) = al_frame(&mut s);
+        // One side at a time: the other three stay 0 ([top, right, bottom, left]).
+        for (key, v, want) in [
+            ("paddingTop", 8.0, [8.0, 0.0, 0.0, 0.0]),
+            ("paddingRight", 12.0, [0.0, 12.0, 0.0, 0.0]),
+            ("paddingBottom", 16.0, [0.0, 0.0, 16.0, 0.0]),
+            ("paddingLeft", 20.0, [0.0, 0.0, 0.0, 20.0]),
+        ] {
+            ex(&mut s, "node.set", json!({"id": f, "props": {"padding": 0}}));
+            ex(&mut s, "node.set", json!({"id": f, "props": {key: v}}));
+            assert_eq!(node(&s, f).layout.as_ref().unwrap().padding, want, "{key}");
+        }
+        // The [t, r, b, l] array and the axis pairs agree with the four sides.
+        ex(&mut s, "node.set", json!({"id": f, "props": {"padding": [8, 12, 16, 20]}}));
+        assert_eq!(node(&s, f).layout.as_ref().unwrap().padding, [8.0, 12.0, 16.0, 20.0]);
+        ex(&mut s, "node.set", json!({"id": f, "props": {"paddingHorizontal": 4}}));
+        assert_eq!(node(&s, f).layout.as_ref().unwrap().padding, [8.0, 4.0, 16.0, 4.0]);
+        ex(&mut s, "node.set", json!({"id": f, "props": {"paddingVertical": 2}}));
+        assert_eq!(node(&s, f).layout.as_ref().unwrap().padding, [2.0, 4.0, 2.0, 4.0]);
+        // Negatives clamp to 0; junk is refused.
+        ex(&mut s, "node.set", json!({"id": f, "props": {"paddingTop": -5}}));
+        assert_eq!(node(&s, f).layout.as_ref().unwrap().padding[0], 0.0);
+        assert!(s.execute("node.set", &json!({"id": f, "props": {"paddingLeft": "wide"}})).is_err());
+    }
+
     #[test]
     fn baseline_alignment_lines_up_text() {
         let mut s = Session::new();
diff --git a/crates/engine/src/cmd/lists.rs b/crates/engine/src/cmd/lists.rs
index 769d0a29c..287c9ddd0 100644
--- a/crates/engine/src/cmd/lists.rs
+++ b/crates/engine/src/cmd/lists.rs
@@ -112,7 +112,8 @@ pub fn stop_binding(field: &str) -> Option<usize> {
 /// Keep the gradient stop bindings of paint `index` of `n`'s fills (or strokes) on their stops after
 /// the paint changed from `old`: one stop removed shifts the later ones down (the removed one's
 /// binding goes); a paint that is no longer a gradient drops them. Other edits keep stop indices.
-pub(crate) fn remap_stop_bindings(n: &mut Node, fills: bool, index: usize, old: &figcraft_color::Paint) {
+/// Returns the removed stop's index.
+pub(crate) fn remap_stop_bindings(n: &mut Node, fills: bool, index: usize, old: &figcraft_color::Paint) -> Option<usize> {
     use figcraft_color::PaintKind;
     let list = if fills { BoundList::Fills } else { BoundList::Strokes };
     let new = if fills { n.fills.get(index) } else { n.strokes.get(index) };
@@ -122,11 +123,11 @@ pub(crate) fn remap_stop_bindings(n: &mut Node, fills: bool, index: usize, old:
             // The first stop that differs is the removed one when the rest moved down unchanged.
             let k = a.stops.iter().zip(&b.stops).position(|(x, y)| x != y).unwrap_or(b.stops.len());
             if a.stops.get(k + 1..) != b.stops.get(k..) {
-                return;
+                return None;
             }
             Some(k)
         }
-        (_, Some(PaintKind::Gradient(_))) => return,
+        (_, Some(PaintKind::Gradient(_))) => return None,
         _ => None,
     };
     let keys: Vec<(String, Option<String>)> = n
@@ -150,6 +151,42 @@ pub(crate) fn remap_stop_bindings(n: &mut Node, fills: bool, index: usize, old:
         }
     }
     n.bound.extend(kept);
+    removed
+}
+
+/// After an explicit edit changed paint `index` of `n`'s fills (or strokes) from `old`: its stop
+/// bindings follow a removed stop, then each binding whose value the edit changed (the colour, the
+/// opacity, a stop's colour) lets go, so the edit stays instead of being put back from the
+/// variable. Bindings whose value the edit kept stay; a paint that is gone takes its bindings.
+pub(crate) fn rebind_edited_paint(n: &mut Node, fills: bool, index: usize, old: &figcraft_color::Paint) {
+    let removed = remap_stop_bindings(n, fills, index, old);
+    let mut old = old.clone();
+    if let (Some(k), figcraft_color::PaintKind::Gradient(g)) = (removed, &mut old.kind)
+        && k < g.stops.len()
+    {
+        g.stops.remove(k);
+    }
+    let list = if fills { BoundList::Fills } else { BoundList::Strokes };
+    let new = if fills { n.fills.get(index) } else { n.strokes.get(index) }.cloned();
+    n.bound.retain(|key, _| match list_binding(key) {
+        Some((l, i, field)) if l == list && i == index => new.as_ref().is_some_and(|new| paint_field_kept(&old, new, field)),
+        _ => true,
+    });
+}
+
+/// Whether a paint's bound `field` (`color`, `opacity`, `stops/<j>/color`, …) has the same value in
+/// `new` as in `old`.
+fn paint_field_kept(old: &figcraft_color::Paint, new: &figcraft_color::Paint, field: &str) -> bool {
+    use figcraft_color::PaintKind;
+    match field {
+        "color" => matches!((&old.kind, &new.kind), (PaintKind::Solid { color: a }, PaintKind::Solid { color: b }) if a == b),
+        "opacity" => old.opacity == new.opacity,
+        _ => match (stop_binding(field), &old.kind, &new.kind) {
+            (Some(j), PaintKind::Gradient(a), PaintKind::Gradient(b)) => a.stops.get(j).map(|s| s.color) == b.stops.get(j).map(|s| s.color),
+            (Some(_), _, _) => false,
+            _ => old == new,
+        },
+    }
 }
 
 /// Where item `k` lands when the item at `from` moves to `to`.
diff --git a/crates/engine/src/cmd/mod.rs b/crates/engine/src/cmd/mod.rs
index 6579494ca..60d089635 100644
--- a/crates/engine/src/cmd/mod.rs
+++ b/crates/engine/src/cmd/mod.rs
@@ -71,6 +71,7 @@ fn registry() -> &'static Registry {
         list.extend(create::specs());
         list.extend(edit::specs());
         list.extend(lists::specs());
+        list.extend(crate::selection_colors::specs());
         list.extend(arrange::specs());
         list.extend(structure::specs());
         list.extend(section::specs());
@@ -79,6 +80,7 @@ fn registry() -> &'static Registry {
         list.extend(page::specs());
         list.extend(view::specs());
         list.extend(text::specs());
+        list.extend(crate::fonts::specs());
         list.extend(styles::specs());
         list.extend(image::specs());
         list.extend(variables::specs());
@@ -107,6 +109,7 @@ fn registry() -> &'static Registry {
         list.extend(crate::online::specs());
         list.extend(crate::invite_links::specs());
         list.extend(crate::templates::specs());
+        list.extend(crate::board::specs());
         let mut index = HashMap::new();
         for (i, s) in list.iter().enumerate() {
             if index.insert(s.id, i).is_some() {
diff --git a/crates/engine/src/cmd/props.rs b/crates/engine/src/cmd/props.rs
index 598be752f..2eedab457 100644
--- a/crates/engine/src/cmd/props.rs
+++ b/crates/engine/src/cmd/props.rs
@@ -13,7 +13,7 @@ pub const STROKE_SIDES: [&str; 4] = ["strokeTopWeight", "strokeRightWeight", "st
 
 /// Keys `node.set` understands (documented for agents).
 pub const KEYS: &str = "name, visible, locked, opacity (0-1), blend, x, y (relative to the parent frame; groups don't count), width, height, rotation (degrees), \
-fills (paints or colours; gradients as {type: linearGradient|radialGradient|angularGradient|diamondGradient, stops: [\"#hex\", ...], from?, to?} too), fill (colour), strokes, stroke (colour), strokeWeight, strokeAlign (inside|center|outside), strokeSides [t,r,b,l], strokeTopWeight / strokeRightWeight / strokeBottomWeight / strokeLeftWeight (one side; turns on individual strokes), \
+fills (paints or colours; gradients as {type: linearGradient|radialGradient|angularGradient|diamondGradient, stops: [\"#hex\", ...], from?, to?} too), fill (colour, or \"none\"/null: no fill), strokes, stroke (colour, or \"none\"/null: no stroke), strokeWeight, strokeAlign (inside|center|outside), strokeSides [t,r,b,l], strokeTopWeight / strokeRightWeight / strokeBottomWeight / strokeLeftWeight (one side; turns on individual strokes), \
 strokeCap / startCap / endCap, strokeJoin, miterAngle (degrees: sharper joins bevel; or miterLimit as a ratio), dashes [..], widthProfile (preset uniform|wedge|taper|eye|rounded|pinch, [[t, scale], ...] or null), brush (preset id, {preset, spacing, sizeJitter, rotationJitter, scatter, seed} or null), cornerRadius (n or [tl,tr,br,bl]), cornerSmoothing (0-1), effects, \
 clip, isMask, layout (null|horizontal|vertical|grid|{...}), gap, crossGap, padding (n or [t,r,b,l]), paddingTop/Right/Bottom/Left, \
 mainAlign (min|center|max, or the auto gaps spaceBetween|spaceAround|spaceEvenly), crossAlign (min|center|max|baseline: first text baselines, horizontal layouts), contentAlign (wrapped lines: auto = packed where crossAlign says | spaceBetween), wrap (rows of a horizontal layout, columns of a vertical one), strokesIncluded (the frame's inside stroke takes up space), reverseZ (canvas stacking: true = first on top), \
@@ -61,6 +61,48 @@ pub fn snake(v: &Value) -> Value {
     }
 }
 
+/// `v` as an effect list, refusing keys an effect doesn't read: serde dropped them without a word,
+/// so a shadow given `offsetY` kept the default offset.
+pub fn effects_from(cmd: &str, v: &Value) -> Result<Vec<Effect>> {
+    let effects: Vec<Effect> = serde_json::from_value(snake(v)).map_err(|e| bad(cmd, format!("effects: {e}")))?;
+    for (i, given) in v.as_array().into_iter().flatten().enumerate() {
+        refuse_ignored_effect_keys(cmd, &format!("effects[{i}]"), given, |v| serde_json::from_value(snake(v)).ok())?;
+    }
+    Ok(effects)
+}
+
+/// `p[key]` as one effect, read as serde reads it (its aliases too), refusing keys it doesn't read.
+pub fn effect_from(cmd: &str, p: &Value, key: &str) -> Result<Option<Effect>> {
+    let Some(v) = get(p, key) else { return Ok(None) };
+    let effect: Effect = serde_json::from_value(v.clone()).map_err(|e| bad(cmd, format!("`{key}`: {e}")))?;
+    refuse_ignored_effect_keys(cmd, &format!("`{key}`"), v, |v| serde_json::from_value(v.clone()).ok())?;
+    Ok(Some(effect))
+}
+
+/// Refuse the keys of effect `given` that `parse` ignores, naming the keys the effect takes. Set to
+/// null, a key it reads fails to parse or changes the effect; a key it ignores changes nothing.
+fn refuse_ignored_effect_keys(cmd: &str, at: &str, given: &Value, parse: impl Fn(&Value) -> Option<Effect>) -> Result<()> {
+    let Some(fields) = given.as_object() else { return Ok(()) };
+    let parsed = parse(given);
+    let ignored: Vec<&str> = fields
+        .iter()
+        .filter(|(_, v)| !v.is_null())
+        .filter(|(k, _)| {
+            let mut probe = fields.clone();
+            probe.insert((*k).clone(), Value::Null);
+            parse(&Value::Object(probe)).is_some_and(|e| Some(e) == parsed)
+        })
+        .map(|(k, _)| k.as_str())
+        .collect();
+    if ignored.is_empty() {
+        return Ok(());
+    }
+    let takes = parsed.and_then(|e| serde_json::to_value(e).ok()).map(crate::inspect::camel).unwrap_or_default();
+    let kind = takes.get("type").and_then(Value::as_str).unwrap_or("effect").to_string();
+    let names: Vec<&str> = takes.as_object().into_iter().flatten().map(|(k, _)| k.as_str()).collect();
+    Err(bad(cmd, format!("{at}: unknown properties: {} (a {kind} takes {})", ignored.join(", "), names.join(", "))))
+}
+
 pub(crate) fn enum_of<T: serde::de::DeserializeOwned>(v: &Value) -> Option<T> {
     let s = v.as_str()?;
     // Accept camelCase, snake/upper-case and spaced variants.
@@ -265,18 +307,95 @@ fn ensure_layout(n: &mut Node) -> &mut AutoLayout {
     n.layout.get_or_insert_with(|| AutoLayout { padding: [0.0; 4], gap: 0.0, ..Default::default() })
 }
 
-/// Apply a property map to one node. `x`/`y` are relative to the parent.
-pub fn apply(cmd: &str, doc: &mut Document, id: NodeId, props: &Map<String, Value>) -> Result<()> {
-    let mut unknown = Vec::new();
-    // Geometry keys first so rotation applies to the final size.
-    let order = |k: &str| match k {
+/// The keys that set a frame's auto layout (through [`layout_mut`]).
+pub const LAYOUT_KEYS: &[&str] = &[
+    "gap",
+    "itemSpacing",
+    "columnGap",
+    "crossGap",
+    "counterAxisSpacing",
+    "rowGap",
+    "padding",
+    "paddingTop",
+    "paddingRight",
+    "paddingBottom",
+    "paddingLeft",
+    "paddingHorizontal",
+    "paddingVertical",
+    "mainAlign",
+    "primaryAxisAlignItems",
+    "crossAlign",
+    "counterAxisAlignItems",
+    "contentAlign",
+    "counterAxisAlignContent",
+    "wrap",
+    "gridColumns",
+    "gridRows",
+    "strokesIncluded",
+    "reverseZ",
+    "columnTracks",
+    "gridColumnTracks",
+    "rowTracks",
+    "gridRowTracks",
+];
+
+/// Drop the bindings of auto layout fields (gap, padding…): they go with the auto layout, or
+/// re-applying them would bring it back.
+pub fn drop_layout_bindings(n: &mut Node) {
+    n.bound.retain(|k, _| !LAYOUT_KEYS.contains(&k.as_str()));
+}
+
+/// The auto layout of a frame-like node, created when it has none yet. Other nodes can't hold an
+/// auto layout: an auto layout key on them is refused, not stored where nothing reads it
+/// (`node.set` on several layers skips them instead, see `edit::set`).
+fn layout_mut<'a>(cmd: &str, k: &str, n: &'a mut Node) -> Result<&'a mut AutoLayout> {
+    if !n.kind.is_frame_like() {
+        return Err(bad(
+            cmd,
+            format!(
+                "`{k}` is an auto layout property, and layer {} “{}” is a {} (only frames, components and instances have auto layout)",
+                n.id,
+                n.name,
+                n.kind.type_name()
+            ),
+        ));
+    }
+    Ok(ensure_layout(n))
+}
+
+/// Replace a node's fills (or strokes). Bindings on the paints whose bound values the new list
+/// changed let go, as an explicit edit does (see `lists::rebind_edited_paint`).
+fn set_paints(n: &mut Node, fills: bool, paints: Vec<Paint>) {
+    let old = std::mem::replace(if fills { &mut n.fills } else { &mut n.strokes }, paints);
+    for (i, p) in old.iter().enumerate() {
+        super::lists::rebind_edited_paint(n, fills, i, p);
+    }
+}
+
+/// `"none"` (either case) and null ask for no paint, as an empty `fills`/`strokes` list does.
+fn paint_none(v: &Value) -> bool {
+    v.is_null() || v.as_str().is_some_and(|s| s.eq_ignore_ascii_case("none"))
+}
+
+/// The order [`apply`] takes keys in: geometry first so rotation applies to the final size, style
+/// links after the values so a link wins over values its style sets, variable bindings last so
+/// paints set in the same call don't detach them.
+fn apply_order(k: &str) -> u8 {
+    match k {
         "width" | "height" | "w" | "h" => 0,
         "rotation" => 2,
         "x" | "y" => 3,
+        "fillStyle" | "strokeStyle" | "effectStyle" | "textStyle" | "gridStyle" => 4,
+        "boundVariables" => 5,
         _ => 1,
-    };
+    }
+}
+
+/// Apply a property map to one node. `x`/`y` are relative to the parent.
+pub fn apply(cmd: &str, doc: &mut Document, id: NodeId, props: &Map<String, Value>) -> Result<()> {
+    let mut unknown = Vec::new();
     let mut keys: Vec<(&String, &Value)> = props.iter().collect();
-    keys.sort_by_key(|(k, _)| order(k));
+    keys.sort_by_key(|(k, _)| apply_order(k));
     for (k, v) in keys {
         let k = k.as_str();
         match k {
@@ -348,15 +467,23 @@ pub fn apply(cmd: &str, doc: &mut Document, id: NodeId, props: &Map<String, Valu
                 let b = v.as_str().and_then(figcraft_color::BlendMode::from_name).ok_or_else(|| bad(cmd, "unknown blend mode"))?;
                 doc.get_mut(id)?.blend = b;
             }
-            "fills" => doc.get_mut(id)?.fills = paints_of(v).ok_or_else(|| bad(cmd, "`fills` must be paints or colours"))?,
+            "fills" => set_paints(doc.get_mut(id)?, true, paints_of(v).ok_or_else(|| bad(cmd, "`fills` must be paints or colours"))?),
             "fill" => {
-                let c = color_of(v).ok_or_else(|| bad(cmd, "`fill` must be a colour"))?;
-                doc.get_mut(id)?.fills = vec![Paint::solid(c)];
+                if paint_none(v) {
+                    set_paints(doc.get_mut(id)?, true, vec![]);
+                } else {
+                    let c = color_of(v).ok_or_else(|| bad(cmd, "`fill` must be a colour, \"none\" or null"))?;
+                    set_paints(doc.get_mut(id)?, true, vec![Paint::solid(c)]);
+                }
             }
-            "strokes" => doc.get_mut(id)?.strokes = paints_of(v).ok_or_else(|| bad(cmd, "`strokes` must be paints or colours"))?,
+            "strokes" => set_paints(doc.get_mut(id)?, false, paints_of(v).ok_or_else(|| bad(cmd, "`strokes` must be paints or colours"))?),
             "stroke" => {
-                let c = color_of(v).ok_or_else(|| bad(cmd, "`stroke` must be a colour"))?;
-                doc.get_mut(id)?.strokes = vec![Paint::solid(c)];
+                if paint_none(v) {
+                    set_paints(doc.get_mut(id)?, false, vec![]);
+                } else {
+                    let c = color_of(v).ok_or_else(|| bad(cmd, "`stroke` must be a colour, \"none\" or null"))?;
+                    set_paints(doc.get_mut(id)?, false, vec![Paint::solid(c)]);
+                }
             }
             "strokeWeight" => doc.get_mut(id)?.stroke.weight = f64_of(v).ok_or_else(|| bad(cmd, "`strokeWeight` must be a number"))?.max(0.0),
             "strokeAlign" => doc.get_mut(id)?.stroke.align = enum_of(v).ok_or_else(|| bad(cmd, "strokeAlign: inside|center|outside"))?,
@@ -412,7 +539,7 @@ pub fn apply(cmd: &str, doc: &mut Document, id: NodeId, props: &Map<String, Valu
                 }
             }
             "cornerSmoothing" => doc.get_mut(id)?.corners.smoothing = f64_of(v).unwrap_or(0.0).clamp(0.0, 1.0),
-            "effects" => doc.get_mut(id)?.effects = serde_json::from_value(snake(v)).map_err(|e| bad(cmd, format!("effects: {e}")))?,
+            "effects" => doc.get_mut(id)?.effects = effects_from(cmd, v)?,
             "clip" | "clipsContent" => doc.get_mut(id)?.clip = v.as_bool().ok_or_else(|| bad(cmd, "`clip` must be a boolean"))?,
             "isMask" => doc.get_mut(id)?.is_mask = v.as_bool().unwrap_or(false),
             "devStatus" => {
@@ -421,8 +548,12 @@ pub fn apply(cmd: &str, doc: &mut Document, id: NodeId, props: &Map<String, Valu
                 } else {
                     v.as_str().and_then(|s| DevStatus::ALL.into_iter().find(|d| d.id().eq_ignore_ascii_case(s)))
                 };
+                let st = st.ok_or_else(|| bad(cmd, "devStatus: none|readyForDev|completed"))?;
+                if !st.is_none() && !crate::devinspect::has_status(doc, id) {
+                    return Err(bad(cmd, "devStatus: only sections and frames at the top of a page or section take one"));
+                }
                 let n = doc.get_mut(id)?;
-                n.dev_status = st.ok_or_else(|| bad(cmd, "devStatus: none|readyForDev|completed"))?;
+                n.dev_status = st;
                 // Marking a layer (again) starts from its current contents.
                 n.dev_changed = false;
             }
@@ -436,8 +567,14 @@ pub fn apply(cmd: &str, doc: &mut Document, id: NodeId, props: &Map<String, Valu
                     return Err(bad(cmd, "auto layout needs a frame"));
                 }
                 match v {
-                    Value::Null => n.layout = None,
-                    Value::String(s) if s.eq_ignore_ascii_case("none") => n.layout = None,
+                    Value::Null => {
+                        n.layout = None;
+                        drop_layout_bindings(n);
+                    }
+                    Value::String(s) if s.eq_ignore_ascii_case("none") => {
+                        n.layout = None;
+                        drop_layout_bindings(n);
+                    }
                     Value::String(s) => {
                         let mode = match s.to_ascii_lowercase().as_str() {
                             "horizontal" | "row" => LayoutMode::Horizontal,
@@ -452,56 +589,56 @@ pub fn apply(cmd: &str, doc: &mut Document, id: NodeId, props: &Map<String, Valu
                 }
             }
             "gap" | "itemSpacing" | "columnGap" => {
-                ensure_layout(doc.get_mut(id)?).gap = f64_of(v).ok_or_else(|| bad(cmd, format!("`{k}` must be a number")))?
+                layout_mut(cmd, k, doc.get_mut(id)?)?.gap = f64_of(v).ok_or_else(|| bad(cmd, format!("`{k}` must be a number")))?
             }
             "crossGap" | "counterAxisSpacing" | "rowGap" => {
-                ensure_layout(doc.get_mut(id)?).cross_gap = f64_of(v).ok_or_else(|| bad(cmd, format!("`{k}` must be a number")))?
+                layout_mut(cmd, k, doc.get_mut(id)?)?.cross_gap = f64_of(v).ok_or_else(|| bad(cmd, format!("`{k}` must be a number")))?
             }
             "padding" => {
                 let p = four(v).ok_or_else(|| bad(cmd, "padding: n or [t,r,b,l]"))?;
-                ensure_layout(doc.get_mut(id)?).padding = p.map(|x| x.max(0.0));
+                layout_mut(cmd, k, doc.get_mut(id)?)?.padding = p.map(|x| x.max(0.0));
             }
             "paddingTop" | "paddingRight" | "paddingBottom" | "paddingLeft" => {
                 let i = ["paddingTop", "paddingRight", "paddingBottom", "paddingLeft"].iter().position(|x| *x == k).unwrap_or(0);
                 let val = f64_of(v).ok_or_else(|| bad(cmd, format!("`{k}` must be a number")))?.max(0.0);
-                if let Some(slot) = ensure_layout(doc.get_mut(id)?).padding.get_mut(i) {
+                if let Some(slot) = layout_mut(cmd, k, doc.get_mut(id)?)?.padding.get_mut(i) {
                     *slot = val;
                 }
             }
             "paddingHorizontal" => {
                 let val = f64_of(v).unwrap_or(0.0).max(0.0);
-                let l = ensure_layout(doc.get_mut(id)?);
+                let l = layout_mut(cmd, k, doc.get_mut(id)?)?;
                 l.padding[1] = val;
                 l.padding[3] = val;
             }
             "paddingVertical" => {
                 let val = f64_of(v).unwrap_or(0.0).max(0.0);
-                let l = ensure_layout(doc.get_mut(id)?);
+                let l = layout_mut(cmd, k, doc.get_mut(id)?)?;
                 l.padding[0] = val;
                 l.padding[2] = val;
             }
             "mainAlign" | "primaryAxisAlignItems" => {
-                ensure_layout(doc.get_mut(id)?).main_align =
+                layout_mut(cmd, k, doc.get_mut(id)?)?.main_align =
                     enum_of(v).ok_or_else(|| bad(cmd, "mainAlign: min|center|max|spaceBetween|spaceAround|spaceEvenly"))?
             }
             "crossAlign" | "counterAxisAlignItems" => {
-                ensure_layout(doc.get_mut(id)?).cross_align = enum_of(v).ok_or_else(|| bad(cmd, "crossAlign: min|center|max|baseline"))?
+                layout_mut(cmd, k, doc.get_mut(id)?)?.cross_align = enum_of(v).ok_or_else(|| bad(cmd, "crossAlign: min|center|max|baseline"))?
             }
             "contentAlign" | "counterAxisAlignContent" => {
-                ensure_layout(doc.get_mut(id)?).content_align = enum_of(v).ok_or_else(|| bad(cmd, "contentAlign: auto|spaceBetween"))?
+                layout_mut(cmd, k, doc.get_mut(id)?)?.content_align = enum_of(v).ok_or_else(|| bad(cmd, "contentAlign: auto|spaceBetween"))?
             }
-            "wrap" => ensure_layout(doc.get_mut(id)?).wrap = v.as_bool().unwrap_or(false),
+            "wrap" => layout_mut(cmd, k, doc.get_mut(id)?)?.wrap = v.as_bool().unwrap_or(false),
             "gridColumns" | "gridRows" => {
                 let count = f64_of(v).ok_or_else(|| bad(cmd, format!("`{k}` must be a number")))?.clamp(1.0, 1000.0) as u32;
-                let l = ensure_layout(doc.get_mut(id)?);
+                let l = layout_mut(cmd, k, doc.get_mut(id)?)?;
                 // Tracks past the new count go away (new tracks are 1fr).
                 let (n, tracks) =
                     if k == "gridColumns" { (&mut l.grid_columns, &mut l.column_tracks) } else { (&mut l.grid_rows, &mut l.row_tracks) };
                 *n = count;
                 tracks.truncate(count as usize);
             }
-            "strokesIncluded" => ensure_layout(doc.get_mut(id)?).strokes_included = v.as_bool().unwrap_or(false),
-            "reverseZ" => ensure_layout(doc.get_mut(id)?).reverse_z = v.as_bool().unwrap_or(false),
+            "strokesIncluded" => layout_mut(cmd, k, doc.get_mut(id)?)?.strokes_included = v.as_bool().unwrap_or(false),
+            "reverseZ" => layout_mut(cmd, k, doc.get_mut(id)?)?.reverse_z = v.as_bool().unwrap_or(false),
             "sizingH" | "layoutSizingHorizontal" => {
                 let s = sizing(v).ok_or_else(|| bad(cmd, "sizing: fixed|hug|fill"))?;
                 set_sizing(cmd, doc, id, s, true)?;
@@ -533,7 +670,7 @@ pub fn apply(cmd: &str, doc: &mut Document, id: NodeId, props: &Map<String, Valu
             "columnTracks" | "gridColumnTracks" | "rowTracks" | "gridRowTracks" => {
                 let a = v.as_array().ok_or_else(|| bad(cmd, format!("`{k}` must be an array of tracks")))?;
                 let tracks = a.iter().map(track_of).collect::<Option<Vec<_>>>().ok_or_else(|| bad(cmd, TRACK_HELP))?;
-                let l = ensure_layout(doc.get_mut(id)?);
+                let l = layout_mut(cmd, k, doc.get_mut(id)?)?;
                 if k.contains("olumn") {
                     l.grid_columns = (tracks.len() as u32).clamp(1, 1000);
                     l.column_tracks = tracks;
@@ -725,10 +862,15 @@ pub fn apply(cmd: &str, doc: &mut Document, id: NodeId, props: &Map<String, Valu
                     for (field, var) in o {
                         match var.as_str() {
                             Some(vid) => {
+                                if n.bound.get(field).map(String::as_str) != Some(vid) {
+                                    crate::cmd::styles::rebind_paint_alpha(&mut n.fills, &mut n.strokes, field, true);
+                                }
                                 n.bound.insert(field.clone(), vid.to_string());
                             }
                             None => {
-                                n.bound.remove(field);
+                                if n.bound.remove(field).is_some() {
+                                    crate::cmd::styles::rebind_paint_alpha(&mut n.fills, &mut n.strokes, field, false);
+                                }
                             }
                         }
                     }
@@ -783,12 +925,14 @@ pub fn apply(cmd: &str, doc: &mut Document, id: NodeId, props: &Map<String, Valu
     if !unknown.is_empty() {
         return Err(bad(cmd, format!("unknown properties: {} (known: {KEYS})", unknown.join(", "))));
     }
-    // Inside an instance, record which property groups were overridden (an instance's own export
-    // settings and interactions are its own, not overrides).
+    // Inside an instance, record which property groups were overridden (an instance's own
+    // resizing, export settings and interactions are its own, not overrides).
     let own_root = matches!(doc.get(id)?.kind, NodeKind::Instance { .. }) && !crate::components::inside_instance(doc, id);
     let n = doc.get_mut(id)?;
     if n.source.is_some() {
-        for g in props.keys().map(|k| override_group(k)).filter(|g| *g != "other" && !(own_root && matches!(*g, "exports" | "interactions"))) {
+        for g in
+            props.keys().map(|k| override_group(k)).filter(|g| *g != "other" && !(own_root && matches!(*g, "resizing" | "exports" | "interactions")))
+        {
             n.overrides.insert(g.to_string());
         }
     }
@@ -810,7 +954,8 @@ pub fn override_group(k: &str) -> &'static str {
         "features" | "fontFeatures" | "openTypeFeatures" | "listStyle" | "indentation" | "listSpacing" | "maxLines" | "variationSettings"
         | "hangingPunctuation" | "hangingList" => "textStyle",
         "cornerRadius" | "cornerSmoothing" | "topLeftRadius" | "topRightRadius" | "bottomRightRadius" | "bottomLeftRadius" => "corners",
-        "width" | "height" | "w" | "h" | "sizingH" | "sizingV" => "size",
+        "width" | "height" | "w" | "h" => "size",
+        "sizingH" | "sizingV" | "layoutSizingHorizontal" | "layoutSizingVertical" | "minWidth" | "maxWidth" | "minHeight" | "maxHeight" => "resizing",
         "gap" | "itemSpacing" | "columnGap" | "crossGap" | "counterAxisSpacing" | "rowGap" => "gap",
         "padding" | "paddingTop" | "paddingRight" | "paddingBottom" | "paddingLeft" | "paddingHorizontal" | "paddingVertical" => "padding",
         "mainAlign" | "primaryAxisAlignItems" | "crossAlign" | "counterAxisAlignItems" | "contentAlign" | "counterAxisAlignContent" => "alignment",
diff --git a/crates/engine/src/cmd/section.rs b/crates/engine/src/cmd/section.rs
index ac7fb1eec..08a5a7cc8 100644
--- a/crates/engine/src/cmd/section.rs
+++ b/crates/engine/src/cmd/section.rs
@@ -34,7 +34,7 @@ pub fn specs() -> Vec<CommandSpec> {
         spec!(
             "dev.compare",
             "Compare changes",
-            "{id? (default the first selected layer), show? (open the compare view in the app)} → {id, name, changed, snapshot, added, removed, modified, truncated, changes: [{id, name, type, change: added|removed|changed, depth, layers, properties?: [{section, property, before, after, text}]}]}  what changed in a ready-for-dev frame or section since it was marked (`snapshot` is false when that isn't known: a file from before snapshots were kept)",
+            "{id? (default the first selected layer), version? (a version id from version.list: compare with that saved version instead; any top-level frame or section), show? (open the compare view in the app)} → {id, name, changed, snapshot, added, removed, modified, truncated, version: {id, name, time} | null, changes: [{id, name, type, change: added|removed|changed, depth, layers, properties?: [{section, property, before, after, text}]}]}  what changed in a ready-for-dev frame or section since it was marked, or since the version (`snapshot` is false when that isn't known: a file from before snapshots were kept)",
             false,
             compare
         ),
@@ -104,14 +104,30 @@ fn resolve_change(s: &mut Session, p: &Value) -> Result<Value> {
 fn compare(s: &mut Session, p: &Value) -> Result<Value> {
     let cmd = "dev.compare";
     let id = targets(s, p).first().copied().ok_or_else(|| bad(cmd, "select a frame or section or pass `id`"))?;
-    let doc = s.doc()?;
+    let version = match get(p, "version") {
+        None | Some(Value::Null) => None,
+        Some(Value::String(v)) => Some(v.clone()),
+        Some(_) => return Err(bad(cmd, "version: a version id (version.list)")),
+    };
+    let ds = s.ds()?;
+    let doc = &ds.doc;
     let n = doc.node(id).ok_or_else(|| bad(cmd, "no such layer"))?;
-    if !has_status(doc, id) || n.dev_status != DevStatus::ReadyForDev {
-        return Err(bad(cmd, "compare a frame or section marked ready for dev"));
+    if !has_status(doc, id) {
+        return Err(bad(cmd, "compare a top-level frame or a section"));
     }
-    let v = serde_json::to_value(crate::devcompare::compare(doc, id)).unwrap_or(Value::Null);
+    let (cmp, against) = match &version {
+        Some(v) => {
+            let ver = ds.versions.iter().find(|x| x.id == *v).ok_or_else(|| bad(cmd, format!("no version `{v}`")))?;
+            let before = crate::cmd::file::read_version(ver)?;
+            (crate::devcompare::compare_with(&before, doc, id), json!({"id": ver.id, "name": ver.name, "time": ver.time}))
+        }
+        None if n.dev_status != DevStatus::ReadyForDev => return Err(bad(cmd, "compare a frame or section marked ready for dev, or pass `version`")),
+        None => (crate::devcompare::compare(doc, id), Value::Null),
+    };
+    let mut v = serde_json::to_value(cmp).unwrap_or(Value::Null);
+    v["version"] = against;
     if boolean(p, "show") == Some(true) {
-        s.request_ui("view.devCompare", json!({"id": id}));
+        s.request_ui("view.devCompare", json!({"id": id, "version": version}));
     }
     Ok(v)
 }
diff --git a/crates/engine/src/cmd/structure.rs b/crates/engine/src/cmd/structure.rs
index bed70d3df..28a242af4 100644
--- a/crates/engine/src/cmd/structure.rs
+++ b/crates/engine/src/cmd/structure.rs
@@ -10,11 +10,13 @@ use super::{CommandSpec, ok};
 use crate::params::*;
 use crate::{EngineError, Result, Session, bad, spec};
 
+/// The layer structure commands: group, frame, mask, boolean operations, flatten, auto layout
+/// add/remove, move to page and vector path edits.
 pub fn specs() -> Vec<CommandSpec> {
     vec![
-        spec!("object.group", "Group selection", "{ids?, name?}", true, |s, p| wrap(s, p, Wrap::Group)),
+        spec!("object.group", "Group selection", "{ids?, name?}", true, |s, p| wrap(s, p, "object.group", Wrap::Group)),
         spec!("object.ungroup", "Ungroup selection", "{ids?}", true, ungroup),
-        spec!("object.frameSelection", "Frame selection", "{ids?, name?}", true, |s, p| wrap(s, p, Wrap::Frame)),
+        spec!("object.frameSelection", "Frame selection", "{ids?, name?}", true, |s, p| wrap(s, p, "object.frameSelection", Wrap::Frame)),
         spec!("object.removeFrame", "Remove frame", "{ids?}", true, ungroup),
         spec!(
             "object.convertToGroup",
@@ -26,16 +28,23 @@ pub fn specs() -> Vec<CommandSpec> {
         spec!(
             "object.convertToFrame",
             "Convert to frame",
-            "{ids?} (groups become frames of the same box in place, their layers staying where they are: no fill, not clipping. Frames are left alone; instances, main components and layers inside instances are refused)",
+            "{ids?} (groups become frames of the same box in place, their layers staying where they are: no fill, not clipping; sections become frames that keep their fill and don't clip. Frames are left alone; instances, main components, layers inside instances and sections holding sections are refused)",
             true,
             |s, p| convert(s, p, "object.convertToFrame", true)
         ),
+        spec!(
+            "object.convertToSection",
+            "Convert to section",
+            "{ids?} (frames on the page or in a section become sections in place, keeping their fill and layers; what only a frame has goes: auto layout, clipping, layout grids, guides and scrolling. Sections are left alone; nested frames, instances and main components are refused)",
+            true,
+            convert_to_section
+        ),
         spec!(
             "object.wrapInSection",
             "Wrap in new section",
             "{ids?, name?} (layers on the page or in a section; the section wraps them with some room)",
             true,
-            |s, p| wrap(s, p, Wrap::Section)
+            |s, p| wrap(s, p, "object.wrapInSection", Wrap::Section)
         ),
         spec!(
             "object.resizeToFit",
@@ -64,7 +73,9 @@ pub fn specs() -> Vec<CommandSpec> {
                 // Hugging needs auto layout and the children that filled have nothing to fill: both
                 // become fixed (the frame keeps filling its own auto layout parent).
                 let doc = s.doc_mut()?;
-                doc.get_mut(i)?.layout = None;
+                let n = doc.get_mut(i)?;
+                n.layout = None;
+                super::props::drop_layout_bindings(n);
                 figcraft_layout::coherent_sizing(doc, i);
             }
             ok()
@@ -96,6 +107,20 @@ pub fn specs() -> Vec<CommandSpec> {
             }
             ok()
         }),
+        spec!(
+            "vector.fillRule",
+            "Set fill rule",
+            "{ids? | id?, region? (a filled area of a vector; every area when left out), rule: nonZero|evenOdd}",
+            true,
+            fill_rule
+        ),
+        spec!(
+            "vector.reverseLoop",
+            "Reverse loop",
+            "{ids? | id?, region, loop} (a loop of a filled area; its direction flips, which changes how the area fills)",
+            true,
+            reverse_loop
+        ),
         spec!("vector.simplify", "Simplify vector", "{ids?, tolerance?}", true, simplify),
         spec!("vector.offset", "Offset path", "{ids?, offset}", true, offset_path),
         spec!("vector.join", "Join selection", "{ids?} (in vector edit mode: joins the selected points)", true, |s, p| {
@@ -121,26 +146,27 @@ const SECTION_PAD: f64 = 40.0;
 const BOOL_PARAMS: &str = "{ids?} — layers inside boolean groups: sets their own operation (how each combines with the operands below it); one boolean group: sets its operation (every operand follows it); otherwise wraps the layers in a new boolean group";
 
 /// Wrap the selection in a new boolean group doing `op`.
-pub(crate) fn wrap_boolean(s: &mut Session, p: &Value, op: BoolOp) -> Result<Value> {
-    wrap(s, p, Wrap::Bool(op))
+pub(crate) fn wrap_boolean(s: &mut Session, p: &Value, cmd: &str, op: BoolOp) -> Result<Value> {
+    wrap(s, p, cmd, Wrap::Bool(op))
 }
 
-/// Wrap the selection in a new container at the topmost selected layer's place.
-fn wrap(s: &mut Session, p: &Value, w: Wrap) -> Result<Value> {
-    let ids = req_targets("object.group", s, p)?;
+/// Wrap the selection in a new container at the topmost selected layer's place. Errors name `cmd`,
+/// the command that asked.
+fn wrap(s: &mut Session, p: &Value, cmd: &str, w: Wrap) -> Result<Value> {
+    let ids = req_targets(cmd, s, p)?;
     let doc = s.doc_mut()?;
     let ids = z_sorted(doc, &roots(doc, &ids));
-    let top = *ids.last().ok_or_else(|| bad("object.group", "nothing selected"))?;
-    let parent = doc.get(top)?.parent.ok_or_else(|| bad("object.group", "can't group a page"))?;
+    let top = *ids.last().ok_or_else(|| bad(cmd, "nothing selected"))?;
+    let parent = doc.get(top)?.parent.ok_or_else(|| bad(cmd, "can't group a page"))?;
     // Sections sit on the page or in sections, never in frames or groups.
     let board = |doc: &Document, i: NodeId| {
         doc.node(i).and_then(|n| n.parent).and_then(|p| doc.node(p)).is_some_and(|p| p.is_page() || matches!(p.kind, NodeKind::Section { .. }))
     };
     if matches!(w, Wrap::Section) && !ids.iter().all(|i| board(doc, *i)) {
-        return Err(bad("object.wrapInSection", "only layers on the page or in a section can be wrapped in a section"));
+        return Err(bad(cmd, "only layers on the page or in a section can be wrapped in a section"));
     }
     if !matches!(w, Wrap::Section) && ids.iter().any(|i| doc.node(*i).is_some_and(|n| matches!(n.kind, NodeKind::Section { .. }))) {
-        return Err(bad("object.group", "sections can't go in groups or frames"));
+        return Err(bad(cmd, "sections can't go in groups or frames"));
     }
     let index = doc.index_in_parent(top).map(|i| i + 1);
     let mut bounds = doc.bounds_of(&ids).unwrap_or_default();
@@ -199,6 +225,13 @@ fn convert(s: &mut Session, p: &Value, cmd: &'static str, to_frame: bool) -> Res
         let n = doc.get(i)?;
         let refuse = |why: &str| Err(bad(cmd, format!("\"{}\" {why}", n.name)));
         match (&n.kind, to_frame) {
+            // A frame can't hold sections.
+            (NodeKind::Section { .. }, true)
+                if n.children.iter().any(|c| doc.node(*c).is_some_and(|c| matches!(c.kind, NodeKind::Section { .. }))) =>
+            {
+                return refuse("holds sections, which can't go inside a frame: convert those first");
+            }
+            (NodeKind::Section { .. }, true) => todo.push(i),
             (NodeKind::Instance { .. }, _) => return refuse("is an instance: its layers come from its main component (detach it first)"),
             (NodeKind::Component { .. }, _) => return refuse("is a main component, which stays a frame"),
             (NodeKind::Frame | NodeKind::Group, _) if crate::components::owning_instance(doc, i).is_some() => {
@@ -212,12 +245,15 @@ fn convert(s: &mut Session, p: &Value, cmd: &'static str, to_frame: bool) -> Res
     }
     for i in &todo {
         if to_frame {
-            // The group's box as it is; nothing painted or clipped, so the look stays.
+            // The box as it is and nothing clipped, so the look stays: a group has nothing painted, a
+            // section keeps its fill.
             let n = doc.get_mut(*i)?;
+            if matches!(n.kind, NodeKind::Group) {
+                n.fills.clear();
+                n.strokes.clear();
+            }
             n.kind = NodeKind::Frame;
             n.clip = false;
-            n.fills.clear();
-            n.strokes.clear();
             continue;
         }
         let n = doc.get_mut(*i)?;
@@ -242,6 +278,43 @@ fn convert(s: &mut Session, p: &Value, cmd: &'static str, to_frame: bool) -> Res
     Ok(json!({"ids": todo}))
 }
 
+/// Frames on the page or in a section become sections in place (sections only sit there).
+fn convert_to_section(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "object.convertToSection";
+    let ids = req_targets(cmd, s, p)?;
+    let doc = s.doc_mut()?;
+    let mut todo = Vec::new();
+    for i in ids {
+        let n = doc.get(i)?;
+        let refuse = |why: &str| Err(bad(cmd, format!("\"{}\" {why}", n.name)));
+        let on_board = n.parent.and_then(|p| doc.node(p)).is_some_and(|p| p.is_page() || matches!(p.kind, NodeKind::Section { .. }));
+        match &n.kind {
+            NodeKind::Section { .. } => {}
+            NodeKind::Instance { .. } => return refuse("is an instance: its layers come from its main component (detach it first)"),
+            NodeKind::Component { .. } | NodeKind::ComponentSet { .. } => return refuse("is a main component, which stays a frame"),
+            NodeKind::Frame if !on_board => return refuse("is inside a frame or group: only frames on the page or in a section become sections"),
+            NodeKind::Frame => todo.push(i),
+            _ => return refuse("is not a frame"),
+        }
+    }
+    for i in &todo {
+        let n = doc.get_mut(*i)?;
+        n.kind = NodeKind::Section { contents_hidden: false };
+        (n.layout, n.clip, n.overflow) = (None, false, proto::Overflow::None);
+        n.grids.clear();
+        n.guides.clear();
+        n.styles.grid = None;
+        super::props::drop_layout_bindings(n);
+        let kids = n.children.clone();
+        for k in kids {
+            // Out of the flow there is nothing to fill or to be absolute against.
+            doc.get_mut(k)?.child_layout.absolute = false;
+        }
+        figcraft_layout::coherent_sizing(doc, *i);
+    }
+    Ok(json!({"ids": todo}))
+}
+
 fn ungroup(s: &mut Session, p: &Value) -> Result<Value> {
     let ids = req_targets("object.ungroup", s, p)?;
     let doc = s.doc_mut()?;
@@ -284,7 +357,7 @@ fn mask(s: &mut Session, p: &Value) -> Result<Value> {
         return ok();
     }
     // Group, then the bottom-most child is the mask.
-    let r = wrap(s, &json!({"ids": ids, "name": "Mask group"}), Wrap::Group)?;
+    let r = wrap(s, &json!({"ids": ids, "name": "Mask group"}), "object.mask", Wrap::Group)?;
     let gid = id_of(&r["id"]).ok_or_else(|| EngineError::Other("group failed".into()))?;
     let doc = s.doc_mut()?;
     if let Some(first) = doc.get(gid)?.children.first().copied() {
@@ -309,33 +382,46 @@ fn flatten(s: &mut Session, p: &Value) -> Result<Value> {
     let parent = doc.get(top)?.parent.ok_or_else(|| bad("vector.flatten", "can't flatten a page"))?;
     let index = doc.index_in_parent(top).map(|i| i + 1);
     let pw = doc.world_transform(parent);
-    let mut path = BezPath::new();
-    let mut even = false;
+    let mut net = VectorNetwork::default();
     for i in &ids {
         let Some(n) = doc.node(*i) else { continue };
-        // Booleans flatten to their result; strokes don't get outlined.
-        let Some((mut op, rule)) = (match &n.kind {
-            NodeKind::Group | NodeKind::Frame | NodeKind::Component { .. } | NodeKind::Instance { .. } => figcraft_render::subtree_outline(doc, n, 0),
-            _ => figcraft_render::node_outline(doc, n),
-        }) else {
-            continue;
+        // Vectors keep their own network (open paths and unfilled loops have no fill outline);
+        // booleans flatten to their result; strokes don't get outlined.
+        let mut part = match &n.kind {
+            NodeKind::Vector { network } => network.clone(),
+            _ => {
+                let Some((op, rule)) = (match &n.kind {
+                    NodeKind::Group | NodeKind::Frame | NodeKind::Component { .. } | NodeKind::Instance { .. } => {
+                        figcraft_render::subtree_outline(doc, n, 0)
+                    }
+                    _ => figcraft_render::node_outline(doc, n),
+                }) else {
+                    continue;
+                };
+                let mut part = VectorNetwork::from_path(&op);
+                if rule == figcraft_render::FillRule::EvenOdd {
+                    for r in &mut part.regions {
+                        r.winding = WindingRule::EvenOdd;
+                    }
+                }
+                part
+            }
         };
-        even |= rule == figcraft_render::FillRule::EvenOdd;
         // Into the common parent's space.
-        let w = doc.world_transform(*i);
-        op.apply_affine(pw.inverse() * w);
-        path.extend(op.elements().iter().copied());
+        let all: Vec<usize> = (0..part.vertices.len()).collect();
+        crate::vectoredit::ops::transform_vertices(&mut part, &all, pw.inverse() * doc.world_transform(*i));
+        let (nv, ns) = (net.vertices.len(), net.segments.len());
+        net.vertices.extend(part.vertices);
+        net.segments.extend(part.segments.into_iter().map(|s| Segment { a: s.a + nv, b: s.b + nv, ..s }));
+        net.regions.extend(
+            part.regions.into_iter().map(|r| Region { loops: r.loops.into_iter().map(|l| l.into_iter().map(|s| s + ns).collect()).collect(), ..r }),
+        );
     }
-    if path.elements().is_empty() {
+    let Some(bb) = net.bounds() else {
         return Err(EngineError::Disabled("vector.flatten".into(), "nothing to flatten".into()));
-    }
+    };
     let first = ids.first().and_then(|i| doc.node(*i)).cloned();
-    let bb = path.bounding_box();
-    path.apply_affine(Affine::translate((-bb.x0, -bb.y0)));
-    let mut net = VectorNetwork::from_path(&path);
-    for r in &mut net.regions {
-        r.winding = if even { WindingRule::EvenOdd } else { WindingRule::NonZero };
-    }
+    net.translate(-bb.x0, -bb.y0);
     let vid = doc.alloc_id();
     let name = first.as_ref().map(|f| f.name.clone()).unwrap_or_else(|| "Vector".into());
     let mut v = Node::new(vid, NodeKind::Vector { network: net }, name, bb.width(), bb.height());
@@ -405,7 +491,7 @@ fn outline_stroke(s: &mut Session, p: &Value) -> Result<Value> {
                 let f = doc.get_mut(fill_id)?;
                 f.strokes.clear();
             }
-            let r = wrap(s, &json!({"ids": [fill_id, vid], "name": n.name}), Wrap::Group)?;
+            let r = wrap(s, &json!({"ids": [fill_id, vid], "name": n.name}), "vector.outlineStroke", Wrap::Group)?;
             if let Some(g) = id_of(&r["id"]) {
                 out.push(g);
             }
@@ -452,7 +538,7 @@ fn layout_add(s: &mut Session, p: &Value) -> Result<Value> {
         ids
     } else {
         // Wrap non-frames in a new frame without a fill, then add auto layout to it.
-        let r = wrap(s, &json!({"ids": ids}), Wrap::Frame)?;
+        let r = wrap(s, &json!({"ids": ids}), "layout.add", Wrap::Frame)?;
         let fid = id_of(&r["id"]).ok_or_else(|| EngineError::Other("wrap failed".into()))?;
         let f = s.doc_mut()?.get_mut(fid)?;
         f.fills.clear();
@@ -477,11 +563,16 @@ fn layout_add(s: &mut Session, p: &Value) -> Result<Value> {
             let pb = doc.node(*b).map(|n| figcraft_geom::transform_rect_bbox(n.transform, n.local_rect())).unwrap_or_default();
             if vertical { pa.y0.total_cmp(&pb.y0) } else { pa.x0.total_cmp(&pb.x0) }
         });
+        let empty = doc.node(*f).is_some_and(|n| n.children.iter().filter_map(|c| doc.node(*c)).all(|c| !c.visible || c.child_layout.absolute));
         let n = doc.get_mut(*f)?;
         n.children = kids;
         n.layout = Some(al);
-        n.child_layout.sizing_h = Sizing::Hug;
-        n.child_layout.sizing_v = Sizing::Hug;
+        if !all_frames || !empty {
+            // A frame wrapped around the selection hugs it; an existing frame with no flow
+            // children keeps its size instead of collapsing to its padding.
+            n.child_layout.sizing_h = Sizing::Hug;
+            n.child_layout.sizing_v = Sizing::Hug;
+        }
     }
     s.set_selection(targets.clone());
     Ok(json!({"ids": targets}))
@@ -556,6 +647,10 @@ fn offset_path(s: &mut Session, p: &Value) -> Result<Value> {
     for i in req_targets("vector.offset", s, p)? {
         let doc = s.doc_mut()?;
         let n = doc.get(i)?.clone();
+        // A vector can't hold children: leave containers (frames, groups, instances) alone.
+        if !n.children.is_empty() {
+            continue;
+        }
         let Some((path, _)) = figcraft_render::node_outline(doc, &n) else { continue };
         let props = StrokeProps { weight: d.abs() * 2.0, join: StrokeJoin::Round, align: StrokeAlign::Center, ..Default::default() };
         let ring = figcraft_pathops::stroke_center(&path, d.abs() * 2.0, &props);
@@ -648,3 +743,146 @@ fn resize_to_fit(s: &mut Session, p: &Value) -> Result<Value> {
     }
     Ok(json!({"ids": fitted}))
 }
+
+/// The vector network of `id`, when it is a vector layer.
+fn network_mut(doc: &mut Document, id: NodeId) -> Option<&mut VectorNetwork> {
+    match &mut doc.get_mut(id).ok()?.kind {
+        NodeKind::Vector { network } => Some(network),
+        _ => None,
+    }
+}
+
+/// The id a fill rule is written as.
+fn rule_id(rule: WindingRule) -> &'static str {
+    match rule {
+        WindingRule::NonZero => "nonZero",
+        WindingRule::EvenOdd => "evenOdd",
+    }
+}
+
+/// `region` as an index: absent (or null) means every area.
+fn area_index(cmd: &str, p: &Value) -> Result<Option<usize>> {
+    match get(p, "region") {
+        None | Some(Value::Null) => Ok(None),
+        Some(v) => {
+            let k = f64_of(v).ok_or_else(|| bad(cmd, "`region` must be a number"))?;
+            if !(0.0..1e9).contains(&k) || k.fract() != 0.0 {
+                return Err(bad(cmd, "`region` out of range"));
+            }
+            Ok(Some(k as usize))
+        }
+    }
+}
+
+/// Segments another one- or two-segment loop lists: a short loop takes its direction from the ends
+/// its segments are stored with, so re-storing one of those would turn that loop round too. A loop
+/// of three or more segments is left out: its ring is walked in list order, which the stored ends
+/// don't decide.
+fn short_loop_segments(net: &VectorNetwork, skip: (usize, usize)) -> std::collections::HashSet<usize> {
+    let mut out = std::collections::HashSet::new();
+    for (r, region) in net.regions.iter().enumerate() {
+        for (l, lp) in region.loops.iter().enumerate() {
+            if (r, l) != skip && lp.len() <= 2 {
+                out.extend(lp.iter().copied());
+            }
+        }
+    }
+    out
+}
+
+fn fill_rule(s: &mut Session, p: &Value) -> Result<Value> {
+    let ids = req_targets("vector.fillRule", s, p)?;
+    let rule = match string(p, "rule").as_deref().map(str::trim) {
+        Some("evenOdd" | "evenodd" | "EVENODD") => WindingRule::EvenOdd,
+        Some("nonZero" | "nonzero" | "NONZERO") => WindingRule::NonZero,
+        _ => return Err(bad("vector.fillRule", "`rule` is nonZero or evenOdd")),
+    };
+    let only = area_index("vector.fillRule", p)?;
+    let doc = s.doc_mut()?;
+    let mut count = 0usize;
+    for id in ids {
+        let Some(net) = network_mut(doc, id) else { continue };
+        match only {
+            Some(r) => {
+                if let Some(region) = net.regions.get_mut(r) {
+                    region.winding = rule;
+                    count += 1;
+                }
+            }
+            None => {
+                for region in &mut net.regions {
+                    region.winding = rule;
+                    count += 1;
+                }
+            }
+        }
+    }
+    if count == 0 {
+        return Err(EngineError::Disabled("vector.fillRule".into(), "no filled area to set (select a vector)".into()));
+    }
+    Ok(json!({"regions": count, "rule": rule_id(rule)}))
+}
+
+/// One loop of a vector, worked out but not yet written back: its segments in the new order and,
+/// for a loop of one or two segments, the one to store the other way.
+struct LoopFlip {
+    id: NodeId,
+    turned: Vec<usize>,
+    store: Option<usize>,
+}
+
+/// Turn one loop of a filled area round: its segments are walked the other way, so the area it
+/// bounds counts the other way in the winding (which turns a hole into a filled part and back).
+///
+/// How a loop is walked depends on how many segments it has:
+/// - three or more: the order they are listed in, each segment turned to continue from the point
+///   reached. Reversing the list is therefore enough, and the stored ends are left alone (a shared
+///   segment's ends belong to its neighbour too);
+/// - two: the same ring either way round, so one of the two has to be stored the other way instead;
+/// - one: only its stored ends say which way it runs, so they are swapped.
+///
+/// A short loop can only turn round by re-storing a segment, which is refused when another short
+/// loop lists that segment too: it would turn that area round as well.
+fn reverse_loop(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "vector.reverseLoop";
+    let ids = req_targets(cmd, s, p)?;
+    let region = req_index(cmd, p, "region")?;
+    let index = req_index(cmd, p, "loop")?;
+    let doc = s.doc_mut()?;
+    // Work every loop out before touching the document: one that can't turn round refuses the call
+    // and the others stay as they were.
+    let mut flips: Vec<LoopFlip> = Vec::new();
+    for id in ids {
+        let Some(NodeKind::Vector { network }) = doc.node(id).map(|n| &n.kind) else { continue };
+        let Some(loop_) = network.regions.get(region).and_then(|r| r.loops.get(index)) else { continue };
+        if loop_.is_empty() {
+            continue;
+        }
+        let mut store = None;
+        if loop_.len() <= 2 {
+            let busy = short_loop_segments(network, (region, index));
+            let Some(pick) = loop_.iter().copied().filter(|s| !busy.contains(s)).min() else {
+                return Err(EngineError::Disabled(
+                    cmd.into(),
+                    "the loop shares its segments with another one- or two-segment loop, so turning it round would turn that one round too".into(),
+                ));
+            };
+            store = Some(pick);
+        }
+        flips.push(LoopFlip { id, turned: loop_.iter().rev().copied().collect(), store });
+    }
+    if flips.is_empty() {
+        return Err(EngineError::Disabled(cmd.into(), "no such loop (select a vector with filled areas)".into()));
+    }
+    for LoopFlip { id, turned, store } in flips {
+        let Some(net) = network_mut(doc, id) else { continue };
+        if let Some(seg) = store.and_then(|i| net.segments.get_mut(i)) {
+            std::mem::swap(&mut seg.a, &mut seg.b);
+            std::mem::swap(&mut seg.ta, &mut seg.tb);
+        }
+        if let Some(l) = net.regions.get_mut(region).and_then(|r| r.loops.get_mut(index)) {
+            *l = turned;
+        }
+    }
+    Ok(json!({"reversed": true}))
+}
diff --git a/crates/engine/src/cmd/styles.rs b/crates/engine/src/cmd/styles.rs
index 552a44cfb..dd93bac38 100644
--- a/crates/engine/src/cmd/styles.rs
+++ b/crates/engine/src/cmd/styles.rs
@@ -110,16 +110,26 @@ pub fn specs() -> Vec<CommandSpec> {
             ))
         }),
         spec!("variable.createCollection", "Create variable collection", "{name, modes? [names]}", true, |s, p| {
-            let name = req_string("variable.createCollection", p, "name")?;
-            let doc = s.doc_mut()?;
-            if doc.variables.collections.iter().any(|c| c.name == name) {
-                return Err(bad("variable.createCollection", format!("a collection named `{name}` already exists")));
+            let cmd = "variable.createCollection";
+            let name = req_string(cmd, p, "name")?.trim().to_string();
+            if name.is_empty() {
+                return Err(bad(cmd, "name can't be empty"));
             }
-            let id = doc.new_collection_id();
             let modes: Vec<String> = match get(p, "modes") {
-                Some(Value::Array(a)) => a.iter().filter_map(|m| m.as_str().map(str::to_string)).collect(),
+                Some(Value::Array(a)) => a.iter().filter_map(|m| m.as_str().map(|m| m.trim().to_string())).collect(),
                 _ => vec!["Mode 1".into()],
             };
+            if modes.is_empty() {
+                return Err(bad(cmd, "a collection needs at least one mode"));
+            }
+            if modes.iter().any(String::is_empty) {
+                return Err(bad(cmd, "mode names can't be empty"));
+            }
+            let doc = s.doc_mut()?;
+            if doc.variables.collections.iter().any(|c| c.name == name) {
+                return Err(bad(cmd, format!("a collection named `{name}` already exists")));
+            }
+            let id = doc.new_collection_id();
             let modes = modes.into_iter().enumerate().map(|(i, m)| Mode { id: format!("{id}/mode{}", i + 1), name: m }).collect();
             doc.variables.collections.push(Collection { id: id.clone(), name, modes, extends: None });
             Ok(json!({"id": id}))
@@ -458,10 +468,19 @@ fn bind_style(s: &mut Session, p: &Value) -> Result<Value> {
     match var {
         Some((_, kind)) if kind != want => return Err(bad(cmd, format!("`{field}` takes a {} variable, not a {} one", want.id(), kind.id()))),
         Some((id, _)) => {
+            if style.bound.get(&key) != Some(&id)
+                && let StyleKind::Paint { paints } = &mut style.kind
+            {
+                rebind_paint_alpha(paints, &mut [], &key, true);
+            }
             style.bound.insert(key, id);
         }
         None => {
-            style.bound.remove(&key);
+            if style.bound.remove(&key).is_some()
+                && let StyleKind::Paint { paints } = &mut style.kind
+            {
+                rebind_paint_alpha(paints, &mut [], &key, false);
+            }
         }
     }
     // The style takes its default-mode value, and each layer using it its own.
@@ -770,16 +789,49 @@ pub fn bind(s: &mut Session, p: &Value) -> Result<Value> {
         let n = doc.get_mut(i)?;
         match &vid {
             Some(v) => {
+                if n.bound.get(&field) != Some(v) {
+                    rebind_paint_alpha(&mut n.fills, &mut n.strokes, &field, true);
+                }
                 n.bound.insert(field.clone(), v.clone());
             }
             None => {
-                n.bound.remove(&field);
+                if n.bound.remove(&field).is_some() {
+                    rebind_paint_alpha(&mut n.fills, &mut n.strokes, &field, false);
+                }
             }
         }
     }
     ok()
 }
 
+/// A colour variable bound to a solid paint owns its whole colour, alpha included. Binding restarts
+/// an opacity that holds the alpha a typed colour had (see `Paint::solid`) at 1, so the variable's
+/// alpha applies once; an opacity set on its own, before or while bound, multiplies on top and
+/// stays. Unbinding moves the colour's alpha back into the opacity, where a typed colour keeps it.
+pub(crate) fn rebind_paint_alpha(fills: &mut [Paint], strokes: &mut [Paint], field: &str, bind: bool) {
+    use super::lists::{BoundList, list_binding};
+    let Some((list, i, "color")) = list_binding(field) else { return };
+    let paints = match list {
+        BoundList::Fills => fills,
+        BoundList::Strokes => strokes,
+        _ => return,
+    };
+    if let Some(p) = paints.get_mut(i)
+        && let PaintKind::Solid { color } = &mut p.kind
+    {
+        if bind {
+            if p.color_alpha {
+                p.opacity = 1.0;
+            }
+            p.color_alpha = false;
+        } else if color.a < 1.0 {
+            p.opacity *= color.a;
+            p.color_alpha = true;
+        }
+        color.a = 1.0;
+    }
+}
+
 /// `variable.setMode`: choose a collection's mode on frames (the page when none are given).
 pub fn set_mode(s: &mut Session, p: &Value) -> Result<Value> {
     let cmd = "variable.setMode";
@@ -913,6 +965,167 @@ pub fn apply_bindings(doc: &mut Document) {
 
 /// [`apply_bindings`] for the layers `only` (every bound layer when `None`).
 pub fn apply_bindings_to(doc: &mut Document, only: Option<&std::collections::BTreeSet<NodeId>>) {
+    apply_bindings_matching(doc, only, |_| true);
+}
+
+/// The layers `ids` before an explicit edit, for [`detach_edited`] (only those with bindings).
+pub(crate) fn bound_before(doc: &Document, ids: &[NodeId]) -> Vec<std::sync::Arc<Node>> {
+    ids.iter().filter_map(|i| doc.node_arc(*i)).filter(|n| !n.bound.is_empty()).cloned().collect()
+}
+
+/// An explicit edit sticks: each layer's own bound field (not a list item's) whose value the edit
+/// changed drops its binding, which would otherwise write the variable's value back (#809).
+/// Compared by value, so keys written unchanged keep their bindings and fields moved along with
+/// another (proportions, min/max) lose theirs.
+pub(crate) fn detach_edited(doc: &mut Document, before: &[std::sync::Arc<Node>]) {
+    for old in before {
+        let Some(n) = doc.node(old.id) else { continue };
+        let edited: Vec<String> = n
+            .bound
+            .keys()
+            // A binding the edit itself made (`boundVariables`) stays.
+            .filter(|f| old.bound.get(*f) == n.bound.get(*f))
+            .filter(|f| super::lists::list_binding(f).is_none() && !f.starts_with(crate::components::PROP_BINDING))
+            .filter(|f| bound_field(old, f) != bound_field(n, f))
+            .cloned()
+            .collect();
+        if edited.is_empty() {
+            continue;
+        }
+        if let Ok(n) = doc.get_mut(old.id) {
+            for f in edited {
+                n.bound.remove(&f);
+            }
+        }
+    }
+}
+
+/// The stored value a layer-level binding writes, comparable (`None`: the layer has no such field).
+fn bound_field(n: &Node, field: &str) -> Option<String> {
+    let text = |f: &dyn Fn(&TextStyle) -> String| match &n.kind {
+        NodeKind::Text(t) => Some(std::iter::once(&t.style).chain(t.runs.iter().map(|r| &r.style)).map(f).collect::<Vec<_>>().join(",")),
+        _ => None,
+    };
+    let layout = n.layout.as_ref();
+    let cl = &n.child_layout;
+    let pad = |i: usize| layout.and_then(|l| l.padding.get(i).copied());
+    Some(match field {
+        "width" => format!("{}", n.width),
+        "height" => format!("{}", n.height),
+        "minWidth" => format!("{:?}", cl.min_w),
+        "maxWidth" => format!("{:?}", cl.max_w),
+        "minHeight" => format!("{:?}", cl.min_h),
+        "maxHeight" => format!("{:?}", cl.max_h),
+        "opacity" => format!("{}", n.opacity),
+        "visible" => format!("{}", n.visible),
+        "gap" | "columnGap" => format!("{:?}", layout.map(|l| l.gap)),
+        "crossGap" | "rowGap" => format!("{:?}", layout.map(|l| l.cross_gap)),
+        "padding" => format!("{:?}", layout.map(|l| l.padding)),
+        "paddingTop" => format!("{:?}", pad(0)),
+        "paddingRight" => format!("{:?}", pad(1)),
+        "paddingBottom" => format!("{:?}", pad(2)),
+        "paddingLeft" => format!("{:?}", pad(3)),
+        "paddingHorizontal" => format!("{:?}", (pad(1), pad(3))),
+        "paddingVertical" => format!("{:?}", (pad(0), pad(2))),
+        "cornerRadius" => format!("{:?}", n.corners.radii),
+        "topLeftRadius" => format!("{:?}", n.corners.radii.first()),
+        "topRightRadius" => format!("{:?}", n.corners.radii.get(1)),
+        "bottomRightRadius" => format!("{:?}", n.corners.radii.get(2)),
+        "bottomLeftRadius" => format!("{:?}", n.corners.radii.get(3)),
+        "strokeWeight" => format!("{:?}", (n.stroke.weight, n.stroke.sides)),
+        "strokeTopWeight" | "strokeRightWeight" | "strokeBottomWeight" | "strokeLeftWeight" => format!("{:?}", n.stroke.sides),
+        "arcStart" | "arcSweep" | "arcInner" => match &n.kind {
+            NodeKind::Ellipse { start, sweep, inner } => format!(
+                "{}",
+                if field == "arcStart" {
+                    start
+                } else if field == "arcSweep" {
+                    sweep
+                } else {
+                    inner
+                }
+            ),
+            _ => return None,
+        },
+        "characters" => match &n.kind {
+            NodeKind::Text(t) => t.characters.clone(),
+            _ => return None,
+        },
+        "paragraphSpacing" | "paragraphIndent" => match &n.kind {
+            NodeKind::Text(t) => format!("{}", if field == "paragraphSpacing" { t.paragraph_spacing } else { t.paragraph_indent }),
+            _ => return None,
+        },
+        "fontFamily" => text(&|s| s.font_family.clone())?,
+        "fontStyle" => text(&|s| s.font_style.clone())?,
+        "fontWeight" => text(&|s| s.weight().to_string())?,
+        "fontSize" => text(&|s| s.font_size.to_string())?,
+        "lineHeight" => text(&|s| format!("{:?}", s.line_height))?,
+        "letterSpacing" => text(&|s| format!("{:?}", s.letter_spacing))?,
+        // shortcut: other layer-level fields keep their binding on edits; add a reader when one is bound in practice.
+        _ => return None,
+    })
+}
+
+/// Imported files (`.fig`, REST) keep a solid paint's alpha in its opacity, a bound paint's too,
+/// while the bound colour brings its own alpha: take the variable's alpha back out of the opacity
+/// (styles' paints and layers') before the bindings are first resolved, so it applies once.
+pub(crate) fn unfold_imported_bound_alpha(doc: &mut Document) {
+    use super::lists::{BoundList, list_binding};
+    fn alphas(vars: &Variables, bound: &BTreeMap<String, VariableId>, modes: &BTreeMap<CollectionId, ModeId>) -> Vec<(BoundList, usize, f32)> {
+        let found = bound.iter().filter_map(|(field, var)| match (list_binding(field)?, vars.resolve(var, modes)?) {
+            ((list @ (BoundList::Fills | BoundList::Strokes), i, "color"), VariableValue::Color(c)) if c.a > 0.0 && c.a < 1.0 => Some((list, i, c.a)),
+            _ => None,
+        });
+        found.collect()
+    }
+    fn unfold(p: Option<&mut Paint>, a: f32) {
+        if let Some(p) = p
+            && matches!(p.kind, PaintKind::Solid { .. })
+        {
+            p.opacity = (p.opacity / a).min(1.0);
+        }
+    }
+    let pending = doc.take_dirty();
+    for i in 0..doc.styles.len() {
+        let found = doc.styles.get(i).map(|s| alphas(&doc.variables, &s.bound, &BTreeMap::new())).unwrap_or_default();
+        if let Some(StyleKind::Paint { paints }) = doc.styles.get_mut(i).filter(|_| !found.is_empty()).map(|s| &mut s.kind) {
+            for (_, j, a) in found {
+                unfold(paints.get_mut(j), a);
+            }
+        }
+    }
+    let ids: Vec<NodeId> = doc.nodes().filter(|n| !n.bound.is_empty()).map(|n| n.id).collect();
+    for id in ids {
+        let found = doc.node(id).map(|n| alphas(&doc.variables, &n.bound, &doc.modes_for(id))).unwrap_or_default();
+        if found.is_empty() {
+            continue;
+        }
+        let Ok(n) = doc.get_mut(id) else { continue };
+        for (list, j, a) in found {
+            unfold(if list == BoundList::Fills { n.fills.get_mut(j) } else { n.strokes.get_mut(j) }, a);
+        }
+    }
+    doc.take_dirty();
+    doc.mark_dirty(pending);
+}
+
+/// Settle imported paint colours before the document is first shown. Other bindings can affect
+/// layout or component structure, which must be resolved through the normal edit pipeline.
+pub(crate) fn apply_paint_bindings_on_load(doc: &mut Document) {
+    let pending = doc.take_dirty();
+    apply_bindings_matching(doc, None, |field| {
+        super::lists::list_binding(field).is_some_and(|(list, _, prop)| {
+            matches!(list, super::lists::BoundList::Fills | super::lists::BoundList::Strokes)
+                && (prop == "color" || super::lists::stop_binding(prop).is_some())
+        })
+    });
+    doc.take_dirty();
+    doc.mark_dirty(pending);
+}
+
+/// Re-apply the variable bindings whose field passes `include`, on the `only` nodes (every bound
+/// node when `None`). Auto layout fields wait while their node has no auto layout.
+fn apply_bindings_matching(doc: &mut Document, only: Option<&std::collections::BTreeSet<NodeId>>, include: impl Fn(&str) -> bool) {
     use super::lists::{BoundList, list_binding};
     if doc.variables.variables.is_empty() {
         return;
@@ -926,12 +1139,20 @@ pub fn apply_bindings_to(doc: &mut Document, only: Option<&std::collections::BTr
         let modes = doc.modes_for(id);
         let Some(n) = doc.node(id) else { continue };
         let binds = n.bound.clone();
+        let has_layout = n.layout.is_some();
         let mut sets = serde_json::Map::new();
         let mut effect_sets: Vec<(usize, String, VariableValue)> = Vec::new();
         let mut paint_sets: Vec<(bool, usize, Option<usize>, Color)> = Vec::new();
         let mut grid_sets: Vec<(usize, String, f64)> = Vec::new();
         let mut prop_sets: Vec<(String, VariableValue)> = Vec::new();
         for (field, var) in binds {
+            if !include(&field) {
+                continue;
+            }
+            // A binding never creates an auto layout: without one it waits for the next.
+            if !has_layout && super::props::LAYOUT_KEYS.contains(&field.as_str()) {
+                continue;
+            }
             let Some(val) = doc.variables.resolve(&var, &modes) else { continue };
             // One list item's value: a paint's colour, an effect's or a layout grid's field.
             if let Some((list, i, prop)) = list_binding(&field) {
@@ -1083,7 +1304,6 @@ pub fn document_colors(doc: &Document, page: NodeId) -> Vec<(Color, usize)> {
         stack.extend(n.children.iter().copied());
         for paint in n.fills.iter().chain(n.strokes.iter()).filter(|p| p.visible) {
             if let Some(c) = paint.solid_color() {
-                let c = c.with_alpha(c.a * paint.opacity);
                 counts.entry(c.to_rgba8()).or_insert((c, 0)).1 += 1;
             }
         }
diff --git a/crates/engine/src/cmd/text.rs b/crates/engine/src/cmd/text.rs
index 14ea17621..a2f761155 100644
--- a/crates/engine/src/cmd/text.rs
+++ b/crates/engine/src/cmd/text.rs
@@ -18,6 +18,7 @@ fn style(s: &mut Session, p: &Value, f: impl Fn(&mut TextStyle)) -> Result<Value
         let ds = s.ds_mut()?;
         let before = ds.doc.clone();
         let doc = ds.doc_mut();
+        let bound = super::styles::bound_before(doc, &[id]);
         if let NodeKind::Text(t) = &mut doc.get_mut(id)?.kind {
             if a == b {
                 t.restyle(0, t.char_count(), &f);
@@ -25,19 +26,21 @@ fn style(s: &mut Session, p: &Value, f: impl Fn(&mut TextStyle)) -> Result<Value
                 t.restyle(a, b, &f);
             }
         }
+        super::styles::detach_edited(doc, &bound);
         crate::normalize(doc, &before);
         return ok();
     }
     let ids = req_targets("text", s, p)?;
     let doc = s.doc_mut()?;
-    for i in ids {
-        for d in doc.subtree(i) {
-            if let Some(NodeKind::Text(t)) = doc.node_mut(d).map(|n| &mut n.kind) {
-                let n = t.char_count();
-                t.restyle(0, n, &f);
-            }
+    let ids: Vec<NodeId> = ids.into_iter().flat_map(|i| doc.subtree(i)).collect();
+    let before = super::styles::bound_before(doc, &ids);
+    for d in ids {
+        if let Some(NodeKind::Text(t)) = doc.node_mut(d).map(|n| &mut n.kind) {
+            let n = t.char_count();
+            t.restyle(0, n, &f);
         }
     }
+    super::styles::detach_edited(doc, &before);
     ok()
 }
 
@@ -332,7 +335,7 @@ pub fn specs() -> Vec<CommandSpec> {
         spec!(
             "text.preview",
             "Preview text change",
-            "{command: style.apply|library.applyStyle|text.setVariations|text.style, params}  shows what the command would do on the canvas without an undo step (a hovered text style or named instance, a dragged axis slider), in place of an earlier preview; text.endPreview or any other command ends it, so running the command for real commits it as one undo step",
+            "{command: style.apply|library.applyStyle|text.setVariations|text.style, params}  shows what the command would do on the canvas without an undo step (a hovered font family or style, text style or named instance, a dragged axis slider), in place of an earlier preview; text.endPreview or any other command ends it, so running the command for real commits it as one undo step",
             false,
             |s, p| {
                 let c = req_string("text.preview", p, "command")?;
@@ -348,11 +351,13 @@ pub fn specs() -> Vec<CommandSpec> {
             let c = string(p, "characters").or_else(|| string(p, "text")).ok_or_else(|| bad("text.set", "`characters` required"))?;
             let ids = req_targets("text.set", s, p)?;
             let doc = s.doc_mut()?;
+            let before = super::styles::bound_before(doc, &ids);
             for i in ids {
                 let mut m = Map::new();
                 m.insert("characters".into(), json!(c));
                 super::props::apply("text.set", doc, i, &m)?;
             }
+            super::styles::detach_edited(doc, &before);
             ok()
         }),
         spec!(
@@ -364,6 +369,7 @@ pub fn specs() -> Vec<CommandSpec> {
                 let ids = req_targets("text.style", s, p)?;
                 let m = p.as_object().cloned().unwrap_or_default();
                 let doc = s.doc_mut()?;
+                let before = super::styles::bound_before(doc, &ids);
                 for i in ids {
                     let n = doc.get_mut(i)?;
                     let NodeKind::Text(t) = &mut n.kind else { return Err(bad("text.style", format!("{i} is not text"))) };
@@ -377,6 +383,7 @@ pub fn specs() -> Vec<CommandSpec> {
                         super::props::apply_text_style("text.style", t, a, b, k, v)?;
                     }
                 }
+                super::styles::detach_edited(doc, &before);
                 ok()
             }
         ),
@@ -474,5 +481,40 @@ pub fn specs() -> Vec<CommandSpec> {
                 })
             }
         ),
+        spec!(
+            "text.rescanFonts",
+            "Rescan installed fonts",
+            "{}  walks the system font folders again, for fonts installed while the app runs; the open document's auto-sizing text in the families that gained faces (new ones, or styles installed since) fits them (text.refit) → {added: [families that were unknown], refitted: [ids]}",
+            true,
+            |s, _| {
+                let rescan = figcraft_text::rescan_system_fonts();
+                let refitted = crate::fonts::refit_open(s, None, Some(&rescan.changed));
+                Ok(json!({"added": rescan.added, "refitted": refitted}))
+            }
+        ),
+        spec!(
+            "text.loadFont",
+            "Load font file",
+            "{path | data (base64)}  adds a font file (.ttf, .otf, .ttc, .otc; every face of a collection) to this session's fonts without installing it; the open document's auto-sizing text in its families fits it (text.refit) → {families, refitted: [ids]}",
+            true,
+            |s, p| {
+                let cmd = "text.loadFont";
+                let bytes = if let Some(b64) = string(p, "data") {
+                    use base64::Engine as _;
+                    let b64 = b64.split_once(',').map(|(_, d)| d.to_string()).unwrap_or(b64);
+                    base64::engine::general_purpose::STANDARD.decode(b64.trim()).map_err(|e| bad(cmd, format!("`data`: {e}")))?
+                } else if let Some(path) = string(p, "path") {
+                    super::file::read_capped(&path, figcraft_text::fontdb::MAX_FONT_FILE)?
+                } else {
+                    return Err(bad(cmd, "pass `path` or `data` (base64)"));
+                };
+                let families = figcraft_text::load_font_bytes(bytes);
+                if families.is_empty() {
+                    return Err(bad(cmd, "not a font file"));
+                }
+                let refitted = crate::fonts::refit_open(s, None, Some(&families));
+                Ok(json!({"families": families, "refitted": refitted}))
+            }
+        ),
     ]
 }
diff --git a/crates/engine/src/cmd/variables.rs b/crates/engine/src/cmd/variables.rs
index 3e6dc69d6..53b62ee46 100644
--- a/crates/engine/src/cmd/variables.rs
+++ b/crates/engine/src/cmd/variables.rs
@@ -288,7 +288,11 @@ pub(crate) fn forget_variables(doc: &mut Document, gone: &BTreeSet<VariableId>)
     doc.variables.variables.retain(|v| !gone.contains(&v.id));
     let users: Vec<NodeId> = doc.nodes().filter(|n| n.bound.values().any(|v| gone.contains(v))).map(|n| n.id).collect();
     for id in users {
-        doc.get_mut(id)?.bound.retain(|_, v| !gone.contains(v));
+        let n = doc.get_mut(id)?;
+        for (field, _) in n.bound.iter().filter(|(_, v)| gone.contains(*v)) {
+            super::styles::rebind_paint_alpha(&mut n.fills, &mut n.strokes, field, false);
+        }
+        n.bound.retain(|_, v| !gone.contains(v));
     }
     Ok(())
 }
diff --git a/crates/engine/src/cmd/variables_io.rs b/crates/engine/src/cmd/variables_io.rs
index 99a786400..f3b9a820d 100644
--- a/crates/engine/src/cmd/variables_io.rs
+++ b/crates/engine/src/cmd/variables_io.rs
@@ -25,7 +25,7 @@ pub fn specs() -> Vec<CommandSpec> {
         spec!(
             "variable.import",
             "Import variables",
-            "{variables (the local variables JSON, as variable.export writes it: an object, JSON text or a path)}  collections join this file's collection of the same name (values by mode name; new modes and variables are added, a variable of another type is skipped), others are added  → {collections (added), variables (added), updated, warnings}",
+            "{variables (the local variables JSON, as variable.export writes it: an object, JSON text or a path; `variableCollections` and `variables` under `meta` or at the top level)}  collections join this file's collection of the same name (values by mode name; new modes and variables are added, a variable of another type is skipped), others are added  → {collections (added), variables (added), updated, warnings (also when it holds no variables, or fewer than its collections list)}",
             true,
             import
         ),
diff --git a/crates/engine/src/cmd/view.rs b/crates/engine/src/cmd/view.rs
index de69e6908..17f71b492 100644
--- a/crates/engine/src/cmd/view.rs
+++ b/crates/engine/src/cmd/view.rs
@@ -19,30 +19,58 @@ fn flag(s: &mut Session, p: &Value, f: fn(&mut ViewState) -> &mut bool) -> Resul
     Ok(json!({"on": *slot}))
 }
 
+/// One of a view's on/off settings.
+type Slot = fn(&mut ViewState) -> &mut bool;
+
+/// The View menu's on/off toggles (Pixel preview, with its scale, has its own command), and
+/// whether the preferences keep each: files opened or made later start with the kept ones. Outline
+/// modes and the sRGB soft-proof stay with their file, so a new file never opens in one.
+const TOGGLES: &[(&str, Slot, bool)] = &[
+    ("view.pixelGrid", |v| &mut v.pixel_grid, true),
+    ("view.layoutGrids", |v| &mut v.layout_grids, true),
+    ("view.rulers", |v| &mut v.rulers, true),
+    ("view.slices", |v| &mut v.show_slices, true),
+    ("view.comments", |v| &mut v.comments, true),
+    ("view.multiplayerCursors", |v| &mut v.multiplayer_cursors, true),
+    ("view.outlines", |v| &mut v.outlines, false),
+    ("view.outlinesSelection", |v| &mut v.outlines_selection, false),
+    ("view.outlinesHiddenLayers", |v| &mut v.outline_hidden, true),
+    ("view.outlinesObjectBounds", |v| &mut v.outline_bounds, true),
+    ("view.maskOutlines", |v| &mut v.mask_outlines, true),
+    ("view.frameOutlines", |v| &mut v.frame_outlines, true),
+    ("view.proofSrgb", |v| &mut v.proof_srgb, false),
+    ("view.snapGeometry", |v| &mut v.snap_geometry, true),
+    ("view.snapObjects", |v| &mut v.snap_objects, true),
+    ("view.snapPixel", |v| &mut v.snap_pixel, true),
+];
+
+/// View toggle `id`: the file's view changes, and the preferences remember a kept one.
+fn toggle(s: &mut Session, p: &Value, id: &str) -> Result<Value> {
+    let Some(&(_, f, keep)) = TOGGLES.iter().find(|(k, ..)| *k == id) else { return Err(bad(id, "not a View toggle")) };
+    let r = flag(s, p, f)?;
+    if keep && let Some(on) = r.get("on").and_then(Value::as_bool) {
+        s.prefs.view.insert(id.to_string(), on);
+    }
+    Ok(r)
+}
+
+/// Set `v`'s View toggles to the ones the preferences keep (the others stay as they are).
+pub(crate) fn apply_kept(prefs: &crate::Prefs, v: &mut ViewState) {
+    for (id, f, _) in TOGGLES.iter().filter(|t| t.2) {
+        if let Some(on) = prefs.view.get(*id) {
+            *f(v) = *on;
+        }
+    }
+}
+
 /// Whether the View menu's toggle `id` is on (the menus show a check mark); `None` for a command
 /// that isn't one.
 pub fn checked(s: &Session, id: &str) -> Option<bool> {
-    let v = &s.ds().ok()?.view;
-    Some(match id {
-        "view.pixelGrid" => v.pixel_grid,
-        "view.layoutGrids" => v.layout_grids,
-        "view.rulers" => v.rulers,
-        "view.slices" => v.show_slices,
-        "view.comments" => v.comments,
-        "view.multiplayerCursors" => v.multiplayer_cursors,
-        "view.outlines" => v.outlines,
-        "view.outlinesSelection" => v.outlines_selection,
-        "view.outlinesHiddenLayers" => v.outline_hidden,
-        "view.outlinesObjectBounds" => v.outline_bounds,
-        "view.maskOutlines" => v.mask_outlines,
-        "view.pixelPreview" => v.pixel_preview,
-        "view.frameOutlines" => v.frame_outlines,
-        "view.proofSrgb" => v.proof_srgb,
-        "view.snapGeometry" => v.snap_geometry,
-        "view.snapObjects" => v.snap_objects,
-        "view.snapPixel" => v.snap_pixel,
-        _ => return None,
-    })
+    let mut v = s.ds().ok()?.view.clone();
+    if id == "view.pixelPreview" {
+        return Some(v.pixel_preview);
+    }
+    TOGGLES.iter().find(|(k, ..)| *k == id).map(|(_, f, _)| *f(&mut v))
 }
 
 /// Pixel preview: toggles, or turns on at a resolution of 1x or 2x.
@@ -172,7 +200,7 @@ fn pref(s: &mut Session, p: &Value, f: fn(&mut crate::Prefs) -> &mut bool) -> Re
     Ok(json!({"on": *slot}))
 }
 
-fn tool(s: &mut Session, t: ToolId) -> Result<Value> {
+pub(crate) fn tool(s: &mut Session, t: ToolId) -> Result<Value> {
     // A file you can't edit now (view only, or on its way to a server): moving around only.
     if let Some(why) = s.active_read_only().filter(|_| !matches!(t, ToolId::Move | ToolId::Hand)) {
         return Err(EngineError::Disabled(format!("tool.{}", t.id()), why.into()));
@@ -235,46 +263,46 @@ pub fn specs() -> Vec<CommandSpec> {
         spec!("view.nextFrame", "Zoom to next frame", "{}", false, |s, _| zoom_frame(s, 1)),
         spec!("view.prevPage", "Previous page", "{}", false, |s, _| page_step(s, -1)),
         spec!("view.nextPage", "Next page", "{}", false, |s, _| page_step(s, 1)),
-        spec!("view.pixelGrid", "Pixel grid", "{on?}", false, |s, p| flag(s, p, |v| &mut v.pixel_grid)),
-        spec!("view.layoutGrids", "Layout grids", "{on?}", false, |s, p| flag(s, p, |v| &mut v.layout_grids)),
-        spec!("view.rulers", "Rulers", "{on?}", false, |s, p| flag(s, p, |v| &mut v.rulers)),
-        spec!("view.slices", "Slices", "{on?}", false, |s, p| flag(s, p, |v| &mut v.show_slices)),
-        spec!("view.comments", "Comments", "{on?}", false, |s, p| flag(s, p, |v| &mut v.comments)),
+        spec!("view.pixelGrid", "Pixel grid", "{on?}", false, |s, p| toggle(s, p, "view.pixelGrid")),
+        spec!("view.layoutGrids", "Layout grids", "{on?}", false, |s, p| toggle(s, p, "view.layoutGrids")),
+        spec!("view.rulers", "Rulers", "{on?}", false, |s, p| toggle(s, p, "view.rulers")),
+        spec!("view.slices", "Slices", "{on?}", false, |s, p| toggle(s, p, "view.slices")),
+        spec!("view.comments", "Comments", "{on?}", false, |s, p| toggle(s, p, "view.comments")),
         spec!("view.multiplayerCursors", "Multiplayer cursors", "{on?}  others' cursors in a live session", false, |s, p| {
-            flag(s, p, |v| &mut v.multiplayer_cursors)
+            toggle(s, p, "view.multiplayerCursors")
         }),
         spec!("view.pan", "Pan the view", "{dx, dy (arrow-key steps, e.g. 1 or -1), big? (ten times as far, like Shift)}", false, pan),
-        spec!("view.outlines", "Outlines", "{on?}", false, |s, p| flag(s, p, |v| &mut v.outlines)),
+        spec!("view.outlines", "Outlines", "{on?}", false, |s, p| toggle(s, p, "view.outlines")),
         spec!("view.outlinesSelection", "Outlines for selection", "{on?}  outline mode for the selected layers only", false, |s, p| {
-            flag(s, p, |v| &mut v.outlines_selection)
+            toggle(s, p, "view.outlinesSelection")
         }),
         spec!(
             "view.outlinesHiddenLayers",
             "Include hidden layers in outlines",
             "{on?}  outline mode (and outlines for the selection) outlines hidden layers too; they can be clicked there",
             false,
-            |s, p| { flag(s, p, |v| &mut v.outline_hidden) }
+            |s, p| { toggle(s, p, "view.outlinesHiddenLayers") }
         ),
         spec!(
             "view.outlinesObjectBounds",
             "Include object bounds in outlines",
             "{on?}  outline mode also draws each layer's box (groups, text, vectors); a click on a box's edge picks its layer",
             false,
-            |s, p| { flag(s, p, |v| &mut v.outline_bounds) }
+            |s, p| { toggle(s, p, "view.outlinesObjectBounds") }
         ),
-        spec!("view.maskOutlines", "Mask outlines", "{on?}", false, |s, p| flag(s, p, |v| &mut v.mask_outlines)),
+        spec!("view.maskOutlines", "Mask outlines", "{on?}", false, |s, p| toggle(s, p, "view.maskOutlines")),
         spec!("view.pixelPreview", "Pixel preview", "{on?, scale? (1|2: rendered pixels per page pixel; turns it on)}", false, pixel_preview),
-        spec!("view.frameOutlines", "Frame outlines", "{on?}", false, |s, p| flag(s, p, |v| &mut v.frame_outlines)),
+        spec!("view.frameOutlines", "Frame outlines", "{on?}", false, |s, p| toggle(s, p, "view.frameOutlines")),
         spec!(
             "view.proofSrgb",
             "Soft-proof sRGB",
             "{on?}  mark the colours of a Display P3 file that sRGB screens and files can't show",
             false,
-            |s, p| { flag(s, p, |v| &mut v.proof_srgb) }
+            |s, p| { toggle(s, p, "view.proofSrgb") }
         ),
-        spec!("view.snapGeometry", "Snap to geometry", "{on?}", false, |s, p| flag(s, p, |v| &mut v.snap_geometry)),
-        spec!("view.snapObjects", "Snap to objects", "{on?}", false, |s, p| flag(s, p, |v| &mut v.snap_objects)),
-        spec!("view.snapPixel", "Snap to pixel grid", "{on?}", false, |s, p| flag(s, p, |v| &mut v.snap_pixel)),
+        spec!("view.snapGeometry", "Snap to geometry", "{on?}", false, |s, p| toggle(s, p, "view.snapGeometry")),
+        spec!("view.snapObjects", "Snap to objects", "{on?}", false, |s, p| toggle(s, p, "view.snapObjects")),
+        spec!("view.snapPixel", "Snap to pixel grid", "{on?}", false, |s, p| toggle(s, p, "view.snapPixel")),
         spec!("view.toggleUi", "Show/Hide UI", "{on?}", false, |s, p| flag(s, p, |v| &mut v.ui_hidden)),
         spec!("view.fullscreen", "Full screen", "{on?}  the window fills the screen (the desktop app; a no-op headless)", false, |s, p| {
             s.request_ui("window.fullscreen", json!({"on": boolean(p, "on")}));
@@ -342,7 +370,25 @@ pub fn specs() -> Vec<CommandSpec> {
         spec!("pref.showDimensions", "Show dimensions on objects", "{on?}", false, |s, p| pref(s, p, |x| &mut x.show_dimensions)),
         spec!("pref.numberKeysOpacity", "Use number keys for opacity", "{on?}", false, |s, p| pref(s, p, |x| &mut x.number_keys_opacity)),
         spec!("pref.reduceMotion", "Reduce motion", "{on?}", false, |s, p| pref(s, p, |x| &mut x.reduce_motion)),
+        spec!(
+            "pref.uiScale",
+            "Interface size",
+            "{scale?: a size from 0.75 to 3 relative to the system's display scale, 1 being the system's own size, so 1.25 is 125 %, not 125 (outside the range it stops at the nearest end; \"auto\" is 1; omit: just read it)} → {scale}: how large the whole interface is drawn; the canvas zoom is separate",
+            false,
+            |s, p| {
+                match get(p, "scale") {
+                    None => {}
+                    Some(Value::String(v)) if v.trim().eq_ignore_ascii_case("auto") => s.prefs.ui_scale = 1.0,
+                    Some(_) => {
+                        let scale = req_num("pref.uiScale", p, "scale")?;
+                        s.prefs.ui_scale = crate::clamp_ui_scale(scale).ok_or_else(|| bad("pref.uiScale", "`scale` must be a finite number"))?;
+                    }
+                }
+                Ok(json!({"scale": s.prefs.ui_scale}))
+            }
+        ),
         spec!("pref.autoSave", "Save files automatically", "{on?}", false, |s, p| pref(s, p, |x| &mut x.auto_save)),
+        spec!("pref.startOnHome", "Start on the Home screen", "{on?}", false, |s, p| pref(s, p, |x| &mut x.start_on_home)),
         spec!("pref.nudge", "Nudge amount", "{small?, big?}", false, |s, p| {
             s.prefs.nudge_small = num(p, "small").unwrap_or(s.prefs.nudge_small).clamp(0.01, 1000.0);
             s.prefs.nudge_big = num(p, "big").unwrap_or(s.prefs.nudge_big).clamp(0.01, 10000.0);
@@ -381,7 +427,7 @@ pub fn specs() -> Vec<CommandSpec> {
         spec!(
             "pref.language",
             "Interface language",
-            "{language: system|en|cs|ru|es|es-419|fr|de|pt-BR|ja|ko|zh-Hans|…; else English}",
+            "{language: system|en|cs|ru|es|es-419|fr|de|pt-BR|ja|ka|ko|zh-Hans|…; else English}",
             false,
             |s, p| {
                 let lang = req_string("pref.language", p, "language")?;
@@ -419,11 +465,14 @@ pub fn specs() -> Vec<CommandSpec> {
         spec!(
             "tool.set",
             "Choose tool",
-            "{tool: move|scale|hand|frame|section|slice|rectangle|line|arrow|ellipse|polygon|star|pen|pencil|text|comment|shapeBuilder}",
+            "{tool: move|scale|hand|frame|section|slice|rectangle|line|arrow|ellipse|polygon|star|pen|pencil|text|comment|shapeBuilder | on boards: sticky|shape|connector|marker|highlighter|eraser|stamp}",
             false,
             |s, p| {
                 let t = req_string("tool.set", p, "tool")?;
                 let t = ToolId::from_id(&t).ok_or_else(|| bad("tool.set", format!("unknown tool `{t}`")))?;
+                if t.on_boards() {
+                    crate::board::require(s, &format!("tool.{}", t.id()))?;
+                }
                 tool(s, t)
             }
         ),
@@ -488,9 +537,37 @@ pub fn specs() -> Vec<CommandSpec> {
         spec!("tool.text", "Text", "{}", false, |s, _| tool(s, ToolId::Text)),
         spec!("tool.comment", "Comment", "{}", false, |s, _| tool(s, ToolId::Comment)),
         spec!("tool.shapeBuilder", "Shape builder", "{}", false, |s, _| tool(s, ToolId::ShapeBuilder)),
-        spec!("edit.pickColor", "Pick color", "{}", false, |s, _| tool(s, ToolId::Eyedropper)),
+        // `apply: false` is for the UI colour picker: the eyedropper only samples (into
+        // `ToolState::picked`) and the picker writes the colour to the paint it edits.
+        spec!("edit.pickColor", "Pick color", "{apply?}", false, |s, p| {
+            let r = tool(s, ToolId::Eyedropper)?;
+            s.tool.pick_only = !boolean(p, "apply").unwrap_or(true);
+            s.tool.picked = None;
+            Ok(r)
+        }),
     ]
 }
 
 #[allow(dead_code)]
 fn unused(_: NodeId) {}
+
+#[cfg(test)]
+mod start_on_home_tests {
+    use serde_json::json;
+
+    use crate::Session;
+
+    #[test]
+    fn start_on_home_is_a_preference_that_persists() {
+        let mut s = Session::new();
+        assert!(!s.prefs.start_on_home);
+        assert_eq!(s.execute("pref.startOnHome", &json!({})).unwrap()["on"], true);
+        assert!(s.prefs.start_on_home);
+        // Saved with the other preferences and read back; older settings files without it read as off.
+        let saved: crate::Prefs = serde_json::from_value(serde_json::to_value(&s.prefs).unwrap()).unwrap();
+        assert!(saved.start_on_home);
+        assert_eq!(s.execute("pref.startOnHome", &json!({"on": false})).unwrap()["on"], false);
+        let old: crate::Prefs = serde_json::from_value(json!({"theme": "dark"})).unwrap();
+        assert!(!old.start_on_home);
+    }
+}
diff --git a/crates/engine/src/code_connect.rs b/crates/engine/src/code_connect.rs
index 463406368..08b3af022 100644
--- a/crates/engine/src/code_connect.rs
+++ b/crates/engine/src/code_connect.rs
@@ -14,9 +14,9 @@ use figcraft_doc::*;
 use serde_json::{Value, json};
 
 use crate::cmd::CommandSpec;
-use crate::codegen::CodeLang;
+use crate::codegen::{CodeLang, Ctx};
 use crate::component_codegen::{Component, Param, ParamKind, describe, instance_values, js_string, main_of, value_expr};
-use crate::components::variant_set;
+use crate::components::{slots_of, variant_set};
 use crate::params::*;
 use crate::{EngineError, Result, Session, bad, spec};
 
@@ -70,14 +70,106 @@ pub fn import_line(link: &CodeLink, lang: CodeLang) -> String {
     }
 }
 
-/// Layer `id`'s code with `link`: the import line and the snippet (an instance's values, else the
-/// defaults). `None` when `id` isn't a component, set or instance.
+/// Layer `id`'s code with `link`: the import lines (its own and those of connected components its
+/// instance swaps place) and the snippet (an instance's values, else the defaults). `None` when
+/// `id` isn't a component, set or instance.
 pub fn connected_code(doc: &Document, id: NodeId, lang: CodeLang, link: &CodeLink) -> Option<String> {
     let c = main_of(doc, id).and_then(|m| describe(doc, m))?;
     let values = instance_values(doc, id, &c).unwrap_or_else(|| c.params.iter().map(|p| (p.prop.clone(), p.default.clone())).collect());
-    let snippet = render(doc, &c, &values, link, lang, "");
-    let import = import_line(link, lang);
-    Some(if import.is_empty() { snippet } else { format!("{import}\n\n{snippet}") })
+    let mut imports = Vec::new();
+    snippet_imports(doc, &c, &values, link, lang, &mut imports);
+    Some(with_imports(&imports, render(doc, &c, &values, link, lang, "")))
+}
+
+/// `code` with `imports` at the top: joined to the import block it starts with, else apart.
+pub fn with_imports(imports: &[String], code: String) -> String {
+    match imports.join("\n") {
+        i if i.is_empty() => code,
+        i if code.starts_with("import ") || code.starts_with("use ") => format!("{i}\n{code}"),
+        i => format!("{i}\n\n{code}"),
+    }
+}
+
+/// Adds `line` to `out` unless it's empty or already there.
+fn add(out: &mut Vec<String>, line: String) {
+    if !line.is_empty() && !out.contains(&line) {
+        out.push(line);
+    }
+}
+
+/// The import lines a connected snippet needs: its own and those of the connected components its
+/// instance swaps place (the ones its template shows).
+fn snippet_imports(doc: &Document, c: &Component, values: &[(String, Value)], link: &CodeLink, lang: CodeLang, out: &mut Vec<String>) {
+    add(out, import_line(link, lang));
+    for piece in pieces(&link.template) {
+        if let Piece::Value { name, .. } = piece
+            && let Some((p, v)) = find(c, values, name)
+            && p.kind == ParamKind::InstanceSwap
+            && let Some(l) = id_of(v).and_then(|i| self::link(doc, i, lang))
+        {
+            add(out, import_line(l, lang));
+        }
+    }
+}
+
+/// The import lines of the connected components the generated code of layer `id` calls
+/// (instances in its tree, in a component's definition and in the slots an instance fills), once
+/// each in tree order. A connected `id` shows its snippet ([`connected_code`]) instead.
+pub fn tree_imports(doc: &Document, id: NodeId, lang: CodeLang) -> Vec<String> {
+    let mut out = Vec::new();
+    let Some(n) = doc.node(id) else { return out };
+    let c = main_of(doc, id).and_then(|m| describe(doc, m));
+    match (&n.kind, &c) {
+        // Its call (the slots it fills), then its component's definition.
+        (NodeKind::Instance { .. }, Some(c)) => {
+            call_imports(doc, id, lang, 0, &mut out);
+            tree(&Ctx { doc, root: c.comp, comp: Some(c), base: 0 }, c.comp, lang, 0, &mut out);
+        }
+        (NodeKind::Component { .. } | NodeKind::ComponentSet { .. }, Some(c)) => {
+            tree(&Ctx { doc, root: c.comp, comp: Some(c), base: 0 }, c.comp, lang, 0, &mut out)
+        }
+        _ => tree(&Ctx::new(doc, id), id, lang, 0, &mut out),
+    }
+    out
+}
+
+/// Imports under layer `id` as the code walk sees it: its visible children, instances as calls
+/// (one an instance swap parameter places is that parameter). shortcut: the depth cap counts from
+/// the tree's root, not from each slot's; align them if a deep slot tree shows a stray import.
+fn tree(ctx: &Ctx, id: NodeId, lang: CodeLang, depth: usize, out: &mut Vec<String>) {
+    let Some(n) = ctx.doc.node(id) else { return };
+    if ctx.too_deep(depth) {
+        return;
+    }
+    for k in ctx.kids(n) {
+        let Some(kn) = ctx.doc.node(k) else { continue };
+        let call = matches!(kn.kind, NodeKind::Instance { .. }) && main_of(ctx.doc, k).is_some();
+        match (call, ctx.param(kn, "mainComponent")) {
+            (true, Some(_)) => {}
+            (true, None) => call_imports(ctx.doc, k, lang, depth + 1, out),
+            (false, _) => tree(ctx, k, lang, depth + 1, out),
+        }
+    }
+}
+
+/// The imports instance `id` placed as a call brings: a connected one's snippet's, else those of
+/// the content it puts in its slots.
+fn call_imports(doc: &Document, id: NodeId, lang: CodeLang, depth: usize, out: &mut Vec<String>) {
+    let Some(c) = main_of(doc, id).and_then(|m| describe(doc, m)) else { return };
+    let Some(values) = instance_values(doc, id, &c) else { return };
+    if let Some(l) = link(doc, id, lang) {
+        return snippet_imports(doc, &c, &values, l, lang, out);
+    }
+    let slots = slots_of(doc, id);
+    for (p, (_, v)) in c.params.iter().zip(&values) {
+        if p.kind == ParamKind::Slot
+            && v.as_bool() == Some(true)
+            && let Some((slot, _)) = slots.iter().find(|(_, name)| *name == p.prop)
+        {
+            // The same depth base as the slot's generated content, so its connected children count.
+            tree(&Ctx { doc, root: *slot, comp: None, base: depth }, *slot, lang, depth + 1, out);
+        }
+    }
 }
 
 // ------------------------------------------------------------------ templates
@@ -180,14 +272,17 @@ fn expr(doc: &Document, c: &Component, p: &Param, v: &Value, lang: CodeLang) ->
     }
 }
 
+/// Template `t` as pieces. One that doesn't parse, or that skipped `check` (a hand-edited file)
+/// and is far too long, stays as written: parsing rescans after each literal brace.
+fn pieces(t: &str) -> Vec<Piece<'_>> {
+    let checkable = t.len() <= MAX_TEMPLATE * 4;
+    checkable.then(|| parse(t).ok()).flatten().unwrap_or_else(|| vec![Piece::Text(t)])
+}
+
 /// `link`'s template with `values` (one per parameter of `c`), every line prefixed by `pad`.
 pub(crate) fn render(doc: &Document, c: &Component, values: &[(String, Value)], link: &CodeLink, lang: CodeLang, pad: &str) -> String {
-    // A template that skipped `check` (a hand-edited file) and is far too long stays as written:
-    // parsing rescans after each literal brace.
-    let checkable = link.template.len() <= MAX_TEMPLATE * 4;
-    let pieces = checkable.then(|| parse(&link.template).ok()).flatten().unwrap_or_else(|| vec![Piece::Text(&link.template)]);
     let mut out = String::new();
-    for piece in pieces {
+    for piece in pieces(&link.template) {
         match piece {
             Piece::Text(t) => out.push_str(t),
             Piece::Value { name, inner } => match find(c, values, name) {
diff --git a/crates/engine/src/codegen.rs b/crates/engine/src/codegen.rs
index 7d35229f1..7ed81b303 100644
--- a/crates/engine/src/codegen.rs
+++ b/crates/engine/src/codegen.rs
@@ -231,7 +231,7 @@ impl<'a> Ctx<'a> {
             .collect()
     }
 
-    fn too_deep(&self, depth: usize) -> bool {
+    pub(crate) fn too_deep(&self, depth: usize) -> bool {
         depth > self.base + MAX_DEPTH
     }
 
@@ -256,7 +256,26 @@ fn stroke_color(n: &Node) -> Option<Color> {
     if !n.has_visible_stroke() {
         return None;
     }
-    n.strokes.iter().filter(|p| p.visible).find_map(|p| p.solid_color().map(|c| c.with_alpha(c.a * p.opacity)))
+    n.strokes.iter().filter(|p| p.visible).find_map(|p| p.solid_color())
+}
+
+/// The CSS borders a solid stroke makes: one `border`, or with individual stroke sides a border
+/// on each side that has a weight.
+fn css_borders(doc: &Document, n: &Node, t: &mut Tokens) -> Vec<(String, String)> {
+    let Some(c) = stroke_color(n) else { return Vec::new() };
+    let Some(sides) = n.stroke.sides else {
+        let weight = tok(doc, n, &["strokeWeight"], format!("{}px", num(n.stroke.weight)), t);
+        return vec![("border".into(), format!("{weight} solid {}", tok(doc, n, &["stroke"], c.to_css(), t)))];
+    };
+    let color = tok(doc, n, &["stroke"], c.to_css(), t);
+    let named = ["top", "right", "bottom", "left"].into_iter().zip(crate::cmd::props::STROKE_SIDES);
+    named
+        .zip(sides)
+        .filter(|(_, weight)| *weight > 0.0)
+        .map(|((side, field), weight)| {
+            (format!("border-{side}"), format!("{} solid {color}", tok(doc, n, &[field], format!("{}px", num(weight)), t)))
+        })
+        .collect()
 }
 
 fn drop_shadow(n: &Node) -> Option<&Shadow> {
@@ -452,9 +471,8 @@ pub(crate) fn css_decls(doc: &Document, n: &Node, t: &mut Tokens, hug: (bool, bo
             PaintKind::Pattern(_) => put("background", "url(pattern.png) repeat".into()),
         }
     }
-    if let Some(c) = stroke_color(n) {
-        let weight = tok(doc, n, &["strokeWeight"], px(n.stroke.weight), t);
-        put("border", format!("{weight} solid {}", tok(doc, n, &["stroke"], c.to_css(), t)));
+    for (key, value) in css_borders(doc, n, t) {
+        put(&key, value);
     }
     let shadows: Vec<String> = n
         .effects
@@ -858,11 +876,16 @@ pub(crate) fn swift(ctx: &Ctx, id: NodeId, depth: usize, out: &mut String, extra
     swift_layer(ctx, n, depth, out, extra);
 }
 
+/// A layer name safe for a single-line `//` comment: line breaks become spaces.
+fn one_line(name: &str) -> String {
+    name.replace(['\n', '\r', '\u{85}', '\u{2028}', '\u{2029}'], " ")
+}
+
 fn swift_layer(ctx: &Ctx, n: &Node, depth: usize, out: &mut String, extra: &[String]) {
     let doc = ctx.doc;
     let pad = indent(depth);
     if ctx.too_deep(depth) {
-        out.push_str(&format!("{pad}// {} …\n", n.name));
+        out.push_str(&format!("{pad}// {} …\n", one_line(&n.name)));
         return;
     }
     // Nested instances are calls; an instance swap parameter is a view.
@@ -1035,7 +1058,7 @@ fn compose_layer(ctx: &Ctx, n: &Node, depth: usize, out: &mut String) {
     let doc = ctx.doc;
     let pad = indent(depth);
     if ctx.too_deep(depth) {
-        out.push_str(&format!("{pad}// {} …\n", n.name));
+        out.push_str(&format!("{pad}// {} …\n", one_line(&n.name)));
         return;
     }
     // Nested instances are calls; an instance swap parameter is a composable.
@@ -1168,4 +1191,26 @@ mod tests {
         assert!(kt.contains("Modifier.offset(7.dp, 9.dp)"));
         assert!(code_for(doc, NodeId(999_999), CodeLang::Css).is_empty());
     }
+
+    #[test]
+    fn too_deep_placeholder_keeps_a_multiline_layer_name_in_the_comment() {
+        let mut s = Session::new();
+        let name = "deep\nevil()\r\u{2028}more()";
+        let mut parent = id_of(&s.execute("frame.create", &json!({"x": 0, "y": 0, "width": 50, "height": 50, "name": name})).unwrap()["id"]).unwrap();
+        let root = parent;
+        for _ in 0..16 {
+            parent =
+                id_of(&s.execute("frame.create", &json!({"x": 1, "y": 1, "width": 40, "height": 40, "parent": parent, "name": name})).unwrap()["id"])
+                    .unwrap();
+        }
+        let doc = s.doc().unwrap();
+        for lang in [CodeLang::SwiftUi, CodeLang::Compose] {
+            let code = code_for(doc, root, lang);
+            assert!(code.contains("// deep evil()  more() …\n"), "{code}");
+            for line in code.lines() {
+                let t = line.trim_start();
+                assert!(!t.starts_with("evil()") && !t.starts_with("more()"), "layer name leaked as code:\n{code}");
+            }
+        }
+    }
 }
diff --git a/crates/engine/src/component_codegen.rs b/crates/engine/src/component_codegen.rs
index 1416b15f9..a8217be1c 100644
--- a/crates/engine/src/component_codegen.rs
+++ b/crates/engine/src/component_codegen.rs
@@ -109,14 +109,14 @@ pub fn specs() -> Vec<CommandSpec> {
 
 /// Code for any layer in React, Leptos, SwiftUI or Compose: an instance's call and its component's
 /// definition, a component's (or set's) definition, or the layer tree (React and Leptos wrap it
-/// in a function component).
+/// in a function component), with the imports of the connected components it calls at the top.
 pub fn code(doc: &Document, id: NodeId, lang: CodeLang) -> String {
     let Some(n) = doc.node(id) else { return String::new() };
     if let Some(code) = crate::code_connect::link(doc, id, lang).and_then(|l| crate::code_connect::connected_code(doc, id, lang, l)) {
         return code;
     }
     let comp = main_of(doc, id).and_then(|m| describe(doc, m));
-    match (&n.kind, comp) {
+    let code = match (&n.kind, comp) {
         (NodeKind::Instance { .. }, Some(c)) => format!("{}\n{}", usage(doc, id, lang, 0).unwrap_or_default(), definition(doc, &c, lang)),
         (NodeKind::Component { .. } | NodeKind::ComponentSet { .. }, Some(c)) => definition(doc, &c, lang),
         _ => match lang {
@@ -135,7 +135,8 @@ pub fn code(doc: &Document, id: NodeId, lang: CodeLang) -> String {
                 out
             }
         },
-    }
+    };
+    crate::code_connect::with_imports(&crate::code_connect::tree_imports(doc, id, lang), code)
 }
 
 fn is_component(doc: &Document, id: NodeId) -> bool {
@@ -521,8 +522,7 @@ pub fn usage(doc: &Document, id: NodeId, lang: CodeLang, depth: usize) -> Option
     let c = main_of(doc, id).and_then(|m| describe(doc, m))?;
     let values = instance_values(doc, id, &c)?;
     let pad = if lang == CodeLang::React { "  ".repeat(depth) } else { indent(depth) };
-    // A connected component: its real snippet. shortcut: inside a layer tree it brings no import
-    // line; collect them at the top of the tree's code when people ask for it.
+    // A connected component: its real snippet (its import is at the top of the code: `code`).
     if let Some(link) = crate::code_connect::link(doc, id, lang) {
         return Some(crate::code_connect::render(doc, &c, &values, link, lang, &pad));
     }
diff --git a/crates/engine/src/components.rs b/crates/engine/src/components.rs
index da0b2d13d..91402b58a 100644
--- a/crates/engine/src/components.rs
+++ b/crates/engine/src/components.rs
@@ -11,12 +11,13 @@
 //! Override groups: `fills`, `strokes`, `effects`, `opacity`, `visible`, `name`, `corners`,
 //! `characters`, `textStyle` (font, size, spacing, resizing, …), `padding`, `gap` and `alignment`
 //! (of auto layout: its direction and other settings are the main's), `grids`, `exports`,
-//! `interactions`, `component` (a swapped nested instance), `props` (property values of a nested
-//! instance) and `slot` (a slot holding the instance's own content). An instance's own export
-//! settings and interactions are its own, like its place. `size` and `position` overrides of
-//! layers inside an instance are still read and kept, but new ones are refused
-//! ([`check_override_edit`]): those layers take their geometry, constraints and resizing from the
-//! main; the instance itself resizes.
+//! `interactions`, `size` and `resizing` (hug, fill or fixed, with min and max sizes) of layers
+//! inside an instance, `modes` (the variable modes a layer inside an instance chooses),
+//! `component` (a swapped nested instance), `props` (property values of a nested instance) and
+//! `slot` (a slot holding the instance's own content). An instance's own export settings,
+//! interactions, resizing and variable modes are its own, like its place. `position`
+//! overrides of layers inside an instance are still read and kept, but new ones are refused
+//! ([`check_override_edit`]): those layers take their place and constraints from the main.
 //!
 //! Switching variants keeps an override where the layer's name path matches and the two variants
 //! agreed on that property (text layers keep all of theirs); swapping from the Assets panel keeps
@@ -58,7 +59,9 @@ pub const OVERRIDE_GROUPS: &[&str] = &[
     "exports",
     "interactions",
     "size",
+    "resizing",
     "position",
+    "modes",
     "component",
     "props",
     SLOT,
@@ -113,6 +116,23 @@ pub fn inside_instance(doc: &Document, id: NodeId) -> bool {
     enclosing_instance(doc, id).is_some()
 }
 
+/// Mark the `modes` override on layers inside instances whose variable modes differ from their
+/// main layer's, for files from before `modes` was an override group. Copies follow their main
+/// layer's modes, so a layer on other modes chose them itself.
+pub fn mark_layer_modes(doc: &mut Document) {
+    let chose: Vec<NodeId> = doc
+        .nodes()
+        .filter(|n| !n.overrides.contains("modes") && n.source.and_then(|s| doc.node(s)).is_some_and(|m| m.var_modes != n.var_modes))
+        .map(|n| n.id)
+        .filter(|id| inside_instance(doc, *id))
+        .collect();
+    for id in chose {
+        if let Some(n) = doc.node_mut(id) {
+            n.overrides.insert("modes".into());
+        }
+    }
+}
+
 /// The slot property frame `id` stands for (its name and preferred components): a frame bound to
 /// a slot property of its component, or an instance's copy of one (followed through its sources).
 pub fn slot_def(doc: &Document, id: NodeId) -> Option<(&str, &[NodeId])> {
@@ -284,11 +304,28 @@ pub fn create_instance_at(doc: &mut Document, component: NodeId, parent: NodeId,
     root.dev_resources.clear();
     // The main's interactions play on its instances in prototypes; the instance's own start empty.
     root.interactions.clear();
+    // So do the variable modes the main sets (see `Document::inherited_modes`).
+    root.var_modes.clear();
     doc.insert(root, parent, index)?;
     sync_instance(doc, id);
     Ok(id)
 }
 
+/// Copy `id` within its own file under `parent` (at `index`), keeping its local transform. A file
+/// has one main per component, so a main component's copy is an instance of it; a variant copied
+/// into its set stays a new variant, and every other layer is deep-copied.
+pub fn copy_in_file(doc: &mut Document, id: NodeId, parent: NodeId, index: Option<usize>) -> Result<NodeId, DocError> {
+    let n = doc.get(id)?;
+    let in_set = doc.node(parent).is_some_and(|p| matches!(p.kind, NodeKind::ComponentSet { .. }));
+    if !matches!(n.kind, NodeKind::Component { .. }) || in_set {
+        return doc.duplicate_into(id, parent, index);
+    }
+    let transform = n.transform;
+    let instance = create_instance_at(doc, id, parent, 0.0, 0.0, index)?;
+    doc.get_mut(instance)?.transform = transform;
+    Ok(instance)
+}
+
 /// Which part of the carried overrides to apply.
 #[derive(Clone, Copy, PartialEq)]
 enum Carry {
@@ -317,6 +354,27 @@ fn carry_overrides(from: &Node, to: &mut Node, what: Carry) {
     }
 }
 
+/// An instance switched from variant `was` to `new`: its resizing (sizing and min / max per axis)
+/// that is still `was`'s follows `new`; what the instance set itself stays in `own`.
+fn follow_variant_resizing(own: &mut ChildLayout, was: &ChildLayout, new: &ChildLayout) {
+    if own.sizing_h == was.sizing_h {
+        own.sizing_h = new.sizing_h;
+    }
+    if own.sizing_v == was.sizing_v {
+        own.sizing_v = new.sizing_v;
+    }
+    for (o, w, n) in [
+        (&mut own.min_w, was.min_w, new.min_w),
+        (&mut own.max_w, was.max_w, new.max_w),
+        (&mut own.min_h, was.min_h, new.min_h),
+        (&mut own.max_h, was.max_h, new.max_h),
+    ] {
+        if *o == w {
+            *o = n;
+        }
+    }
+}
+
 /// Copy the values of property group `g` of `from` onto `to`, with the variables bound to them.
 pub(crate) fn copy_group(from: &Node, to: &mut Node, g: &str) {
     if from.bound.iter().chain(to.bound.iter()).any(|(k, _)| binding_group(k) == Some(g)) {
@@ -388,12 +446,16 @@ pub(crate) fn copy_group(from: &Node, to: &mut Node, g: &str) {
         "size" => {
             to.width = from.width;
             to.height = from.height;
-            to.child_layout = from.child_layout.clone();
             if let (NodeKind::Text(a), NodeKind::Text(b)) = (&from.kind, &mut to.kind) {
                 b.auto_resize = a.auto_resize;
             }
         }
+        "resizing" => {
+            let (a, b) = (&from.child_layout, &mut to.child_layout);
+            (b.sizing_h, b.sizing_v, b.min_w, b.max_w, b.min_h, b.max_h) = (a.sizing_h, a.sizing_v, a.min_w, a.max_w, a.min_h, a.max_h);
+        }
         "position" => to.transform = from.transform,
+        "modes" => to.var_modes = from.var_modes.clone(),
         "component" => {
             if let (NodeKind::Instance { component: a, .. }, NodeKind::Instance { component: b, .. }) = (&from.kind, &mut to.kind) {
                 *b = *a;
@@ -758,6 +820,7 @@ fn sync_instance_depth(doc: &mut Document, inst: NodeId, depth: usize, spare: BT
     if let Some(prev) = root.source.and_then(|p| doc.node(p)).filter(|p| sibling_variants(doc, p.id, component)) {
         let differs = diff_groups(prev, &comp);
         root.overrides.retain(|g| g == "name" || !differs.contains(&g.as_str()));
+        follow_variant_resizing(&mut fresh.child_layout, &prev.child_layout, &comp.child_layout);
     }
     carry_overrides(&root, &mut fresh, Carry::Root);
     if let Some(r) = doc.node_mut(inst) {
@@ -773,6 +836,15 @@ fn sync_instance_depth(doc: &mut Document, inst: NodeId, depth: usize, spare: BT
     for s in &src {
         let Some(nid) = map.get(s).copied() else { continue };
         let Some(o) = old.get(&nid) else { continue };
+        // A frame that kept the size its own resizing gave it: its layers (copied at their main
+        // layers' places) follow their constraints from its main layer's size.
+        if o.overrides.contains("resizing")
+            && !o.overrides.contains("size")
+            && doc.node(nid).is_some_and(|n| n.kind.is_frame_like() && n.layout.is_none())
+            && let Some((mw, mh)) = doc.node(*s).map(|m| (m.width, m.height))
+        {
+            figcraft_layout::apply_constraints(doc, nid, mw, mh);
+        }
         if !o.overrides.contains("size") && !o.overrides.contains("position") {
             continue;
         }
@@ -800,9 +872,10 @@ fn sync_instance_depth(doc: &mut Document, inst: NodeId, depth: usize, spare: BT
     }
     // Nested instances showing another main than the main's copy (swapped): rebuild from it,
     // with the old layers below them this rebuild didn't reuse.
-    let unused: BTreeMap<NodeId, std::sync::Arc<Node>> = old.into_iter().filter(|(i, _)| !used.contains(i) && !doc.contains(*i)).collect();
+    let unused: BTreeMap<NodeId, std::sync::Arc<Node>> =
+        old.iter().filter(|(i, _)| !used.contains(*i) && !doc.contains(**i)).map(|(i, x)| (*i, x.clone())).collect();
     for n in nested {
-        let below: BTreeMap<NodeId, std::sync::Arc<Node>> = unused
+        let mut below: BTreeMap<NodeId, std::sync::Arc<Node>> = unused
             .iter()
             .filter(|(_, x)| {
                 let mut cur = x.parent;
@@ -817,10 +890,77 @@ fn sync_instance_depth(doc: &mut Document, inst: NodeId, depth: usize, spare: BT
             })
             .map(|(i, x)| (*i, x.clone()))
             .collect();
+        take_placing_overrides(doc, n, &old, &mut below);
         sync_instance_depth(doc, n, depth + 1, below);
     }
 }
 
+/// Before swapped nested instance `n` is rebuilt from its new main: each of its old layers (the
+/// copies just made of the outer main's, and `below`) takes the overrides held along the source
+/// chain it had before this rebuild (`before`), through layers inside instances in the mains that
+/// place `n`. Matched by name, they carry onto the new main's layers as the instance's own, so a
+/// swap takes what the outer main set once: later rebuilds find layers mirroring the new main.
+/// Geometry and slot content follow the new main; groups the layer overrides itself keep its value.
+fn take_placing_overrides(
+    doc: &mut Document,
+    n: NodeId,
+    before: &BTreeMap<NodeId, std::sync::Arc<Node>>,
+    below: &mut BTreeMap<NodeId, std::sync::Arc<Node>>,
+) {
+    let placing = placing_mains(doc, n);
+    for id in doc.subtree(n).into_iter().filter(|i| *i != n) {
+        let held = before.get(&id).map(|b| held_along(doc, b, &placing)).unwrap_or_default();
+        if let Some(layer) = doc.node_mut(id) {
+            take(layer, &held);
+        }
+    }
+    for layer in below.values_mut() {
+        let held = held_along(doc, layer, &placing);
+        if !held.is_empty() {
+            take(std::sync::Arc::make_mut(layer), &held);
+        }
+    }
+}
+
+/// The mains placing nested instance `n`: those of the layers it mirrors, outward.
+fn placing_mains(doc: &Document, n: NodeId) -> BTreeSet<NodeId> {
+    let mut out = BTreeSet::new();
+    let mut cur = doc.node(n).and_then(|x| x.source);
+    for _ in 0..=MAX_DEPTH {
+        let Some(s) = cur.and_then(|c| doc.node(c)).filter(|s| !matches!(s.kind, NodeKind::Component { .. })) else { break };
+        out.extend(owning_component(doc, s.id));
+        cur = s.source;
+    }
+    out
+}
+
+/// The overrides but geometry and slot content held along `layer`'s source chain while it runs
+/// through layers inside instances in `placing` mains, each with the nearest layer holding it.
+fn held_along(doc: &Document, layer: &Node, placing: &BTreeSet<NodeId>) -> BTreeMap<String, std::sync::Arc<Node>> {
+    let mut out = BTreeMap::new();
+    let mut cur = layer.source;
+    for _ in 0..=MAX_DEPTH {
+        let Some(s) = cur.and_then(|c| doc.node_arc(c)) else { break };
+        if !inside_instance(doc, s.id) || !owning_component(doc, s.id).is_some_and(|m| placing.contains(&m)) {
+            break;
+        }
+        for g in s.overrides.iter().filter(|g| !matches!(g.as_str(), "size" | "position" | SLOT)) {
+            out.entry(g.clone()).or_insert_with(|| s.clone());
+        }
+        cur = s.source;
+    }
+    out
+}
+
+/// Give `layer` the `held` groups it has no override of its own for.
+fn take(layer: &mut Node, held: &BTreeMap<String, std::sync::Arc<Node>>) {
+    for (g, from) in held {
+        if layer.overrides.insert(g.clone()) {
+            copy_group(from, layer, g);
+        }
+    }
+}
+
 /// Whether main components `a` and `b` are two variants of one set.
 fn sibling_variants(doc: &Document, a: NodeId, b: NodeId) -> bool {
     a != b && variant_set(doc, a).is_some_and(|s| variant_set(doc, b) == Some(s))
@@ -985,6 +1125,9 @@ pub fn diff_groups(a: &Node, b: &Node) -> Vec<&'static str> {
     if (a.width - b.width).abs() > 1e-6 || (a.height - b.height).abs() > 1e-6 {
         out.push("size");
     }
+    if resizing(a) != resizing(b) {
+        out.push("resizing");
+    }
     if a.transform != b.transform {
         out.push("position");
     }
@@ -1016,6 +1159,9 @@ pub fn diff_groups(a: &Node, b: &Node) -> Vec<&'static str> {
     if a.interactions != b.interactions {
         out.push("interactions");
     }
+    if a.var_modes != b.var_modes {
+        out.push("modes");
+    }
     if let (NodeKind::Instance { component: x, props: px }, NodeKind::Instance { component: y, props: py }) = (&a.kind, &b.kind) {
         if x != y {
             out.push("component");
@@ -1027,6 +1173,12 @@ pub fn diff_groups(a: &Node, b: &Node) -> Vec<&'static str> {
     out
 }
 
+/// The `resizing` group of a layer: how it sizes on each axis, and its min and max sizes.
+fn resizing(n: &Node) -> (Sizing, Sizing, [Option<f64>; 4]) {
+    let c = &n.child_layout;
+    (c.sizing_h, c.sizing_v, [c.min_w, c.max_w, c.min_h, c.max_h])
+}
+
 /// Whether two texts differ in anything but their characters (the `textStyle` group).
 fn text_style_differs(x: &TextData, y: &TextData) -> bool {
     x.style != y.style
@@ -1107,9 +1259,10 @@ pub fn sync_after_edit(doc: &mut Document, before: &Document, changed: &[NodeId]
         }
         let raw = diff_groups(b, n);
         let mut groups = raw.clone();
-        // An instance's own place, export settings and interactions are its own, not overrides.
+        // An instance's own place, resizing, export settings, interactions and variable modes are
+        // its own, not overrides.
         if top_root {
-            groups.retain(|g| !matches!(*g, "component" | "props" | "position" | "exports" | "interactions"));
+            groups.retain(|g| !matches!(*g, "component" | "props" | "position" | "resizing" | "exports" | "interactions" | "modes"));
         }
         if groups.iter().any(|g| matches!(*g, "size" | "position")) {
             groups.retain(|g| !matches!(*g, "size" | "position") || !geometry_derived(doc, before, id, g));
@@ -1414,7 +1567,7 @@ fn patch_structure(doc: &mut Document, before: &Document, seeds: &[NodeId]) -> b
 fn child_follows_main(doc: &Document, parent: NodeId, absolute: bool) -> bool {
     let Some(p) = doc.node(parent) else { return false };
     let constrains = p.layout.is_none() || absolute;
-    let resized = p.overrides.contains("size")
+    let resized = sized_own(p)
         || match &p.kind {
             NodeKind::Instance { component, .. } => {
                 doc.node(*component).is_none_or(|m| (m.width - p.width).abs() > 1e-9 || (m.height - p.height).abs() > 1e-9)
@@ -1475,7 +1628,7 @@ fn patch_copies(doc: &mut Document, seeds: &[(NodeId, Vec<&'static str>)]) -> bo
             let gs: Vec<&'static str> = groups
                 .iter()
                 .copied()
-                .filter(|g| !cn.overrides.contains(*g) && !(root && matches!(*g, "visible" | "name" | "position" | "exports" | "interactions")))
+                .filter(|g| !(cn.overrides.contains(*g) || root && matches!(*g, "visible" | "name" | "position" | "exports" | "interactions")))
                 .collect();
             if gs.is_empty() {
                 continue;
@@ -1518,7 +1671,7 @@ fn follows_main_geometry(doc: &Document, id: NodeId) -> bool {
     chain.windows(2).all(|w| {
         let (Some(below), Some(a)) = (w.first().and_then(|i| doc.node(*i)), w.get(1).and_then(|i| doc.node(*i))) else { return false };
         let constrains = a.layout.is_none() || below.child_layout.absolute;
-        if a.overrides.contains("size") && constrains {
+        if sized_own(a) && constrains {
             return false;
         }
         match &a.kind {
@@ -1530,6 +1683,12 @@ fn follows_main_geometry(doc: &Document, id: NodeId) -> bool {
     })
 }
 
+/// Whether a layer inside an instance overrides its size or resizing: it may not have its main
+/// layer's size, so the layers in it can't take their main layers' places as they are.
+fn sized_own(n: &Node) -> bool {
+    n.overrides.contains("size") || n.overrides.contains("resizing")
+}
+
 /// Rebuild every instance of `comps` (and of the components that hold those instances, and so on
 /// outwards), each outermost instance once, inner components first.
 fn rebuild_instances(doc: &mut Document, comps: &BTreeSet<NodeId>) {
@@ -1665,10 +1824,9 @@ pub fn check_override_edit(before: &Document, after: &Document) -> Result<(), St
 
 /// What about layer `id` an edit from `before` to `after` changed that only its main can: the
 /// auto layout of an instance or a layer in one but its padding, gap and alignment, or the
-/// position (rotation too), size, constraints or resizing of a layer inside an instance (the
-/// instance itself resizes, and its layers follow; text whose box follows its content still
-/// does). `None` when the edit is fine, also when the main changed the same way in this edit (a
-/// library update).
+/// position (rotation too), constraints or place in auto layout (absolute, grid cell) of a layer
+/// inside an instance (its size and resizing are overrides). `None` when the edit is fine, also
+/// when the main changed the same way in this edit (a library update).
 pub fn refused_override(before: &Document, after: &Document, id: NodeId) -> Option<&'static str> {
     let (n, b) = (after.node(id)?, before.node(id)?);
     if after.is_remote(id) || n.source != b.source || owning_instance(before, id).is_none() || owning_instance(after, id).is_none() {
@@ -1684,8 +1842,12 @@ pub fn refused_override(before: &Document, after: &Document, id: NodeId) -> Opti
             l
         })
     };
-    let size = |x: &Node| (x.width, x.height);
-    let resized = |x: &Node, y: &Node| (x.width - y.width).abs() > 1e-6 || (x.height - y.height).abs() > 1e-6;
+    // Child layout settings other than the resizing ones.
+    let placing = |x: &Node| {
+        let mut c = x.child_layout.clone();
+        (c.sizing_h, c.sizing_v, c.min_w, c.max_w, c.min_h, c.max_h) = (Sizing::Fixed, Sizing::Fixed, None, None, None, None);
+        c
+    };
     if mode(n) != mode(b) && mode(ma) == mode(mb) {
         return Some("The auto layout direction");
     }
@@ -1698,18 +1860,174 @@ pub fn refused_override(before: &Document, after: &Document, id: NodeId) -> Opti
     if n.transform != b.transform && ma.transform == mb.transform && !geometry_derived(after, before, id, "position") {
         return Some("A layer's position");
     }
-    if resized(n, b) && size(ma) == size(mb) && !geometry_derived(after, before, id, "size") {
-        return Some("A layer's size");
-    }
     if n.constraints != b.constraints && ma.constraints == mb.constraints {
         return Some("A layer's constraints");
     }
-    if n.child_layout != b.child_layout && ma.child_layout == mb.child_layout {
-        return Some("A layer's resizing");
+    if placing(n) != placing(b) && placing(ma) == placing(mb) {
+        return Some("A layer's place in auto layout");
     }
     None
 }
 
+/// Bounded source and parent lookups while a rebase reads an unchanged document.
+struct RebaseSources<'a> {
+    doc: &'a Document,
+    chains: BTreeMap<NodeId, Option<Vec<NodeId>>>,
+    parents: BTreeMap<(NodeId, NodeId), Option<bool>>,
+    main_changes: BTreeMap<NodeId, bool>,
+}
+
+impl<'a> RebaseSources<'a> {
+    const PARENTS: usize = 512;
+    const CACHE: usize = 8192;
+
+    fn new(doc: &'a Document) -> Self {
+        Self { doc, chains: BTreeMap::new(), parents: BTreeMap::new(), main_changes: BTreeMap::new() }
+    }
+
+    fn chain(&mut self, source: NodeId) -> Option<Vec<NodeId>> {
+        if let Some(chain) = self.chains.get(&source) {
+            return chain.clone();
+        }
+        let read = || {
+            let mut chain = Vec::new();
+            let mut seen = BTreeSet::new();
+            let mut current = Some(source);
+            for _ in 0..MAX_DEPTH {
+                let Some(id) = current else { return Some(chain) };
+                if !seen.insert(id) {
+                    return None;
+                }
+                let n = self.doc.node(id)?;
+                chain.push(id);
+                current = n.source;
+            }
+            current.is_none().then_some(chain)
+        };
+        let chain = read();
+        if self.chains.len() < Self::CACHE {
+            self.chains.insert(source, chain.clone());
+        }
+        chain
+    }
+
+    /// Validate the complete parent chain, even if `main` was found before a cycle.
+    fn in_main(&mut self, id: NodeId, main: NodeId) -> Option<bool> {
+        if let Some(found) = self.parents.get(&(id, main)) {
+            return *found;
+        }
+        let read = || {
+            let mut current = Some(id);
+            let mut seen = BTreeSet::new();
+            let mut found = false;
+            for _ in 0..Self::PARENTS {
+                let Some(id) = current else { return Some(found) };
+                if !seen.insert(id) {
+                    return None;
+                }
+                found |= id == main;
+                current = self.doc.node(id)?.parent;
+            }
+            current.is_none().then_some(found)
+        };
+        let found = read();
+        if self.parents.len() < Self::CACHE {
+            self.parents.insert((id, main), found);
+        }
+        found
+    }
+
+    fn member(&mut self, source: NodeId, main: NodeId, target: NodeId) -> Option<NodeId> {
+        let chain = self.chain(source)?;
+        if chain.contains(&target) {
+            return None;
+        }
+        let mut member = None;
+        for id in chain {
+            if self.in_main(id, main)? && id != main && member.is_none() {
+                member = Some(id);
+            }
+        }
+        member
+    }
+
+    /// Nearest enclosing instances and their current mains. Slots with own content end scope.
+    fn owners(&self, id: NodeId) -> Option<Vec<(NodeId, NodeId)>> {
+        let mut owners = Vec::new();
+        let mut current = self.doc.node(id)?.parent;
+        let mut seen = BTreeSet::from([id]);
+        for _ in 0..Self::PARENTS {
+            let Some(id) = current else { return Some(owners) };
+            if !seen.insert(id) {
+                return None;
+            }
+            let n = self.doc.node(id)?;
+            if holds_content(n) {
+                return Some(owners);
+            }
+            if let NodeKind::Instance { component, .. } = &n.kind {
+                owners.push((id, *component));
+            }
+            current = n.parent;
+        }
+        current.is_none().then_some(owners)
+    }
+
+    fn contextual(&mut self, source: NodeId, owners: &[(NodeId, NodeId)]) -> bool {
+        owners.iter().any(|(_, main)| self.in_main(source, *main) == Some(true) && source != *main)
+    }
+
+    /// A contextual child belongs to the same placed slot as its enclosing instance.
+    fn valid(&mut self, source: NodeId, target: NodeId, owners: &[(NodeId, NodeId)]) -> bool {
+        let Some((owner, main)) = owners.first() else { return false };
+        if self.member(source, *main, target).is_none() {
+            return false;
+        }
+        if self.in_main(source, *main) == Some(true) {
+            return true;
+        }
+        let Some(source_owner) = self.doc.node(*owner).and_then(|n| n.source) else { return false };
+        matches!(self.doc.node(source_owner).map(|n| &n.kind), Some(NodeKind::Instance { component, .. }) if component == main)
+            && self.owners(source).and_then(|owners| owners.first().copied()).is_some_and(|(id, _)| id == source_owner)
+    }
+
+    fn placed(&mut self, id: NodeId, owners: &[(NodeId, NodeId)]) -> Option<NodeId> {
+        let source = self.doc.node(id)?.source?;
+        if !matches!(self.doc.node(source)?.kind, NodeKind::Instance { .. } | NodeKind::Frame)
+            || !self.valid(source, id, owners)
+            || !self.contextual(source, owners)
+        {
+            return None;
+        }
+        Some(source)
+    }
+
+    fn beneath_swap(&mut self, owners: &[(NodeId, NodeId)], stop: NodeId) -> bool {
+        for (index, (id, main)) in owners.iter().enumerate() {
+            if *id == stop {
+                break;
+            }
+            let changed = if let Some(changed) = self.main_changes.get(id) {
+                *changed
+            } else {
+                let changed = self.placed(*id, &owners[index + 1..]).is_some_and(|source| match self.doc.node(source).map(|n| &n.kind) {
+                    Some(NodeKind::Instance { component, .. }) => component != main,
+                    Some(NodeKind::Frame) => true,
+                    _ => false,
+                });
+                if self.main_changes.len() < Self::CACHE {
+                    self.main_changes.insert(*id, changed);
+                }
+                changed
+            };
+            if changed {
+                return true;
+            }
+        }
+        false
+    }
+}
+
 /// Re-derive `source` links and overrides of instance `inst` against its own main by comparing
 /// values (after detaching an outer instance, restoring a main, or copying a nested instance out):
 /// the look is kept exactly. Values a component property sets aren't overrides.
@@ -1722,22 +2040,28 @@ pub fn rebase_instance(doc: &mut Document, inst: NodeId) {
         diff_groups(a, b).into_iter().filter(|g| !matches!(*g, "size" | "position")).map(str::to_string).collect()
     };
     let mut updates = Vec::new();
+    let mut sources = RebaseSources::new(doc);
+    let root_owners = sources.owners(inst).unwrap_or_default();
+    let placed_source = sources.placed(inst, &root_owners);
+    let mut contexts = vec![(inst, component)];
+    contexts.extend_from_slice(&root_owners);
     for (id, path) in &mine {
         let Some(n) = doc.node(*id) else { continue };
-        // Follow the source chain into the main first (exact), then fall back to the name path.
-        let mut main = None;
-        let mut cur = n.source;
-        for _ in 0..MAX_DEPTH {
-            let Some(c) = cur else { break };
-            if c != component && doc.contains(c) && doc.is_ancestor(component, c) {
-                main = Some(c);
-                break;
-            }
-            cur = doc.node(c).and_then(|x| x.source);
+        let owners = sources.owners(*id).unwrap_or_default();
+        let nearest_main = owners.first().map(|(_, main)| *main);
+        let valid_source = n.source.filter(|source| sources.valid(*source, *id, &owners));
+        let mut main = valid_source.and_then(|source| sources.member(source, component, *id));
+        // A swapped or Frame-to-Instance subtree is compared to its current main by the inner
+        // rebase. An outer name path must not rebind those children to the old expanded copies.
+        if main.is_none() && valid_source.is_some() && sources.beneath_swap(&owners, inst) {
+            updates.push((*id, valid_source, n.overrides.clone()));
+            continue;
         }
-        let main = main.or_else(|| theirs.get(path).copied());
+        main = main
+            .or_else(|| theirs.get(path).copied().filter(|source| nearest_main.is_some_and(|scope| sources.member(*source, scope, *id).is_some())));
+        let source = valid_source.filter(|source| sources.contextual(*source, &contexts)).filter(|_| main.is_some()).or(main);
         let mut overrides: BTreeSet<String> = n.overrides.iter().filter(|g| !matches!(g.as_str(), "component" | "props")).cloned().collect();
-        if let Some(m) = main.and_then(|m| doc.node(m)) {
+        if let Some(m) = source.and_then(|source| doc.node(source)) {
             let mut bound: Vec<&str> = m.prop_refs.keys().map(|f| field_group(f)).collect();
             bound.extend(variable_groups(n, m));
             overrides.extend(value_groups(m, n).into_iter().filter(|g| !bound.contains(&g.as_str())));
@@ -1745,36 +2069,56 @@ pub fn rebase_instance(doc: &mut Document, inst: NodeId) {
                 overrides.insert("component".into());
             }
         }
-        updates.push((*id, main, overrides));
+        updates.push((*id, source, overrides));
     }
+    // A placed nested root compares to its actual slot. A detached root compares to its own main.
+    let root_base = placed_source.or_else(|| {
+        let chain = sources.chain(component)?;
+        (!chain.contains(&inst) && sources.in_main(component, inst) == Some(false)).then_some(component)
+    });
+    let root_groups = match (root_base.and_then(|source| doc.node(source)), doc.node(inst)) {
+        (Some(m), Some(n)) => {
+            let from_variables = variable_groups(n, m);
+            let mut groups: Vec<String> = value_groups(m, n)
+                .into_iter()
+                .filter(|g| !matches!(g.as_str(), "name" | "exports" | "interactions") && !from_variables.contains(&g.as_str()))
+                .filter(|g| placed_source.is_some() || !matches!(g.as_str(), "resizing" | "modes"))
+                .collect();
+            let named = if placed_source.is_some() { n.name != m.name } else { n.name != default_instance_name(doc, component) };
+            if named {
+                groups.push("name".into());
+            }
+            if placed_source.is_some()
+                && matches!((&m.kind, &n.kind), (NodeKind::Instance { component: a, .. }, NodeKind::Instance { component: b, .. }) if a != b)
+            {
+                groups.push("component".into());
+            }
+            groups
+        }
+        _ => Vec::new(),
+    };
+    drop(sources);
     for (id, main, overrides) in updates {
         if let Some(n) = doc.node_mut(id) {
             n.source = main;
             n.overrides = if main.is_some() { overrides } else { BTreeSet::new() };
         }
     }
-    let root_groups = match (doc.node(component), doc.node(inst)) {
-        (Some(m), Some(n)) => {
-            let from_variables = variable_groups(n, m);
-            let mut groups: Vec<String> = value_groups(m, n)
-                .into_iter()
-                .filter(|g| !matches!(g.as_str(), "name" | "exports" | "interactions") && !from_variables.contains(&g.as_str()))
-                .collect();
-            // A layer name of its own (a nested instance renamed in its old main) stays.
-            if n.name != default_instance_name(doc, component) {
-                groups.push("name".into());
-            }
-            groups
-        }
-        _ => Vec::new(),
-    };
     if let Some(n) = doc.node_mut(inst) {
-        n.source = Some(component);
-        n.overrides.retain(|g| !matches!(g.as_str(), "component" | "props" | "position"));
+        n.source = root_base;
+        // A top-level instance's resizing and modes are its own (a nested one's override its main
+        // layer's).
+        n.overrides.retain(|g| {
+            !matches!(g.as_str(), "component" | "props" | "position") && (placed_source.is_some() || !matches!(g.as_str(), "resizing" | "modes"))
+        });
         n.overrides.extend(root_groups);
     }
 }
 
+#[cfg(test)]
+#[path = "components_rebase_source_tests.rs"]
+mod rebase_source_tests;
+
 /// A set's default variant: the one in its top-left corner (nearest to it, then the top-most, then
 /// the left-most).
 pub fn default_variant(doc: &Document, set: NodeId) -> Option<NodeId> {
diff --git a/crates/engine/src/components_behaviour_tests.rs b/crates/engine/src/components_behaviour_tests.rs
index 325ccdee5..a95e1268c 100644
--- a/crates/engine/src/components_behaviour_tests.rs
+++ b/crates/engine/src/components_behaviour_tests.rs
@@ -82,6 +82,179 @@ fn text(n: &Node) -> &TextData {
     n.kind.text().unwrap()
 }
 
+#[test]
+fn copying_a_main_component_pastes_a_linked_instance() {
+    for command in ["edit.paste", "edit.pasteOver", "edit.pasteReplace"] {
+        let mut s = Session::new();
+        let k = kit(&mut s);
+        ex(&mut s, "select.set", json!({"ids": [k.card]}));
+        ex(&mut s, "edit.copy", json!({}));
+        if command != "edit.paste" {
+            ex(&mut s, "select.set", json!({"ids": [k.inst]}));
+        }
+        let before = undo_len(&s);
+        let pasted = crate::params::id_of(&ex(&mut s, command, json!({}))["ids"][0]).unwrap();
+        assert_eq!(component_of(&s, pasted), k.card, "{command}");
+        assert_eq!(node(&s, pasted).parent, Some(s.page().unwrap()));
+        assert_eq!(node(&s, pasted).source, Some(k.card));
+        assert_eq!(undo_len(&s), before + 1);
+        ex(&mut s, "edit.undo", json!({}));
+        assert!(s.doc().unwrap().node(pasted).is_none());
+        ex(&mut s, "edit.redo", json!({}));
+        assert_eq!(component_of(&s, pasted), k.card);
+        ex(&mut s, "node.set", json!({"id": k.title, "props": {"characters": "Updated"}}));
+        assert_eq!(chars(&s, copy_of(&s, pasted, k.title)), "Updated");
+        healthy(&s);
+    }
+}
+
+#[test]
+fn copying_a_variant_pastes_an_instance_but_copying_its_set_keeps_the_components() {
+    let mut s = Session::new();
+    let (set, _, hover) = button_set(&mut s);
+    ex(&mut s, "select.set", json!({"ids": [hover]}));
+    ex(&mut s, "edit.copy", json!({}));
+    let pasted = crate::params::id_of(&ex(&mut s, "edit.paste", json!({}))["ids"][0]).unwrap();
+    assert_eq!(component_of(&s, pasted), hover);
+    assert_eq!(node(&s, pasted).name, node(&s, set).name);
+    let NodeKind::Instance { props, .. } = &node(&s, pasted).kind else { panic!("pasted variant is not an instance") };
+    assert_eq!(chars(&s, layer(&s, pasted, "Label").unwrap()), "Hover");
+    assert_eq!(props["Show dot"], true);
+    assert_eq!(node(&s, pasted).parent, Some(s.page().unwrap()));
+
+    ex(&mut s, "select.set", json!({"ids": [set]}));
+    ex(&mut s, "edit.copy", json!({}));
+    let copied_set = crate::params::id_of(&ex(&mut s, "edit.paste", json!({}))["ids"][0]).unwrap();
+    assert!(matches!(node(&s, copied_set).kind, NodeKind::ComponentSet { .. }));
+    assert_eq!(node(&s, copied_set).parent, Some(s.page().unwrap()));
+    assert_eq!(kids(&s, copied_set).len(), 2);
+    for variant in kids(&s, copied_set) {
+        assert!(matches!(node(&s, variant).kind, NodeKind::Component { .. }));
+        assert!(!kids(&s, set).contains(&variant));
+    }
+    healthy(&s);
+}
+
+#[test]
+fn cut_components_and_components_copied_to_another_file_remain_components() {
+    for (copy, undo_cut, new_file) in [("edit.cut", false, false), ("edit.cut", true, false), ("edit.copy", false, true)] {
+        let mut s = Session::new();
+        let k = kit(&mut s);
+        ex(&mut s, copy, json!({"ids": [k.card]}));
+        if undo_cut {
+            ex(&mut s, "edit.undo", json!({}));
+        }
+        if new_file {
+            ex(&mut s, "file.new", json!({}));
+        }
+        let page = s.page().unwrap();
+        let pasted = crate::params::id_of(&ex(&mut s, "edit.paste", json!({"parent": page}))["ids"][0]).unwrap();
+        assert!(matches!(node(&s, pasted).kind, NodeKind::Component { .. }), "{copy}, undo={undo_cut}, new_file={new_file}");
+        assert_eq!(kids(&s, pasted).len(), 3);
+        healthy(&s);
+    }
+}
+
+#[test]
+fn copying_a_component_does_not_link_to_an_id_reused_after_undo() {
+    let mut s = Session::new();
+    let frame = idv(&ex(&mut s, "frame.create", json!({"width": 120, "height": 60, "name": "Copied main"})));
+    let main = idv(&ex(&mut s, "component.create", json!({"ids": [frame]})));
+    ex(&mut s, "edit.copy", json!({"ids": [main]}));
+    s.undo().unwrap();
+    s.undo().unwrap();
+    let other = idv(&ex(&mut s, "frame.create", json!({"width": 300, "height": 200, "name": "Unrelated main"})));
+    ex(&mut s, "component.create", json!({"ids": [other]}));
+    assert_eq!(other, main, "undo makes the original id available again");
+    let page = s.page().unwrap();
+    let pasted = crate::params::id_of(&ex(&mut s, "edit.paste", json!({"parent": page}))["ids"][0]).unwrap();
+    assert_eq!(node(&s, pasted).name, "Copied main");
+    assert_eq!((node(&s, pasted).width, node(&s, pasted).height), (120.0, 60.0));
+    assert!(matches!(node(&s, pasted).kind, NodeKind::Component { .. }));
+    healthy(&s);
+}
+
+#[test]
+fn pasted_component_instances_keep_the_copied_transform_in_the_target_frame() {
+    let mut s = Session::new();
+    let k = kit(&mut s);
+    ex(&mut s, "node.set", json!({"id": k.card, "props": {"rotation": 30}}));
+    let original = s.doc().unwrap().world_transform(k.card);
+    let frame = idv(&ex(&mut s, "frame.create", json!({"x": -100, "y": -100, "width": 1000, "height": 1000})));
+    ex(&mut s, "edit.copy", json!({"ids": [k.card]}));
+    let pasted = crate::params::id_of(&ex(&mut s, "edit.paste", json!({"parent": frame}))["ids"][0]).unwrap();
+    assert_eq!(component_of(&s, pasted), k.card);
+    for (actual, expected) in s.doc().unwrap().world_transform(pasted).as_coeffs().into_iter().zip(original.as_coeffs()) {
+        assert!((actual - expected).abs() < 1e-9);
+    }
+    assert_eq!(node(&s, pasted).parent, Some(frame));
+    let before = s.doc().unwrap().clone();
+    assert!(s.execute("edit.paste", &json!({"parent": k.card})).is_err());
+    assert_eq!(s.doc().unwrap(), &before, "pasting into the main is refused atomically");
+    healthy(&s);
+}
+
+#[test]
+fn duplicating_a_main_component_makes_a_linked_instance() {
+    for rename in [false, true] {
+        let mut s = Session::new();
+        ex(&mut s, "pref.renameDuplicates", json!({"on": rename}));
+        let k = kit(&mut s);
+        let rect = idv(&ex(&mut s, "shape.rectangle", json!({"x": 0, "y": 300, "width": 50, "height": 50, "props": {"name": "Box"}})));
+        let before = s.doc().unwrap().clone();
+        let out = ex(&mut s, "edit.duplicate", json!({"ids": [k.card, rect]}));
+        let ids: Vec<NodeId> = out["ids"].as_array().unwrap().iter().filter_map(crate::params::id_of).collect();
+        assert_eq!(s.selection(), ids);
+        let copy = *ids.iter().find(|i| matches!(node(&s, **i).kind, NodeKind::Instance { .. })).expect("the main's copy is an instance");
+        assert_eq!(component_of(&s, copy), k.card);
+        assert_eq!(node(&s, copy).name, "Card", "instances keep their default name (rename={rename})");
+        assert_eq!(node(&s, copy).parent, Some(s.page().unwrap()));
+        let (b, c) = (s.doc().unwrap().world_bounds(k.card).unwrap(), s.doc().unwrap().world_bounds(copy).unwrap());
+        assert_eq!((c.x0, c.y0, c.width(), c.height()), (b.x1 + 100.0, b.y0, b.width(), b.height()), "a top-level frame's offset");
+        let other = *ids.iter().find(|i| **i != copy).unwrap();
+        assert!(matches!(node(&s, other).kind, NodeKind::Rectangle), "other layers are still copied");
+        ex(&mut s, "node.set", json!({"id": k.title, "props": {"characters": "Updated"}}));
+        assert_eq!(chars(&s, copy_of(&s, copy, k.title)), "Updated", "the instance follows its main");
+        ex(&mut s, "edit.undo", json!({}));
+        ex(&mut s, "edit.undo", json!({}));
+        assert_eq!(*s.doc().unwrap(), before, "undo restores exactly");
+        healthy(&s);
+    }
+}
+
+#[test]
+fn alt_dragging_a_main_component_copies_an_instance() {
+    use crate::tools::{PointerEvent, PointerKind};
+    let mut s = Session::new();
+    let f = idv(&ex(&mut s, "frame.create", json!({"x": 0, "y": 0, "width": 100, "height": 100, "name": "Tile"})));
+    let main = idv(&ex(&mut s, "component.create", json!({"ids": [f]})));
+    let ev = |kind, x| PointerEvent { alt: true, ..PointerEvent::at(kind, x, 50.0, 1.0) };
+    s.pointer(&ev(PointerKind::Down, 50.0)).unwrap();
+    s.pointer(&ev(PointerKind::Move, 150.0)).unwrap();
+    s.pointer(&ev(PointerKind::Move, 250.0)).unwrap();
+    s.pointer(&ev(PointerKind::Up, 250.0)).unwrap();
+    let [copy] = s.selection()[..] else { panic!("one copy selected") };
+    assert_eq!(component_of(&s, copy), main);
+    assert_eq!(s.doc().unwrap().world_bounds(copy).unwrap().x0, 200.0);
+    assert_eq!(s.doc().unwrap().world_bounds(main).unwrap().x0, 0.0, "the main stays");
+    healthy(&s);
+}
+
+#[test]
+fn duplicating_a_variant_adds_a_variant_to_its_set() {
+    let mut s = Session::new();
+    let (set, _, hover) = button_set(&mut s);
+    let copy = crate::params::id_of(&ex(&mut s, "edit.duplicate", json!({"ids": [hover]}))["ids"][0]).unwrap();
+    assert!(matches!(node(&s, copy).kind, NodeKind::Component { .. }));
+    assert_eq!(node(&s, copy).parent, Some(set));
+    assert_eq!(kids(&s, set).len(), 3);
+    // A whole set duplicates as a new set of variants.
+    let set2 = crate::params::id_of(&ex(&mut s, "edit.duplicate", json!({"ids": [set]}))["ids"][0]).unwrap();
+    assert!(matches!(node(&s, set2).kind, NodeKind::ComponentSet { .. }));
+    assert!(kids(&s, set2).iter().all(|v| matches!(node(&s, *v).kind, NodeKind::Component { .. })));
+    healthy(&s);
+}
+
 #[test]
 fn overridable_properties_stay_through_main_edits_and_reset() {
     // (what, layer, group, override on the instance, the same property edited on the main, read,
@@ -316,14 +489,6 @@ fn what_instances_cannot_override_is_refused() {
         ("nudge a layer", "transform.nudge", json!({"ids": ["$"], "dx": 1, "dy": 0}), Layer::Bg, "position"),
         ("rotate a layer", "node.set", json!({"id": "$", "props": {"rotation": 15}}), Layer::Bg, "position and rotation come with the layer's place"),
         ("flip a layer", "object.flipH", json!({"ids": ["$"]}), Layer::Bg, "position"),
-        (
-            "resize a layer",
-            "node.set",
-            json!({"id": "$", "props": {"width": 50}}),
-            Layer::Bg,
-            "not among the overridable properties; the instance resizes",
-        ),
-        ("resize a text box", "node.set", json!({"id": "$", "props": {"width": 150}}), Layer::Title, "\"the bounds of any text layers\""),
         (
             "change constraints",
             "node.set",
@@ -331,13 +496,6 @@ fn what_instances_cannot_override_is_refused() {
             Layer::Bg,
             "\"any constraints applied to the layers\"",
         ),
-        (
-            "make a layer fill its auto layout",
-            "node.set",
-            json!({"id": "$", "props": {"sizingH": "fill"}}),
-            Layer::Chip,
-            "resizing comes with the layer's size",
-        ),
         (
             "take a layer out of auto layout",
             "node.set",
@@ -499,6 +657,64 @@ fn switching_variants_keeps_overrides_where_the_variants_agreed() {
     healthy(&s);
 }
 
+/// A "Layout" set: Row (horizontal, hugging, a 40 wide "A") and Stacked (vertical, fixed 300 wide,
+/// "A" filling it). Returns (set, row, stacked).
+fn layout_set(s: &mut Session) -> (NodeId, NodeId, NodeId) {
+    let mut variants = Vec::new();
+    for (k, (name, props, child)) in [
+        ("Layout=Row", json!({"layout": "horizontal", "gap": 8, "sizingH": "hug", "sizingV": "hug", "fills": []}), json!({})),
+        (
+            "Layout=Stacked",
+            json!({"layout": "vertical", "gap": 8, "sizingH": "fixed", "width": 300, "sizingV": "hug", "fills": []}),
+            json!({"sizingH": "fill"}),
+        ),
+    ]
+    .into_iter()
+    .enumerate()
+    {
+        let c = idv(&ex(s, "node.create", json!({"type": "component", "name": name, "x": k as f64 * 400.0, "props": props})));
+        ex(s, "node.create", json!({"type": "rectangle", "parent": c, "name": "A", "width": 40, "height": 20, "props": child}));
+        variants.push(c);
+    }
+    let set = idv(&ex(s, "component.combineVariants", json!({"ids": variants.clone()})));
+    (set, variants[0], variants[1])
+}
+
+#[test]
+fn switching_variants_takes_the_new_variants_resizing_unless_the_instance_set_its_own() {
+    let mut s = Session::new();
+    let (set, row, stacked) = layout_set(&mut s);
+    let i = idv(&ex(&mut s, "instance.create", json!({"component": set, "x": 0, "y": 200})));
+    assert_eq!(component_of(&s, i), row);
+    ex(&mut s, "instance.setProperties", json!({"ids": [i], "properties": {"Layout": "Stacked"}}));
+    assert_eq!(component_of(&s, i), stacked);
+    let direct = idv(&ex(&mut s, "instance.create", json!({"component": stacked, "x": 0, "y": 400})));
+    let (n, d) = (node(&s, i), node(&s, direct));
+    assert_eq!(n.child_layout.sizing_h, Sizing::Fixed, "Row's Hug was never the instance's own: it takes Stacked's Fixed");
+    assert_eq!((n.width, n.child_layout.sizing_h), (d.width, d.child_layout.sizing_h), "the same as an instance made from Stacked");
+    let a = layer(&s, i, "A").unwrap();
+    assert_eq!((node(&s, a).child_layout.sizing_h, node(&s, a).width), (Sizing::Fill, 300.0), "A fills the 300 wide instance");
+    // Filling an auto layout parent afterwards leaves A filling, with nothing turned into an override.
+    let col = idv(&ex(
+        &mut s,
+        "node.create",
+        json!({"type": "frame", "name": "Column", "x": 600, "y": 0, "width": 500, "props": {"layout": "vertical", "sizingH": "fixed", "sizingV": "hug", "fills": []}}),
+    ));
+    ex(&mut s, "node.reparent", json!({"ids": [i], "parent": col}));
+    ex(&mut s, "node.set", json!({"ids": [i], "props": {"sizingH": "fill"}}));
+    let a = layer(&s, i, "A").unwrap();
+    assert_eq!(node(&s, a).child_layout.sizing_h, Sizing::Fill, "A still fills");
+    assert!(!node(&s, a).overrides.contains("resizing"), "A's resizing is still the main's");
+    assert_eq!(node(&s, a).width, node(&s, i).width);
+    // Resizing the instance set itself stays across a switch.
+    let own = idv(&ex(&mut s, "instance.create", json!({"component": set, "x": 0, "y": 600})));
+    ex(&mut s, "node.set", json!({"ids": [own], "props": {"minWidth": 120}}));
+    ex(&mut s, "instance.setProperties", json!({"ids": [own], "properties": {"Layout": "Stacked"}}));
+    assert_eq!(node(&s, own).child_layout.min_w, Some(120.0), "its own min width stays");
+    assert_eq!(node(&s, own).child_layout.sizing_h, Sizing::Fixed, "its sizing, still Row's, follows Stacked");
+    healthy(&s);
+}
+
 #[test]
 fn variant_combinations_order_default_and_conflicts() {
     let mut s = Session::new();
@@ -721,3 +937,35 @@ fn auto_layout_instances_follow_their_main() {
     assert_eq!(node(&s, i).child_layout.min_w, Some(80.0));
     healthy(&s);
 }
+
+#[test]
+fn a_new_component_set_is_named_after_its_first_variant() {
+    // "Button/State=Hover" groups under "Button": the set takes the path before the last '/'.
+    // A bare property name ("State=Default, Size=Small") names no set, and neither does an empty
+    // name: the set gets the next numbered default, like a new component. A plain name is kept.
+    let rows = [
+        ("Button/State=Hover", "Button", "slash-prefixed: the path before the last '/'"),
+        ("Icons/Arrow/Dir=Up", "Icons/Arrow", "nested path: everything before the last '/'"),
+        ("State=Default, Size=Small", "Component 1", "bare prop=value: not \"State\""),
+        ("", "Component 1", "empty name: the numbered default"),
+    ];
+    for (name, expected, why) in rows {
+        let mut s = Session::new();
+        let f = idv(&ex(&mut s, "frame.create", json!({"x": 0, "y": 0, "width": 40, "height": 20})));
+        ex(&mut s, "node.set", json!({"id": f, "props": {"name": name}}));
+        let c = idv(&ex(&mut s, "component.create", json!({"ids": [f]})));
+        assert_eq!(node(&s, c).name, name, "{why}: the variant keeps its name");
+        let set = idv(&ex(&mut s, "component.combineVariants", json!({"ids": [c]})));
+        assert_eq!(node(&s, set).name, expected, "{why}");
+        healthy(&s);
+    }
+
+    // Add variant on a lone component (a variant property on it) wraps it in a set named after it.
+    let mut s = Session::new();
+    let f = idv(&ex(&mut s, "frame.create", json!({"x": 0, "y": 0, "width": 40, "height": 20, "name": "Button"})));
+    let c = idv(&ex(&mut s, "component.create", json!({"ids": [f]})));
+    let set = idv(&ex(&mut s, "component.addProperty", json!({"id": c, "name": "State", "type": "variant"})));
+    assert_eq!(node(&s, set).name, "Button");
+    assert_eq!(node(&s, c).name, "State=Default");
+    healthy(&s);
+}
diff --git a/crates/engine/src/components_rebase_source_tests.rs b/crates/engine/src/components_rebase_source_tests.rs
new file mode 100644
index 000000000..94eae71f8
--- /dev/null
+++ b/crates/engine/src/components_rebase_source_tests.rs
@@ -0,0 +1,258 @@
+//! Contextual import sources survive rebasing; detached and swapped subtrees use their current mains.
+
+use super::*;
+
+fn add(doc: &mut Document, parent: NodeId, kind: NodeKind, name: &str) -> NodeId {
+    doc.create(parent, kind, name, 0.0, 0.0, 20.0, 20.0).unwrap()
+}
+
+fn component(doc: &mut Document, parent: NodeId, name: &str) -> NodeId {
+    add(doc, parent, NodeKind::Component { description: String::new(), props: BTreeMap::new() }, name)
+}
+
+fn mirror(doc: &mut Document, source: NodeId, parent: NodeId) -> NodeId {
+    let mut n = doc.node(source).unwrap().clone();
+    let children = std::mem::take(&mut n.children);
+    n.id = doc.alloc_id();
+    n.parent = None;
+    n.source = Some(source);
+    let id = n.id;
+    doc.insert(n, parent, None).unwrap();
+    for child in children {
+        mirror(doc, child, id);
+    }
+    id
+}
+
+fn instance(doc: &mut Document, main: NodeId, parent: NodeId, name: &str) -> NodeId {
+    let mut n = doc.node(main).unwrap().clone();
+    let children = std::mem::take(&mut n.children);
+    n.id = doc.alloc_id();
+    n.kind = NodeKind::Instance { component: main, props: BTreeMap::new() };
+    n.name = name.into();
+    n.parent = None;
+    n.source = None;
+    let id = n.id;
+    doc.insert(n, parent, None).unwrap();
+    for child in children {
+        mirror(doc, child, id);
+    }
+    id
+}
+
+struct Scene {
+    doc: Document,
+    inner: NodeId,
+    base: NodeId,
+    slot: NodeId,
+    context: NodeId,
+    root: NodeId,
+    nested: NodeId,
+    child: NodeId,
+}
+
+fn scene() -> Scene {
+    let mut doc = Document::new("Source context");
+    let page = doc.first_page().unwrap();
+    let inner = component(&mut doc, page, "Inner");
+    let base = add(&mut doc, inner, NodeKind::Rectangle, "Body");
+    doc.node_mut(base).unwrap().transform = Affine::translate((2.0, 0.0));
+    let outer = component(&mut doc, page, "Outer");
+    let slot = instance(&mut doc, inner, outer, "Nested");
+    doc.node_mut(slot).unwrap().source = Some(inner);
+    let context = doc.node(slot).unwrap().children[0];
+    doc.node_mut(context).unwrap().transform = Affine::translate((3.0, 0.0));
+    doc.node_mut(context).unwrap().opacity = 0.3;
+    let root = instance(&mut doc, outer, page, "Outer copy");
+    let nested = doc.node(root).unwrap().children[0];
+    let child = doc.node(nested).unwrap().children[0];
+    doc.node_mut(child).unwrap().transform = Affine::translate((2.0, 0.0));
+    doc.node_mut(child).unwrap().opacity = 0.2;
+    Scene { doc, inner, base, slot, context, root, nested, child }
+}
+
+fn both(s: &mut Scene) {
+    rebase_instance(&mut s.doc, s.nested);
+    rebase_instance(&mut s.doc, s.root);
+}
+
+#[test]
+fn rebase_default_only_sources_promote_to_the_actual_outer_context() {
+    let mut s = scene();
+    s.doc.node_mut(s.nested).unwrap().source = None;
+    s.doc.node_mut(s.child).unwrap().source = None;
+    both(&mut s);
+    assert_eq!(s.doc.node(s.nested).unwrap().source, Some(s.slot));
+    assert_eq!(s.doc.node(s.child).unwrap().source, Some(s.context));
+}
+
+#[test]
+fn rebase_rejects_a_context_source_from_another_nested_slot() {
+    let mut s = scene();
+    let outer = s.doc.node(s.slot).unwrap().parent.unwrap();
+    let sibling = instance(&mut s.doc, s.inner, outer, "Other nested slot");
+    s.doc.node_mut(sibling).unwrap().source = Some(s.inner);
+    let sibling_child = s.doc.node(sibling).unwrap().children[0];
+    mirror(&mut s.doc, sibling, s.root);
+    s.doc.node_mut(s.child).unwrap().source = Some(sibling_child);
+    both(&mut s);
+    assert_eq!(s.doc.node(s.nested).unwrap().source, Some(s.slot));
+    assert_eq!(s.doc.node(s.child).unwrap().source, Some(s.context));
+    assert_eq!(s.doc.node(sibling_child).unwrap().transform.translation().x, 2.0);
+    assert_eq!(s.doc.node(s.context).unwrap().transform.translation().x, 3.0);
+}
+
+#[test]
+fn rebase_does_not_mark_inherited_context_values_as_local_overrides() {
+    let mut s = scene();
+    s.doc.node_mut(s.child).unwrap().opacity = 0.3;
+    both(&mut s);
+    assert_eq!(s.doc.node(s.child).unwrap().source, Some(s.context));
+    assert!(!s.doc.node(s.child).unwrap().overrides.contains("opacity"));
+}
+
+#[test]
+fn rebase_preserves_multilevel_context_without_shortening_source_chains() {
+    let mut doc = Document::new("Nested source contexts");
+    let page = doc.first_page().unwrap();
+    let inner = component(&mut doc, page, "Inner");
+    let base = add(&mut doc, inner, NodeKind::Rectangle, "Body");
+    doc.node_mut(base).unwrap().transform = Affine::translate((2.0, 0.0));
+    let wrapper = component(&mut doc, page, "Wrapper");
+    let default_slot = instance(&mut doc, inner, wrapper, "Nested");
+    doc.node_mut(default_slot).unwrap().source = Some(inner);
+    let outer = component(&mut doc, page, "Outer");
+    let wrapper_slot = instance(&mut doc, wrapper, outer, "Wrapper slot");
+    doc.node_mut(wrapper_slot).unwrap().source = Some(wrapper);
+    let source_slot = doc.node(wrapper_slot).unwrap().children[0];
+    let context = doc.node(source_slot).unwrap().children[0];
+    doc.node_mut(context).unwrap().transform = Affine::translate((3.0, 0.0));
+    let root = instance(&mut doc, outer, page, "Outer copy");
+    let wrapper_copy = doc.node(root).unwrap().children[0];
+    let nested = doc.node(wrapper_copy).unwrap().children[0];
+    let child = doc.node(nested).unwrap().children[0];
+    doc.node_mut(nested).unwrap().name = "Renamed nested".into();
+    doc.node_mut(child).unwrap().transform = Affine::translate((2.0, 0.0));
+    for id in [nested, wrapper_copy, root] {
+        rebase_instance(&mut doc, id);
+        assert_eq!(doc.node(nested).unwrap().source, Some(source_slot));
+        assert_eq!(doc.node(child).unwrap().source, Some(context));
+    }
+    assert_eq!(doc.node(context).unwrap().source, Some(doc.node(default_slot).unwrap().children[0]));
+    assert_eq!(doc.node(context).unwrap().transform.translation().x, 3.0);
+    assert_eq!(doc.node(child).unwrap().transform.translation().x, 2.0);
+}
+
+#[test]
+fn rebase_preserves_placed_frame_to_instance_and_current_main_children() {
+    let mut doc = Document::new("Typed nested source");
+    let page = doc.first_page().unwrap();
+    let inner = component(&mut doc, page, "Inner");
+    let body = add(&mut doc, inner, NodeKind::Rectangle, "Body");
+    let outer = component(&mut doc, page, "Outer");
+    let slot = add(&mut doc, outer, NodeKind::Frame, "Empty slot");
+    let root = instance(&mut doc, outer, page, "Outer copy");
+    let nested = doc.node(root).unwrap().children[0];
+    doc.node_mut(nested).unwrap().kind = NodeKind::Instance { component: inner, props: BTreeMap::new() };
+    let child = mirror(&mut doc, body, nested);
+    rebase_instance(&mut doc, nested);
+    rebase_instance(&mut doc, root);
+    assert_eq!(doc.node(nested).unwrap().source, Some(slot));
+    assert_eq!(doc.node(child).unwrap().source, Some(body));
+    assert!(matches!(doc.node(nested).unwrap().kind, NodeKind::Instance { component, .. } if component == inner));
+}
+
+#[test]
+fn rebase_keeps_current_main_sources_and_component_delta_beneath_swap() {
+    let mut s = scene();
+    let page = s.doc.first_page().unwrap();
+    let replacement = component(&mut s.doc, page, "Replacement");
+    let body = add(&mut s.doc, replacement, NodeKind::Rectangle, "Body");
+    s.doc.node_mut(body).unwrap().transform = Affine::translate((7.0, 0.0));
+    s.doc.node_mut(s.nested).unwrap().kind = NodeKind::Instance { component: replacement, props: BTreeMap::new() };
+    s.doc.remove(s.child).unwrap();
+    s.child = mirror(&mut s.doc, body, s.nested);
+    s.doc.node_mut(s.child).unwrap().transform = Affine::translate((8.0, 0.0));
+    s.doc.node_mut(s.nested).unwrap().name = "Renamed swap".into();
+    rebase_instance(&mut s.doc, s.nested);
+    assert_eq!(s.doc.node(s.nested).unwrap().source, Some(s.slot));
+    assert!(s.doc.node(s.nested).unwrap().overrides.contains("component"));
+    rebase_instance(&mut s.doc, s.root);
+    assert_eq!(s.doc.node(s.nested).unwrap().source, Some(s.slot));
+    assert_eq!(s.doc.node(s.child).unwrap().source, Some(body));
+    assert!(s.doc.node(s.nested).unwrap().overrides.contains("component"));
+    assert_eq!(s.doc.node(s.child).unwrap().transform.translation().x, 8.0);
+}
+
+#[test]
+fn rebase_detached_nested_uses_own_main_and_keeps_inherited_geometry() {
+    let mut s = scene();
+    let page = s.doc.first_page().unwrap();
+    let detached = mirror(&mut s.doc, s.nested, page);
+    let child = s.doc.node(detached).unwrap().children[0];
+    // The old source references still exist, but their Outer context is absent here.
+    s.doc.node_mut(detached).unwrap().source = Some(s.slot);
+    s.doc.node_mut(child).unwrap().source = Some(s.context);
+    s.doc.node_mut(child).unwrap().transform = Affine::translate((3.0, 0.0));
+    rebase_instance(&mut s.doc, detached);
+    assert_eq!(s.doc.node(detached).unwrap().source, Some(s.inner));
+    assert_eq!(s.doc.node(child).unwrap().source, Some(s.base));
+    assert_eq!(s.doc.node(child).unwrap().transform.translation().x, 3.0);
+    assert_eq!(s.doc.node(s.base).unwrap().transform.translation().x, 2.0);
+}
+
+#[test]
+fn rebase_marks_a_nested_roots_own_mode_but_not_a_top_level_instances() {
+    let mut s = scene();
+    let modes = BTreeMap::from([("Tone".to_string(), "B".to_string())]);
+    s.doc.node_mut(s.nested).unwrap().var_modes = modes.clone();
+    both(&mut s);
+    assert!(s.doc.node(s.nested).unwrap().overrides.contains("modes"), "its slot in Outer sets no mode");
+    let page = s.doc.first_page().unwrap();
+    let detached = mirror(&mut s.doc, s.nested, page);
+    rebase_instance(&mut s.doc, detached);
+    let n = s.doc.node(detached).unwrap();
+    assert_eq!((&n.var_modes, n.overrides.contains("modes")), (&modes, false), "a top-level instance's modes are its own");
+}
+
+#[test]
+fn rebase_does_not_preserve_existing_foreign_or_stale_sources() {
+    let mut s = scene();
+    let page = s.doc.first_page().unwrap();
+    let foreign = component(&mut s.doc, page, "Foreign");
+    let foreign_body = add(&mut s.doc, foreign, NodeKind::Rectangle, "Body");
+    s.doc.node_mut(s.child).unwrap().source = Some(foreign_body);
+    both(&mut s);
+    assert_ne!(s.doc.node(s.child).unwrap().source, Some(foreign_body));
+    assert_eq!(s.doc.node(s.child).unwrap().source, Some(s.context));
+    let mut s = scene();
+    let page = s.doc.first_page().unwrap();
+    let replacement = component(&mut s.doc, page, "Replacement");
+    let body = add(&mut s.doc, replacement, NodeKind::Rectangle, "Body");
+    s.doc.node_mut(s.nested).unwrap().kind = NodeKind::Instance { component: replacement, props: BTreeMap::new() };
+    s.doc.node_mut(s.child).unwrap().source = Some(s.context);
+    both(&mut s);
+    assert_ne!(s.doc.node(s.child).unwrap().source, Some(s.context), "the old default-main child is stale after a swap");
+    assert!(s.doc.node(s.child).unwrap().source.is_none() || s.doc.node(s.child).unwrap().source == Some(body));
+}
+
+#[test]
+fn rebase_rejects_source_and_parent_cycles_with_bounded_lookups() {
+    let mut s = scene();
+    s.doc.node_mut(s.base).unwrap().source = Some(s.context);
+    both(&mut s);
+    assert_eq!(s.doc.node(s.child).unwrap().source, None);
+    let mut s = scene();
+    s.doc.node_mut(s.context).unwrap().parent = Some(s.context);
+    both(&mut s);
+    assert_ne!(s.doc.node(s.child).unwrap().source, Some(s.context));
+    let mut s = scene();
+    s.doc.node_mut(s.nested).unwrap().parent = Some(s.child);
+    s.doc.node_mut(s.child).unwrap().parent = Some(s.nested);
+    let sources = RebaseSources::new(&s.doc);
+    assert!(sources.owners(s.child).is_none());
+    let mut s = scene();
+    s.doc.node_mut(s.root).unwrap().kind = NodeKind::Instance { component: s.root, props: BTreeMap::new() };
+    rebase_instance(&mut s.doc, s.root);
+    assert_ne!(s.doc.node(s.root).unwrap().source, Some(s.root));
+}
diff --git a/crates/engine/src/components_scale_tests.rs b/crates/engine/src/components_scale_tests.rs
index c796dad8a..68465932b 100644
--- a/crates/engine/src/components_scale_tests.rs
+++ b/crates/engine/src/components_scale_tests.rs
@@ -747,3 +747,29 @@ fn alt_dropping_a_library_component_swaps_to_it() {
     assert!(doc.node(glyph).unwrap().overrides.is_empty());
     let _ = std::fs::remove_dir_all(dir);
 }
+
+#[test]
+fn a_fill_set_on_a_bound_instance_layer_detaches_it_as_an_override() {
+    // Without unbinding first: the explicit colour detaches the variable on the instance layer only,
+    // and stays through main edits until the override is reset.
+    let mut s = Session::new();
+    let (chip, _) = bound_chip(&mut s);
+    let i = crate::params::id_of(&ex(&mut s, "instance.create", json!({"component": chip, "x": 200, "y": 0}))["id"]).unwrap();
+    let bg = find_path(s.doc().unwrap(), i, &["Bg"]).unwrap();
+    ex(&mut s, "node.set", json!({"ids": [bg], "props": {"fill": "#ff00ff"}}));
+    let n = s.doc().unwrap().node(bg).unwrap().clone();
+    assert_eq!(n.fills[0].solid_color().unwrap().to_hex(), "FF00FF");
+    assert!(!n.bound.contains_key("fill"));
+    assert!(n.overrides.contains("fills"));
+    let main_bg = find_path(s.doc().unwrap(), chip, &["Bg"]).unwrap();
+    ex(&mut s, "node.set", json!({"ids": [main_bg], "props": {"height": 28}}));
+    ex(&mut s, "variable.set", json!({"variable": "Chip", "value": "#445566"}));
+    let doc = s.doc().unwrap();
+    healthy(doc);
+    assert_eq!(doc.node(bg).unwrap().fills[0].solid_color().unwrap().to_hex(), "FF00FF");
+    assert!(doc.node(main_bg).unwrap().bound.contains_key("fill"), "the main keeps its binding");
+    ex(&mut s, "component.resetOverride", json!({"id": bg, "group": "fills"}));
+    let n = s.doc().unwrap().node(bg).unwrap();
+    assert!(n.bound.contains_key("fill"));
+    assert_eq!(n.fills[0].solid_color().unwrap().to_hex(), "445566");
+}
diff --git a/crates/engine/src/components_tests.rs b/crates/engine/src/components_tests.rs
index eb21b20ea..209560cdb 100644
--- a/crates/engine/src/components_tests.rs
+++ b/crates/engine/src/components_tests.rs
@@ -67,8 +67,6 @@ fn overrides_survive_main_edits() {
     ex(&mut s, "node.set", json!({"id": ibg, "props": {"effects": [{"type": "dropShadow"}]}}));
     ex(&mut s, "text.set", json!({"id": ititle, "characters": "Overridden"}));
     ex(&mut s, "node.set", json!({"id": idot, "props": {"visible": false}}));
-    // A layer inside an instance keeps its main's size (the instance itself resizes).
-    assert!(s.execute("node.set", &json!({"id": idot, "props": {"width": 30}})).is_err());
     let ov = node(&s, ibg).overrides;
     for g in ["fills", "strokes", "effects", "name"] {
         assert!(ov.contains(g), "{g} in {ov:?}");
diff --git a/crates/engine/src/convert_container_tests.rs b/crates/engine/src/convert_container_tests.rs
index 7c25a6205..be338a82f 100644
--- a/crates/engine/src/convert_container_tests.rs
+++ b/crates/engine/src/convert_container_tests.rs
@@ -1,5 +1,5 @@
-//! Frames and groups converted into each other in place: the layers stay where they are on the
-//! page, what only a frame has goes with it, what can't convert is refused, one undo step.
+//! Frames, groups and sections converted into each other in place: the layers stay where they are on
+//! the page, what only a frame has goes with it, what can't convert is refused, one undo step.
 
 use serde_json::{Value, json};
 
@@ -136,7 +136,7 @@ fn what_cannot_convert_is_refused_and_nothing_changes() {
 #[test]
 fn junk_parameters_are_refused_not_fatal() {
     let junk = [json!(null), json!(true), json!(-1), json!(1e308), json!("x"), json!([[1]]), json!({"a": 1}), json!([0, 999_999, "7"])];
-    for cmd in ["object.convertToGroup", "object.convertToFrame"] {
+    for cmd in ["object.convertToGroup", "object.convertToFrame", "object.convertToSection"] {
         for j in &junk {
             let mut s = Session::new();
             let f = id(ex(&mut s, "frame.create", json!({"x": 0, "y": 0, "width": 50, "height": 50})));
@@ -148,3 +148,72 @@ fn junk_parameters_are_refused_not_fatal() {
         }
     }
 }
+
+#[test]
+fn a_frame_on_the_page_becomes_a_section_and_back() {
+    let mut s = Session::new();
+    let f = id(ex(&mut s, "frame.create", json!({"x": 100, "y": 50, "width": 300, "height": 200, "name": "Flow", "props": {"fill": "#FFEEDD"}})));
+    let (a, b) = (rect(&mut s, f, 20.0, 30.0), rect(&mut s, f, 400.0, 90.0));
+    ex(&mut s, "layout.add", json!({"ids": [f], "direction": "horizontal"}));
+    ex(&mut s, "node.set", json!({"id": f, "props": {"width": 300, "height": 200}}));
+    let before = [page_box(&s, a), page_box(&s, b), page_box(&s, f)];
+    assert_eq!(ex(&mut s, "object.convertToSection", json!({"ids": [f]}))["ids"], json!([f]));
+    let n = s.doc().unwrap().node(f).unwrap().clone();
+    assert!(matches!(n.kind, NodeKind::Section { contents_hidden: false }));
+    assert_eq!((n.name.as_str(), n.children.clone(), n.fills.len()), ("Flow", vec![a, b], 1), "same name, layers and fill");
+    assert!(n.layout.is_none() && !n.clip, "no auto layout or clipping on a section");
+    assert_eq!([page_box(&s, a), page_box(&s, b), page_box(&s, f)], before, "nothing moves");
+    // And back: a frame that keeps the fill and doesn't clip, so the look stays.
+    assert_eq!(ex(&mut s, "object.convertToFrame", json!({"ids": [f]}))["ids"], json!([f]));
+    let n = s.doc().unwrap().node(f).unwrap().clone();
+    assert!(matches!(n.kind, NodeKind::Frame) && n.fills.len() == 1 && !n.clip);
+    assert_eq!([page_box(&s, a), page_box(&s, b), page_box(&s, f)], before);
+    // Each conversion is one undo step.
+    ex(&mut s, "edit.undo", json!({}));
+    assert!(matches!(kind(&s, f), NodeKind::Section { .. }));
+    ex(&mut s, "edit.undo", json!({}));
+    assert!(matches!(kind(&s, f), NodeKind::Frame));
+    assert!(s.doc().unwrap().node(f).unwrap().layout.is_some(), "the frame's auto layout is back");
+}
+
+#[test]
+fn only_frames_on_the_page_or_in_a_section_become_sections() {
+    let mut s = Session::new();
+    let outer = id(ex(&mut s, "frame.create", json!({"x": 0, "y": 0, "width": 300, "height": 300})));
+    let inner = id(ex(&mut s, "frame.create", json!({"parent": outer, "x": 10, "y": 10, "width": 100, "height": 100})));
+    let err = s.execute("object.convertToSection", &json!({"ids": [inner]})).unwrap_err().to_string();
+    assert!(err.contains("inside a frame"), "{err}");
+    let r = rect(&mut s, outer, 150.0, 150.0);
+    assert!(s.execute("object.convertToSection", &json!({"ids": [r]})).is_err(), "a rectangle isn't a frame");
+    // A frame inside a section converts; a section holding a section can't become a frame.
+    let sec = id(ex(&mut s, "node.create", json!({"type": "section", "x": 500, "y": 0, "width": 400, "height": 400})));
+    let in_sec = id(ex(&mut s, "frame.create", json!({"parent": sec, "x": 20, "y": 20, "width": 100, "height": 100})));
+    ex(&mut s, "object.convertToSection", json!({"ids": [in_sec]}));
+    assert!(matches!(kind(&s, in_sec), NodeKind::Section { .. }));
+    let err = s.execute("object.convertToFrame", &json!({"ids": [sec]})).unwrap_err().to_string();
+    assert!(err.contains("holds sections"), "{err}");
+    assert!(matches!(kind(&s, sec), NodeKind::Section { .. }), "nothing changed");
+}
+
+#[test]
+fn wrapping_errors_name_the_command_that_was_run() {
+    // Grouping, framing, auto layout, masks and booleans share one wrapping step; a refusal names
+    // the command that asked, not `object.group`.
+    let mut s = Session::new();
+    let page = s.page().unwrap();
+    for cmd in ["object.group", "object.frameSelection", "layout.add", "bool.union"] {
+        let err = s.execute(cmd, &json!({"ids": [page]})).unwrap_err().to_string();
+        assert!(err.contains(&format!("`{cmd}`")), "{cmd}: {err}");
+    }
+    let r = rect(&mut s, page, 0.0, 0.0);
+    let err = s.execute("object.mask", &json!({"ids": [page, r]})).unwrap_err().to_string();
+    assert!(err.contains("`object.mask`"), "{err}");
+    let section = id(ex(&mut s, "node.create", json!({"type": "section", "x": 300, "y": 0, "width": 100, "height": 100})));
+    ex(&mut s, "node.set", json!({"ids": [section], "props": {"fills": ["#FFFFFF"], "strokes": ["#000000"], "strokeWeight": 1}}));
+    let err = s.execute("vector.outlineStroke", &json!({"ids": [section]})).unwrap_err().to_string();
+    assert!(err.contains("`vector.outlineStroke`"), "{err}");
+    let f = id(ex(&mut s, "frame.create", json!({"x": 100, "y": 0, "width": 100, "height": 100})));
+    let inner = rect(&mut s, f, 10.0, 10.0);
+    let err = s.execute("object.wrapInSection", &json!({"ids": [inner, r]})).unwrap_err().to_string();
+    assert!(err.contains("`object.wrapInSection`"), "{err}");
+}
diff --git a/crates/engine/src/cursor_tests.rs b/crates/engine/src/cursor_tests.rs
index 05a95f66a..7a9e06216 100644
--- a/crates/engine/src/cursor_tests.rs
+++ b/crates/engine/src/cursor_tests.rs
@@ -202,15 +202,16 @@ fn an_edit_an_instance_refuses_shows_not_allowed_and_is_undone() {
     let before = s.doc().unwrap().world_bounds(inner).unwrap();
     assert_eq!((before.x0, before.y0, before.x1, before.y1), (450.0, 50.0, 550.0, 150.0));
     ex(&mut s, "select.set", json!({"ids": [inner]}));
-    // Resizing it by its right edge: only the main component can.
-    assert!(close(resize(hover(&mut s, (550.0, 100.0), NONE)), 0.0), "the handle still shows its arrow");
+    // Resizing it by its right edge: a size of its own (an override).
+    assert!(close(resize(hover(&mut s, (550.0, 100.0), NONE)), 0.0), "the handle shows its arrow");
     s.pointer(&ev(PointerKind::Down, (550.0, 100.0), NONE)).unwrap();
     s.pointer(&ev(PointerKind::Move, (570.0, 100.0), NONE)).unwrap();
     s.pointer(&ev(PointerKind::Move, (600.0, 100.0), NONE)).unwrap();
-    assert_eq!(s.tool.overlay.cursor, Cursor::NotAllowed);
+    assert_ne!(s.tool.overlay.cursor, Cursor::NotAllowed);
     s.pointer(&ev(PointerKind::Up, (600.0, 100.0), NONE)).unwrap();
-    assert_eq!(s.doc().unwrap().world_bounds(inner).unwrap(), before, "the resize was undone");
-    // Moving it: refused too.
+    let before = s.doc().unwrap().world_bounds(inner).unwrap();
+    assert_eq!((before.x0, before.x1), (450.0, 600.0), "the resize stays");
+    // Moving it: only the main component can.
     s.pointer(&ev(PointerKind::Down, (500.0, 100.0), NONE)).unwrap();
     s.pointer(&ev(PointerKind::Move, (510.0, 110.0), NONE)).unwrap();
     s.pointer(&ev(PointerKind::Move, (520.0, 120.0), NONE)).unwrap();
diff --git a/crates/engine/src/design_paste_tests.rs b/crates/engine/src/design_paste_tests.rs
new file mode 100644
index 000000000..89de80efc
--- /dev/null
+++ b/crates/engine/src/design_paste_tests.rs
@@ -0,0 +1,108 @@
+//! Paste of layers copied from another design app: the clipboard's design data (a `.fig` canvas in
+//! its HTML) read through the `.fig` import and pasted as Paste pastes our own layers.
+
+use base64::Engine as _;
+use serde_json::json;
+
+use super::*;
+use crate::cmd::edit::{CLIP_CLOSE, CLIP_OPEN, design_clipboard_buffer};
+
+const B64: base64::engine::GeneralPurpose = base64::engine::general_purpose::STANDARD;
+
+fn id(v: &Value) -> NodeId {
+    params::id_of(&v["id"]).unwrap()
+}
+
+fn copied_file() -> Vec<u8> {
+    let mut s = Session::new();
+    let frame = id(&s.execute("frame.create", &json!({"x": 0, "y": 0, "width": 200, "height": 100, "name": "Card"})).unwrap());
+    s.execute("node.create", &json!({"type": "rectangle", "x": 10, "y": 10, "width": 40, "height": 20, "parent": frame, "name": "Badge"})).unwrap();
+    s.execute("node.create", &json!({"type": "ellipse", "x": 300, "y": 0, "width": 50, "height": 50, "name": "Dot"})).unwrap();
+    let r = s.execute("file.export", &json!({"format": "fig"})).unwrap();
+    B64.decode(r["data"].as_str().unwrap()).unwrap()
+}
+
+fn clipboard_html(buffer: &[u8]) -> String {
+    let mut wrapped = B64.encode(buffer);
+    wrapped.insert(8, '\n');
+    format!(r#"<meta charset="utf-8"><span data-buffer="<!--{CLIP_OPEN}{wrapped}{CLIP_CLOSE}-->"></span>"#)
+}
+
+fn names(s: &Session, ids: &[NodeId]) -> Vec<String> {
+    let doc = s.doc().unwrap();
+    ids.iter().map(|i| doc.node(*i).unwrap().name.clone()).collect()
+}
+
+#[test]
+fn buffer_is_found_in_the_html() {
+    let file = copied_file();
+    assert_eq!(design_clipboard_buffer(&clipboard_html(&file)), Some(file));
+    assert_eq!(design_clipboard_buffer("<p>plain</p>"), None);
+    assert_eq!(design_clipboard_buffer(&format!("{CLIP_OPEN}not base64!{CLIP_CLOSE}")), None);
+    assert_eq!(design_clipboard_buffer(&format!("{CLIP_OPEN}{}{CLIP_CLOSE}", B64.encode(b"hello"))), None);
+    assert_eq!(design_clipboard_buffer(&format!("{CLIP_OPEN}ZmlnLQ")), None);
+    // Web text that only mentions the markers holds no design data.
+    assert_eq!(design_clipboard_buffer(&format!("<p>see {CLIP_OPEN} and {CLIP_CLOSE} in the docs</p>")), None);
+}
+
+#[test]
+fn oversized_design_data_is_refused_before_decoding() {
+    // Just past the cap (256 MB of data, as base64), made of valid base64 characters.
+    let big = "A".repeat((256 * 1024 * 1024usize).div_ceil(3) * 4 + 4);
+    assert_eq!(design_clipboard_buffer(&format!("{CLIP_OPEN}{big}{CLIP_CLOSE}")), None);
+    let mut s = Session::new();
+    let e = s.execute("edit.pasteDesignLayers", &json!({ "data": big })).unwrap_err();
+    assert!(e.to_string().contains("256 MB"), "{e}");
+    assert!(s.clipboard.nodes.is_empty());
+}
+
+#[test]
+fn layers_paste_into_the_page_and_undo() {
+    let mut s = Session::new();
+    let page = s.page().unwrap();
+    let r = s.execute("edit.pasteDesignLayers", &json!({"html": clipboard_html(&copied_file())})).unwrap();
+    let ids: Vec<NodeId> = r["ids"].as_array().unwrap().iter().map(|v| params::id_of(v).unwrap()).collect();
+    assert_eq!(names(&s, &ids), ["Card", "Dot"]);
+    assert_eq!(s.selection(), ids);
+    let doc = s.doc().unwrap();
+    assert!(ids.iter().all(|i| doc.node(*i).unwrap().parent == Some(page)));
+    let card = doc.node(ids[0]).unwrap();
+    assert_eq!(names(&s, &card.children), ["Badge"]);
+    assert_eq!((card.width, card.height), (200.0, 100.0));
+    assert!(s.undo().unwrap());
+    assert!(ids.iter().all(|i| !s.doc().unwrap().contains(*i)));
+}
+
+#[test]
+fn a_second_paste_repeats_the_copied_layers() {
+    let mut s = Session::new();
+    // `data` may be wrapped and unpadded, like the HTML's base64.
+    let mut data = B64.encode(copied_file()).trim_end_matches('=').to_string();
+    data.insert(8, '\n');
+    s.execute("edit.pasteDesignLayers", &json!({ "data": data })).unwrap();
+    let r = s.execute("edit.paste", &json!({})).unwrap();
+    let ids: Vec<NodeId> = r["ids"].as_array().unwrap().iter().map(|v| params::id_of(v).unwrap()).collect();
+    assert_eq!(names(&s, &ids), ["Card", "Dot"]);
+}
+
+#[test]
+fn pastes_into_the_selected_frame() {
+    let mut s = Session::new();
+    let host = id(&s.execute("frame.create", &json!({"x": 1000, "y": 0, "width": 800, "height": 600})).unwrap());
+    s.execute("select.set", &json!({"ids": [host]})).unwrap();
+    let r = s.execute("edit.pasteDesignLayers", &json!({"html": clipboard_html(&copied_file())})).unwrap();
+    let first = params::id_of(&r["ids"][0]).unwrap();
+    assert_eq!(s.doc().unwrap().node(first).unwrap().parent, Some(host));
+}
+
+#[test]
+fn other_content_is_refused_without_changes() {
+    let mut s = Session::new();
+    let before = s.doc().unwrap().nodes().count();
+    assert!(s.execute("edit.pasteDesignLayers", &json!({})).is_err());
+    assert!(s.execute("edit.pasteDesignLayers", &json!({"html": "<b>hi</b>"})).is_err());
+    assert!(s.execute("edit.pasteDesignLayers", &json!({"data": B64.encode(b"PK not a zip")})).is_err());
+    assert!(s.execute("edit.pasteDesignLayers", &json!({"data": B64.encode(b"fig-kiwi\x00\x00\x00\x00junk")})).is_err());
+    assert_eq!(s.doc().unwrap().nodes().count(), before);
+    assert!(s.clipboard.nodes.is_empty());
+}
diff --git a/crates/engine/src/devcompare.rs b/crates/engine/src/devcompare.rs
index 58cf9aa87..ef40a2fb0 100644
--- a/crates/engine/src/devcompare.rs
+++ b/crates/engine/src/devcompare.rs
@@ -1,6 +1,7 @@
 //! Dev Mode "Compare changes": what changed in a ready-for-dev frame or section since it was
-//! marked. The document keeps a snapshot of the layer from just before its first change
-//! ([`figcraft_doc::handoff`]); this compares it with the layer as it is now, layer by layer
+//! marked, or in any frame or section since a saved version. The document keeps a snapshot of a
+//! ready-for-dev layer from just before its first change ([`figcraft_doc::handoff`]); this compares
+//! it (or the layer in the version) with the layer as it is now, layer by layer
 //! (matched by id): layers added and removed, and for the others their properties formatted the
 //! way Inspect shows them (`width 120 → 136`, `fill #FF0000 → #E03030`).
 
@@ -93,20 +94,25 @@ pub struct Comparison {
     pub truncated: bool,
 }
 
-/// The changes to layer `id` since it was marked ready for dev (empty when it hasn't changed).
-pub fn compare(doc: &Document, id: NodeId) -> Comparison {
-    let n = doc.node(id);
-    let mut out = Comparison {
+/// Nothing compared yet for layer `id` of `doc` (`snapshot` false: the before isn't known).
+pub fn empty(doc: &Document, id: NodeId) -> Comparison {
+    Comparison {
         id,
-        name: n.map(|n| n.name.clone()).unwrap_or_default(),
-        changed: n.is_some_and(|n| n.dev_status == DevStatus::ReadyForDev && n.dev_changed),
+        name: doc.node(id).map(|n| n.name.clone()).unwrap_or_default(),
+        changed: false,
         snapshot: false,
         changes: Vec::new(),
         added: 0,
         removed: 0,
         modified: 0,
         truncated: false,
-    };
+    }
+}
+
+/// The changes to layer `id` since it was marked ready for dev (empty when it hasn't changed).
+pub fn compare(doc: &Document, id: NodeId) -> Comparison {
+    let mut out = empty(doc, id);
+    out.changed = doc.node(id).is_some_and(|n| n.dev_status == DevStatus::ReadyForDev && n.dev_changed);
     if !out.changed {
         return out;
     }
@@ -117,6 +123,21 @@ pub fn compare(doc: &Document, id: NodeId) -> Comparison {
     out
 }
 
+/// The changes to layer `id` of `now` since `before` (a saved version of the same file: layers
+/// match by id). A layer the version doesn't have was added as a whole.
+pub fn compare_with(before: &Document, now: &Document, id: NodeId) -> Comparison {
+    let mut out = empty(now, id);
+    out.snapshot = true;
+    let mut w = Walk { before, now, now_ids: bounded_set(now, id), before_ids: bounded_set(before, id), out: &mut out };
+    if before.contains(id) {
+        w.layer(id, 0);
+    } else {
+        w.whole(now, id, 0, ChangeKind::Added);
+    }
+    out.changed = !out.changes.is_empty();
+    out
+}
+
 /// The before and after documents of layer `id` (the snapshot's copy and the document), for
 /// rendering the two side by side.
 pub fn before_doc(doc: &Document, id: NodeId) -> Option<Document> {
@@ -127,17 +148,7 @@ pub fn before_doc(doc: &Document, id: NodeId) -> Option<Document> {
 /// Every layer that changed between two versions of a whole document, page by page (pages added
 /// or removed as a whole), for reviewing a branch.
 pub fn compare_docs(before: &Document, now: &Document) -> Comparison {
-    let mut out = Comparison {
-        id: NodeId(0),
-        name: now.name.clone(),
-        changed: false,
-        snapshot: true,
-        changes: Vec::new(),
-        added: 0,
-        removed: 0,
-        modified: 0,
-        truncated: false,
-    };
+    let mut out = Comparison { name: now.name.clone(), snapshot: true, ..empty(now, NodeId(0)) };
     let mut w = Walk { before, now, now_ids: now.ids().collect(), before_ids: before.ids().collect(), out: &mut out };
     for p in &now.pages {
         if before.contains(*p) {
diff --git a/crates/engine/src/devfocus_tests.rs b/crates/engine/src/devfocus_tests.rs
index 1607ce562..0801746de 100644
--- a/crates/engine/src/devfocus_tests.rs
+++ b/crates/engine/src/devfocus_tests.rs
@@ -99,8 +99,9 @@ fn nested_frames_stay_out_of_the_ready_list_and_its_navigation() {
     let mut s = Session::new();
     let screen = frame(&mut s, 0.0, "Screen");
     let card = idv(&ex(&mut s, "frame.create", json!({"parent": screen, "width": 100, "height": 50, "name": "Card"})));
-    // A status a nested frame already stores (an older file, or set through node.set) is ignored.
-    ex(&mut s, "node.set", json!({"id": card, "props": {"devStatus": "readyForDev"}}));
+    // node.set refuses a status on a nested frame, and one an older file already stores is ignored.
+    assert!(s.execute("node.set", &json!({"id": card, "props": {"devStatus": "readyForDev"}})).is_err());
+    s.doc_mut().unwrap().node_mut(card).unwrap().dev_status = DevStatus::ReadyForDev;
     assert_eq!(ex(&mut s, "inspect.readyForDev", json!({"status": "any"}))["items"], json!([]));
     assert!(s.execute("dev.focus", &json!({"direction": "next"})).is_err(), "nothing is ready");
     ex(&mut s, "node.set", json!({"id": screen, "props": {"devStatus": "readyForDev"}}));
diff --git a/crates/engine/src/devinspect.rs b/crates/engine/src/devinspect.rs
index fe4009891..16f4bbdc0 100644
--- a/crates/engine/src/devinspect.rs
+++ b/crates/engine/src/devinspect.rs
@@ -214,6 +214,21 @@ pub struct DevItem {
     pub name: String,
     pub page: NodeId,
     pub status: DevStatus,
+    /// Ready for dev and changed since it was marked.
+    pub changed: bool,
+}
+
+/// Whether Dev Mode runs command `id` from the menus and shortcuts: commands that don't edit the
+/// document, and Dev Mode's own edits (annotations, statuses, dev resources, code connections,
+/// comments). Choosing a tool other than moving around and commenting is refused too, and so is
+/// Revert to saved, which isn't an undo step but throws the design's unsaved edits away.
+pub fn dev_mode_allows(id: &str) -> bool {
+    const OWN: [&str; 5] = ["annotation.", "dev.", "devResource.", "codeConnect.", "comment."];
+    match id.strip_prefix("tool.") {
+        Some(t) => matches!(t, "move" | "hand" | "comment"),
+        None if id == "file.revert" => false,
+        None => OWN.iter().any(|p| id.starts_with(p)) || crate::cmd::find_command(id).is_none_or(|c| !c.history),
+    }
 }
 
 /// Most items listed.
@@ -244,7 +259,8 @@ pub fn dev_items(doc: &Document, status: Option<DevStatus>, page: Option<NodeId>
             }
             let Some(n) = doc.node(id) else { continue };
             if !n.dev_status.is_none() && status.is_none_or(|s| s == n.dev_status) && has_status(doc, id) {
-                out.push(DevItem { id, name: n.name.clone(), page: pg, status: n.dev_status });
+                let changed = n.dev_status == DevStatus::ReadyForDev && n.dev_changed;
+                out.push(DevItem { id, name: n.name.clone(), page: pg, status: n.dev_status, changed });
             }
             stack.extend(n.children.iter().rev().copied());
         }
@@ -257,18 +273,21 @@ pub fn specs() -> Vec<CommandSpec> {
         spec!(
             "inspect.readyForDev",
             "Ready for dev",
-            "{status?: readyForDev|completed|any (default readyForDev), page? (page id; default every page)} → {items: [{id, name, page, status}]}  frames and sections by handoff status (set it with `node.set {devStatus}`)",
+            "{status?: readyForDev|changed|completed|any (default readyForDev; changed: ready for dev and changed since marked), page? (page id; default every page)} → {items: [{id, name, page, status, changed}]}  frames and sections by handoff status (set it with `node.set {devStatus}`)",
             false,
             |s, p| {
                 let cmd = "inspect.readyForDev";
-                let status = match string(p, "status").as_deref() {
+                let wanted = string(p, "status");
+                let changed_only = wanted.as_deref().is_some_and(|v| v.eq_ignore_ascii_case("changed"));
+                let status = match wanted.as_deref() {
                     None => Some(DevStatus::ReadyForDev),
+                    _ if changed_only => Some(DevStatus::ReadyForDev),
                     Some(v) if v.eq_ignore_ascii_case("any") || v.eq_ignore_ascii_case("all") => None,
                     Some(v) => Some(
                         DevStatus::ALL
                             .into_iter()
                             .find(|d| !d.is_none() && d.id().eq_ignore_ascii_case(v))
-                            .ok_or_else(|| crate::bad(cmd, "status: readyForDev|completed|any"))?,
+                            .ok_or_else(|| crate::bad(cmd, "status: readyForDev|changed|completed|any"))?,
                     ),
                 };
                 let doc = s.doc()?;
@@ -276,7 +295,9 @@ pub fn specs() -> Vec<CommandSpec> {
                     Some(v) => Some(id_of(v).filter(|pg| doc.pages.contains(pg)).ok_or_else(|| crate::bad(cmd, "page: a page id"))?),
                     None => None,
                 };
-                Ok(json!({"items": serde_json::to_value(dev_items(doc, status, page)).unwrap_or(Value::Null)}))
+                let mut items = dev_items(doc, status, page);
+                items.retain(|i| i.changed || !changed_only);
+                Ok(json!({"items": serde_json::to_value(items).unwrap_or(Value::Null)}))
             }
         ),
         spec!(
diff --git a/crates/engine/src/devinspect_tests.rs b/crates/engine/src/devinspect_tests.rs
index be25e02c0..5ee590cc7 100644
--- a/crates/engine/src/devinspect_tests.rs
+++ b/crates/engine/src/devinspect_tests.rs
@@ -79,7 +79,7 @@ fn redlines_measure_on_hover_without_alt() {
         s.tool.overlay.guides.len()
     };
     assert_eq!(hover(&mut s), 0, "plain hover doesn't measure");
-    s.tool.redlines = true;
+    s.tool.dev_mode = true;
     assert!(hover(&mut s) > 0, "Inspect measures on hover");
 }
 
diff --git a/crates/engine/src/devmode_behaviour_tests.rs b/crates/engine/src/devmode_behaviour_tests.rs
new file mode 100644
index 000000000..3d85fdb11
--- /dev/null
+++ b/crates/engine/src/devmode_behaviour_tests.rs
@@ -0,0 +1,224 @@
+//! Dev Mode behaviour suite, written from the public documentation of handoff tools (in our own
+//! words): the canvas inspects and never edits, what the menus and shortcuts may run there, the
+//! list of what's ready for development, statuses (ready, changed, completed) and the focus view.
+
+use crate::Session;
+use crate::components::tests::{ex, idv};
+use crate::devinspect::dev_mode_allows;
+use crate::tools::{PointerEvent, PointerKind, ToolId};
+use figcraft_doc::{DevStatus, NodeId};
+use serde_json::{Value, json};
+
+fn ev(kind: PointerKind, x: f64, y: f64) -> PointerEvent {
+    PointerEvent::at(kind, x, y, 1.0)
+}
+
+fn drag(s: &mut Session, from: (f64, f64), to: (f64, f64)) {
+    s.pointer(&ev(PointerKind::Down, from.0, from.1)).unwrap();
+    for k in 1..=4 {
+        let t = f64::from(k) / 4.0;
+        s.pointer(&ev(PointerKind::Move, from.0 + (to.0 - from.0) * t, from.1 + (to.1 - from.1) * t)).unwrap();
+    }
+    s.pointer(&ev(PointerKind::Up, to.0, to.1)).unwrap();
+}
+
+fn frame(s: &mut Session, x: f64, name: &str) -> NodeId {
+    idv(&ex(s, "frame.create", json!({"x": x, "y": 0, "width": 200, "height": 200, "name": name})))
+}
+
+fn rect(s: &mut Session, parent: NodeId, x: f64) -> NodeId {
+    idv(&ex(s, "shape.rectangle", json!({"x": x, "y": 20, "width": 40, "height": 40, "parent": parent})))
+}
+
+fn names(v: &Value) -> Vec<String> {
+    v["items"].as_array().map(|a| a.iter().filter_map(|i| i["name"].as_str().map(String::from)).collect()).unwrap_or_default()
+}
+
+fn status(s: &mut Session, ids: &[NodeId], st: &str) {
+    ex(s, "node.set", json!({"ids": ids, "props": {"devStatus": st}}));
+}
+
+#[test]
+fn the_dev_mode_canvas_selects_and_pans_but_never_edits() {
+    let mut s = Session::new();
+    let f = frame(&mut s, 0.0, "Screen");
+    let r = rect(&mut s, f, 20.0);
+    let t = idv(&ex(&mut s, "text.create", json!({"text": "Hello", "x": 100, "y": 120, "parent": f})));
+    s.tool.dev_mode = true;
+    let before = s.doc().unwrap().clone();
+    let steps = s.undo_labels(100).len();
+    // A press selects; dragging it moves nothing.
+    drag(&mut s, (40.0, 40.0), (140.0, 90.0));
+    assert_eq!(s.selection(), vec![r]);
+    // Nor do its resize handles.
+    drag(&mut s, (60.0, 60.0), (120.0, 120.0));
+    // Drawing tools only select there.
+    for tool in [ToolId::Rectangle, ToolId::Frame, ToolId::Text, ToolId::Pen, ToolId::Pencil, ToolId::Scale] {
+        s.set_tool(tool);
+        drag(&mut s, (300.0, 300.0), (360.0, 360.0));
+    }
+    s.set_tool(ToolId::Move);
+    // A double-click on text doesn't start typing; on a frame's layer it selects into it.
+    ex(&mut s, "select.set", json!({"ids": [t]}));
+    s.pointer(&ev(PointerKind::DoubleClick, 110.0, 128.0)).unwrap();
+    assert!(s.ds().unwrap().text_edit.is_none(), "no text editing");
+    ex(&mut s, "select.set", json!({"ids": [r]}));
+    s.pointer(&ev(PointerKind::DoubleClick, 40.0, 40.0)).unwrap();
+    assert!(s.ds().unwrap().vector_edit.is_none(), "no vector editing");
+    assert!(*s.doc().unwrap() == before, "the design is untouched");
+    assert_eq!(s.undo_labels(100).len(), steps, "nothing to undo");
+    // Keys that edit with a tool (a selected guide's Delete) go to the commands instead.
+    assert!(!s.tool_key("Delete", false, false, false).unwrap());
+    // The hand still pans; comments still start.
+    s.set_tool(ToolId::Hand);
+    let cx = s.ds().unwrap().view.cx;
+    s.pointer(&ev(PointerKind::Down, 500.0, 500.0)).unwrap();
+    s.pointer(&PointerEvent { sx: 550.0, ..ev(PointerKind::Move, 500.0, 500.0) }).unwrap();
+    s.pointer(&ev(PointerKind::Up, 500.0, 500.0)).unwrap();
+    assert_ne!(s.ds().unwrap().view.cx, cx, "panned");
+    s.set_tool(ToolId::Comment);
+    s.pointer(&ev(PointerKind::Down, 500.0, 500.0)).unwrap();
+    assert!(s.ui_requests.iter().any(|u| u.kind == "comment.new"));
+    // Back in the design: the same drag moves.
+    s.tool.dev_mode = false;
+    s.set_tool(ToolId::Move);
+    drag(&mut s, (40.0, 40.0), (140.0, 90.0));
+    assert!(s.doc().unwrap().node(r).is_some_and(|n| n.transform.as_coeffs()[4] > 100.0), "moved");
+}
+
+#[test]
+fn dev_mode_runs_its_own_edits_and_refuses_design_edits_from_menus_and_shortcuts() {
+    for id in [
+        "annotation.add",
+        "annotation.edit",
+        "dev.resolveChange",
+        "dev.focus",
+        "devResource.add",
+        "codeConnect.set",
+        "comment.add",
+        "edit.undo",
+        "edit.redo",
+        "edit.copy",
+        "edit.copyAsCss",
+        "select.all",
+        "view.zoomIn",
+        "view.devMode",
+        "file.export",
+        "file.save",
+        "tool.move",
+        "tool.hand",
+        "tool.comment",
+        "inspect.code",
+    ] {
+        assert!(dev_mode_allows(id), "{id} runs in Dev Mode");
+    }
+    for id in [
+        "edit.delete",
+        "edit.paste",
+        "edit.cut",
+        "edit.duplicate",
+        "transform.nudge",
+        "object.group",
+        "tool.rectangle",
+        "tool.text",
+        "tool.place",
+        "file.import",
+        "file.revert",
+    ] {
+        assert!(!dev_mode_allows(id), "{id} edits the design");
+    }
+}
+
+#[test]
+fn the_ready_list_shows_frames_and_sections_with_a_status_across_pages() {
+    let mut s = Session::new();
+    let a = frame(&mut s, 0.0, "Login");
+    let b = frame(&mut s, 300.0, "Signup");
+    let nested = idv(&ex(&mut s, "frame.create", json!({"x": 10, "y": 10, "width": 50, "height": 50, "parent": a, "name": "Card"})));
+    status(&mut s, &[a], "readyForDev");
+    status(&mut s, &[b], "completed");
+    // A layer inside a frame takes no status of its own (its frame's covers it).
+    assert!(s.execute("node.set", &json!({"id": nested, "props": {"devStatus": "readyForDev"}})).is_err());
+    assert!(s.execute("node.set", &json!({"ids": [a, nested], "props": {"devStatus": "completed"}})).is_err(), "all or nothing");
+    assert_eq!(s.doc().unwrap().node(a).map(|n| n.dev_status), Some(DevStatus::ReadyForDev));
+    // Clearing one is always fine.
+    ex(&mut s, "node.set", json!({"id": nested, "props": {"devStatus": null}}));
+    let pg2 = idv(&ex(&mut s, "page.add", json!({"name": "Settings"})));
+    ex(&mut s, "page.select", json!({"id": pg2}));
+    let c = frame(&mut s, 0.0, "Profile");
+    status(&mut s, &[c], "readyForDev");
+    assert_eq!(names(&ex(&mut s, "inspect.readyForDev", json!({}))), vec!["Login", "Profile"]);
+    assert_eq!(names(&ex(&mut s, "inspect.readyForDev", json!({"status": "completed"}))), vec!["Signup"]);
+    assert_eq!(names(&ex(&mut s, "inspect.readyForDev", json!({"status": "any"}))), vec!["Login", "Signup", "Profile"]);
+    // Statuses are undoable.
+    s.undo().unwrap();
+    assert_eq!(names(&ex(&mut s, "inspect.readyForDev", json!({}))), vec!["Login"]);
+}
+
+#[test]
+fn ready_frames_edited_after_marking_show_as_changed_until_resolved_or_completed() {
+    let mut s = Session::new();
+    let a = frame(&mut s, 0.0, "Login");
+    let b = frame(&mut s, 300.0, "Signup");
+    let r = rect(&mut s, a, 20.0);
+    let outside = idv(&ex(&mut s, "shape.rectangle", json!({"x": 900, "y": 0, "width": 10, "height": 10})));
+    status(&mut s, &[a, b], "readyForDev");
+    let changed = |s: &mut Session| names(&ex(s, "inspect.readyForDev", json!({"status": "changed"})));
+    assert!(changed(&mut s).is_empty(), "marking isn't a change");
+    // Edits elsewhere don't count; an edit inside does.
+    ex(&mut s, "node.set", json!({"id": outside, "props": {"width": 30}}));
+    assert!(changed(&mut s).is_empty());
+    ex(&mut s, "node.set", json!({"id": r, "props": {"width": 60}}));
+    assert_eq!(changed(&mut s), vec!["Login"]);
+    let items = ex(&mut s, "inspect.readyForDev", json!({}));
+    assert_eq!(items["items"][0]["changed"], true, "the list says which changed: {items}");
+    assert_eq!(items["items"][1]["changed"], false);
+    // Still ready for dev (the status itself stays).
+    assert_eq!(names(&items), vec!["Login", "Signup"]);
+    // Resolving goes back to plain ready; so does marking it again, or completing it.
+    ex(&mut s, "dev.resolveChange", json!({"ids": [a]}));
+    assert!(changed(&mut s).is_empty());
+    ex(&mut s, "node.set", json!({"id": r, "props": {"width": 70}}));
+    status(&mut s, &[a], "completed");
+    assert!(changed(&mut s).is_empty());
+    let all = ex(&mut s, "inspect.readyForDev", json!({"status": "any"}));
+    assert_eq!(all["items"][0]["changed"], false, "a completed frame isn't changed: {all}");
+    // Completed frames don't turn changed when edited.
+    ex(&mut s, "node.set", json!({"id": r, "props": {"width": 80}}));
+    assert!(!s.doc().unwrap().node(a).unwrap().dev_changed);
+}
+
+#[test]
+fn the_focus_view_steps_through_what_is_ready_and_skips_completed_frames() {
+    let mut s = Session::new();
+    let a = frame(&mut s, 0.0, "Login");
+    let b = frame(&mut s, 300.0, "Signup");
+    let c = frame(&mut s, 600.0, "Profile");
+    let r = rect(&mut s, c, 620.0);
+    status(&mut s, &[a, c], "readyForDev");
+    status(&mut s, &[b], "completed");
+    ex(&mut s, "node.set", json!({"id": r, "props": {"width": 60}}));
+    let step = |s: &mut Session, d: &str| ex(s, "dev.focus", json!({"direction": d}));
+    let v = ex(&mut s, "dev.focus", json!({"id": a}));
+    assert_eq!((v["index"].clone(), v["count"].clone()), (json!(0), json!(2)));
+    assert_eq!(step(&mut s, "next")["id"], json!(c), "completed ones are skipped, changed ones aren't");
+    assert_eq!(step(&mut s, "previous")["id"], json!(a));
+    // Any top-level frame opens in it, even one that's completed.
+    assert_eq!(ex(&mut s, "dev.focus", json!({"id": b}))["index"], json!(null));
+}
+
+#[test]
+fn a_drag_under_way_when_dev_mode_starts_moves_nothing() {
+    let mut s = Session::new();
+    let f = frame(&mut s, 0.0, "Screen");
+    let r = rect(&mut s, f, 20.0);
+    ex(&mut s, "select.set", json!({"ids": [r]}));
+    let before = s.doc().unwrap().world_bounds(r);
+    s.pointer(&ev(PointerKind::Down, 40.0, 40.0)).unwrap();
+    s.pointer(&ev(PointerKind::Move, 90.0, 40.0)).unwrap();
+    s.drop_gesture().unwrap();
+    s.tool.dev_mode = true;
+    s.pointer(&ev(PointerKind::Move, 120.0, 40.0)).unwrap();
+    s.pointer(&ev(PointerKind::Up, 120.0, 40.0)).unwrap();
+    assert_eq!(s.doc().unwrap().world_bounds(r), before, "the drag was dropped, not committed");
+}
diff --git a/crates/engine/src/devmode_tail_tests.rs b/crates/engine/src/devmode_tail_tests.rs
new file mode 100644
index 000000000..b8f1b0196
--- /dev/null
+++ b/crates/engine/src/devmode_tail_tests.rs
@@ -0,0 +1,163 @@
+//! Dev Mode, the tail: import lines for the connected components a layer tree calls.
+
+use crate::Session;
+use crate::components::tests::{ex, idv};
+use figcraft_doc::NodeId;
+use serde_json::json;
+
+fn code(s: &mut Session, id: NodeId, lang: &str) -> String {
+    ex(s, "inspect.code", json!({"id": id, "language": lang}))["code"].as_str().unwrap_or_default().to_string()
+}
+
+/// A component named `name` (an empty frame) at `x`.
+fn component(s: &mut Session, name: &str, x: f64) -> NodeId {
+    let f = idv(&ex(s, "frame.create", json!({"x": x, "y": 1000, "width": 40, "height": 20, "name": name})));
+    idv(&ex(s, "component.create", json!({"ids": [f]})))
+}
+
+fn instance(s: &mut Session, c: NodeId, parent: NodeId) -> NodeId {
+    idv(&ex(s, "instance.create", json!({"component": c, "x": 0, "y": 0, "parent": parent})))
+}
+
+fn frame(s: &mut Session, name: &str, parent: Option<NodeId>) -> NodeId {
+    idv(&ex(s, "frame.create", json!({"x": 0, "y": 0, "width": 400, "height": 300, "name": name, "parent": parent})))
+}
+
+fn count(code: &str, line: &str) -> usize {
+    code.lines().filter(|l| *l == line).count()
+}
+
+#[test]
+fn layer_trees_import_the_connected_components_they_call_once_at_the_top() {
+    let mut s = Session::new();
+    let badge = component(&mut s, "Badge", 0.0);
+    let button = component(&mut s, "Button", 100.0);
+    let toast = component(&mut s, "Toast", 200.0);
+    let divider = component(&mut s, "Divider", 300.0);
+    for (lang, path) in [("react", "@acme/ui"), ("swiftui", "AcmeUI"), ("leptos", "crate::ui"), ("compose", "com.acme.ui.Badge")] {
+        ex(&mut s, "codeConnect.set", json!({"id": badge, "language": lang, "importPath": path}));
+    }
+    ex(&mut s, "codeConnect.set", json!({"id": button, "importPath": "@acme/buttons"}));
+    ex(&mut s, "codeConnect.set", json!({"id": toast, "importPath": "@acme/toast"}));
+    let screen = frame(&mut s, "Screen", None);
+    let row = frame(&mut s, "Row", Some(screen));
+    for (c, parent) in [(badge, screen), (button, screen), (badge, screen), (divider, screen), (badge, row)] {
+        instance(&mut s, c, parent);
+    }
+    let hidden = instance(&mut s, toast, row);
+    ex(&mut s, "node.set", json!({"id": hidden, "props": {"visible": false}}));
+
+    let react = code(&mut s, screen, "react");
+    assert!(react.starts_with("import { Badge } from \"@acme/ui\";\nimport { Button } from \"@acme/buttons\";\nimport \"./"), "{react}");
+    assert_eq!(count(&react, "import { Badge } from \"@acme/ui\";"), 1, "once each: {react}");
+    assert!(!react.contains("@acme/toast"), "hidden layers aren't in the code: {react}");
+    let swift = code(&mut s, screen, "swiftui");
+    assert!(swift.starts_with("import AcmeUI\n\n") && count(&swift, "import AcmeUI") == 1, "per language: {swift}");
+    assert!(!swift.contains("acme/buttons"), "{swift}");
+    let leptos = code(&mut s, screen, "leptos");
+    assert!(leptos.starts_with("use crate::ui::Badge;\nuse leptos::prelude::*;\n"), "joined to the code's own imports: {leptos}");
+    assert!(code(&mut s, screen, "compose").starts_with("import com.acme.ui.Badge\n\n"));
+    assert!(!code(&mut s, screen, "css").contains("import"), "CSS has no imports");
+    // The Inspect panel shows inspect.code's text (the same function).
+    let doc = s.doc().unwrap();
+    assert_eq!(crate::codegen::code_for(doc, screen, crate::codegen::CodeLang::React), react);
+
+    // A connected layer itself: its import and snippet, unchanged.
+    assert_eq!(code(&mut s, badge, "react"), "import { Badge } from \"@acme/ui\";\n\n<Badge />\n");
+
+    // A component's definition, and an instance of it (its call, then the definition).
+    let card_frame = frame(&mut s, "Card", None);
+    instance(&mut s, badge, card_frame);
+    let card = idv(&ex(&mut s, "component.create", json!({"ids": [card_frame]})));
+    assert!(
+        code(&mut s, card, "react").starts_with("import { Badge } from \"@acme/ui\";\nimport \"./card.css\";"),
+        "{}",
+        code(&mut s, card, "react")
+    );
+    let page = frame(&mut s, "Page", None);
+    let card_i = instance(&mut s, card, page);
+    assert!(code(&mut s, card_i, "react").starts_with("import { Badge } from \"@acme/ui\";\n\n<Card />"), "{}", code(&mut s, card_i, "react"));
+    assert!(code(&mut s, page, "react").starts_with("import \"./"), "an unconnected call's insides aren't in the code");
+}
+
+#[test]
+fn slots_and_instance_swaps_bring_their_connected_imports() {
+    let mut s = Session::new();
+    let badge = component(&mut s, "Badge", 0.0);
+    ex(&mut s, "codeConnect.set", json!({"id": badge, "importPath": "@acme/ui"}));
+    // A panel whose slot an instance fills with a badge.
+    let f = frame(&mut s, "Panel", None);
+    let content = frame(&mut s, "Content", Some(f));
+    let panel = idv(&ex(&mut s, "component.create", json!({"ids": [f]})));
+    ex(&mut s, "component.makeSlot", json!({"id": content}));
+    let screen = frame(&mut s, "Screen", None);
+    let p = instance(&mut s, panel, screen);
+    assert!(!code(&mut s, screen, "react").contains("@acme/ui"), "an empty slot");
+    ex(&mut s, "instance.slotInsert", json!({"id": p, "slot": "Content", "component": badge, "replace": true}));
+    assert!(code(&mut s, screen, "react").starts_with("import { Badge } from \"@acme/ui\";\n"), "{}", code(&mut s, screen, "react"));
+    assert!(code(&mut s, p, "react").starts_with("import { Badge } from \"@acme/ui\";\n\n<Panel content={("), "{}", code(&mut s, p, "react"));
+
+    // A connected chip whose template places its icon: the swapped-in connected component's import.
+    let heart = component(&mut s, "Heart", 300.0);
+    let chip_frame = frame(&mut s, "Chip", None);
+    let nested = instance(&mut s, heart, chip_frame);
+    let chip = idv(&ex(&mut s, "component.create", json!({"ids": [chip_frame]})));
+    ex(&mut s, "component.addProperty", json!({"id": chip, "name": "Icon", "type": "instanceSwap", "default": heart, "layer": nested}));
+    ex(&mut s, "codeConnect.set", json!({"id": chip, "importPath": "@acme/chip", "template": "<Chip icon={Icon} />"}));
+    let c = instance(&mut s, chip, screen);
+    ex(&mut s, "instance.setProperties", json!({"ids": [c], "properties": {"Icon": badge}}));
+    assert_eq!(code(&mut s, c, "react"), "import { Chip } from \"@acme/chip\";\nimport { Badge } from \"@acme/ui\";\n\n<Chip icon={<Badge />} />\n");
+    let tree = code(&mut s, screen, "react");
+    assert!(tree.starts_with("import { Badge } from \"@acme/ui\";\nimport { Chip } from \"@acme/chip\";\nimport \"./"), "{tree}");
+    // An unconnected swap target brings nothing; the default (Heart) isn't connected.
+    ex(&mut s, "instance.setProperties", json!({"ids": [c], "properties": {"Icon": heart}}));
+    assert_eq!(code(&mut s, c, "react"), "import { Chip } from \"@acme/chip\";\n\n<Chip icon={<Heart />} />\n");
+}
+
+#[test]
+fn compare_changes_takes_any_saved_version_as_the_before() {
+    let mut s = Session::new();
+    let screen = frame(&mut s, "Screen", None);
+    let button =
+        idv(&ex(&mut s, "shape.rectangle", json!({"x": 20, "y": 20, "width": 120, "height": 40, "parent": screen, "props": {"name": "Button"}})));
+    let old = idv(&ex(&mut s, "shape.ellipse", json!({"x": 200, "y": 20, "width": 20, "height": 20, "parent": screen, "props": {"name": "Dot"}})));
+    let v1 = ex(&mut s, "file.saveVersion", json!({"name": "Kickoff"}))["id"].as_str().unwrap().to_string();
+    ex(&mut s, "node.set", json!({"id": button, "props": {"width": 136}}));
+    ex(&mut s, "edit.delete", json!({"ids": [old]}));
+    let added = idv(&ex(&mut s, "text.create", json!({"text": "Hi", "x": 20, "y": 100, "parent": screen, "props": {"name": "Note"}})));
+    let v2 = ex(&mut s, "file.saveVersion", json!({"name": "Review"}))["id"].as_str().unwrap().to_string();
+    ex(&mut s, "node.set", json!({"id": button, "props": {"width": 150}}));
+
+    // Any frame, ready for dev or not.
+    let c = ex(&mut s, "dev.compare", json!({"id": screen, "version": v1}));
+    assert_eq!(c["version"]["name"], "Kickoff");
+    assert_eq!(
+        (c["changed"].as_bool(), c["added"].as_u64(), c["removed"].as_u64(), c["modified"].as_u64()),
+        (Some(true), Some(1), Some(1), Some(1)),
+        "{c}"
+    );
+    let change =
+        |c: &serde_json::Value, id: NodeId| c["changes"].as_array().unwrap().iter().find(|l| l["id"] == json!(id)).cloned().unwrap_or_default();
+    assert_eq!(change(&c, button)["properties"][0]["text"], "width 120 → 150");
+    assert_eq!(change(&c, old)["change"], "removed");
+    assert_eq!(change(&c, added)["change"], "added");
+    // A later version: only what changed since then.
+    let c = ex(&mut s, "dev.compare", json!({"id": screen, "version": v2}));
+    assert_eq!(c["changes"].as_array().map(Vec::len), Some(1), "{c}");
+    assert_eq!(change(&c, button)["properties"][0]["text"], "width 136 → 150");
+    // A frame the version doesn't have was added as a whole.
+    let fresh = frame(&mut s, "Settings", None);
+    let c = ex(&mut s, "dev.compare", json!({"id": fresh, "version": v1}));
+    assert_eq!(c["changes"][0]["change"], "added");
+    // The snapshot from when it was marked stays the default, for ready-for-dev layers only.
+    assert!(s.execute("dev.compare", &json!({"id": screen})).is_err(), "not ready for dev");
+    ex(&mut s, "node.set", json!({"id": screen, "props": {"devStatus": "readyForDev"}}));
+    let c = ex(&mut s, "dev.compare", json!({"id": screen}));
+    assert_eq!((c["changed"].as_bool(), c["version"].is_null()), (Some(false), true), "{c}");
+    for bad in [json!({"id": screen, "version": "nope"}), json!({"id": screen, "version": 5}), json!({"id": button, "version": v1})] {
+        assert!(s.execute("dev.compare", &bad).is_err(), "{bad}");
+    }
+    // The app opens on the version asked for.
+    ex(&mut s, "dev.compare", json!({"id": screen, "version": v2, "show": true}));
+    assert!(s.ui_requests.iter().any(|u| u.kind == "view.devCompare" && u.data["version"] == json!(v2)));
+}
diff --git a/crates/engine/src/doc_urls.rs b/crates/engine/src/doc_urls.rs
new file mode 100644
index 000000000..3b8417cd2
--- /dev/null
+++ b/crates/engine/src/doc_urls.rs
@@ -0,0 +1,48 @@
+//! Which URLs stored in a document may be handed to the browser or the system opener.
+//!
+//! A document can carry URLs that the app opens for whoever views it: a prototype's Open link
+//! action ([`crate::proto_run`]) and Dev Mode's dev resources ([`crate::dev_resources`]). Both end
+//! up at the platform's opener, so a document that someone else made chooses what that opener is
+//! asked to do. Only the schemes a browser would follow on a plain link are allowed:
+//!
+//! - `javascript:` runs script. In the web build the opener is `window.open`, which executes it in
+//!   the app's own origin, so a saved document becomes stored XSS.
+//! - `file:` and `smb:` reach the file system; on Windows a UNC host also sends credentials.
+//! - Windows hands `ms-…:` schemes to application handlers, and macOS and Linux hand unknown
+//!   schemes to whichever application registered them.
+//!
+//! The check is lexical and does no I/O. It is deliberately an allow-list: a deny-list of known
+//! dangerous schemes is outgrown by every new handler a platform adds.
+
+/// The schemes a URL stored in a document may use.
+const WEB_SCHEMES: [&str; 3] = ["http", "https", "mailto"];
+
+/// Whether `url`, stored in a document, may be opened.
+///
+/// Requires a scheme from [`WEB_SCHEMES`], compared ignoring ASCII case. A URL with no scheme is
+/// refused: the opener would resolve it against the app's own page on the web. Control characters
+/// are refused anywhere, because browsers ignore some of them inside a scheme (`java\tscript:`
+/// reaches a `javascript:` handler), and `http`/`https` must name a host.
+pub fn openable(url: &str) -> bool {
+    let url = url.trim();
+    if url.is_empty() || url.chars().any(char::is_control) {
+        return false;
+    }
+    let Some((scheme, rest)) = url.split_once(':') else { return false };
+    // An RFC 3986 scheme, so a stray colon in text cannot look like one.
+    let mut chars = scheme.chars();
+    if !chars.next().is_some_and(|c| c.is_ascii_alphabetic()) || !chars.all(|c| c.is_ascii_alphanumeric() || matches!(c, '+' | '-' | '.')) {
+        return false;
+    }
+    if !WEB_SCHEMES.iter().any(|s| scheme.eq_ignore_ascii_case(s)) {
+        return false;
+    }
+    if scheme.eq_ignore_ascii_case("mailto") {
+        // `mailto:` names an address.
+        return !rest.is_empty();
+    }
+    // `http` and `https` name a host, so the authority is required: `http:x` is not a web link,
+    // and `http:///p` has no host.
+    let Some(after) = rest.strip_prefix("//") else { return false };
+    !after.is_empty() && !after.starts_with('/')
+}
diff --git a/crates/engine/src/doc_urls_tests.rs b/crates/engine/src/doc_urls_tests.rs
new file mode 100644
index 000000000..d42029a0f
--- /dev/null
+++ b/crates/engine/src/doc_urls_tests.rs
@@ -0,0 +1,87 @@
+//! A URL stored in a document reaches the browser or the system opener, so only the schemes a
+//! browser follows on a plain link are allowed ([`crate::doc_urls`]).
+
+use crate::doc_urls::openable;
+
+#[test]
+fn web_links_are_opened() {
+    for url in [
+        "http://example.com",
+        "https://example.com",
+        "https://example.com/a/b?c=d#e",
+        "HTTPS://EXAMPLE.COM",
+        "HtTp://example.com",
+        "mailto:a@b.c",
+        "mailto:a@b.c?subject=hi",
+        "  https://example.com  ",
+        "https://user:pw@example.com:8443/p",
+    ] {
+        assert!(openable(url), "{url:?} should open");
+    }
+}
+
+#[test]
+fn script_and_handler_schemes_are_refused() {
+    for url in [
+        // Runs in the app's own origin on the web build: a saved document would be stored XSS.
+        "javascript:alert(1)",
+        "JavaScript:alert(1)",
+        "jAvAsCrIpT:alert(document.cookie)",
+        "vbscript:msgbox(1)",
+        "data:text/html,<script>alert(1)</script>",
+        "blob:https://example.com/x",
+        // Reach the file system; a UNC host also sends Windows credentials.
+        "file:///etc/passwd",
+        "file://attacker.example/share/x",
+        "smb://attacker.example/share/x",
+        "webdav://attacker.example/x",
+        // Windows application handlers.
+        "ms-msdt:/id PCWDiagnostic",
+        "ms-officecmd:x",
+        "search-ms:query=x",
+        "shell:startup",
+        // Anything else a platform may have registered.
+        "tel:+1234",
+        "sms:+1234",
+        "ssh://host",
+        "ftp://host/x",
+        "figcraft://join?host=127.0.0.1",
+        "zoommtg://zoom.us/join?x",
+        "view-source:https://example.com",
+        "jar:https://example.com/x!/y",
+    ] {
+        assert!(!openable(url), "{url:?} must be refused");
+    }
+}
+
+#[test]
+fn a_scheme_is_required_and_control_characters_are_refused() {
+    for url in [
+        // No scheme: the web opener would resolve these against the app's own page.
+        "",
+        "   ",
+        "example.com",
+        "/etc/passwd",
+        "//example.com",
+        "\\\\host\\share\\x",
+        "about",
+        // Browsers ignore some control characters inside a scheme, so a smuggled one must not
+        // leave `javascript` looking like an unknown scheme that we then refuse by luck.
+        "java\tscript:alert(1)",
+        "java\nscript:alert(1)",
+        "java\rscript:alert(1)",
+        "javascript\u{0}:alert(1)",
+        "https://example.com/\u{0}",
+        // A colon in ordinary text is not a scheme.
+        "see page 2: the diagram",
+        "1https://example.com",
+        // The allowed schemes still need their own part.
+        "mailto:",
+        "http:",
+        "http:example.com",
+        "http:///p",
+        "https://",
+    ] {
+        assert!(!openable(url), "{url:?} must be refused");
+    }
+}
diff --git a/crates/engine/src/duplicate_spacing_tests.rs b/crates/engine/src/duplicate_spacing_tests.rs
index b65fbb641..4c62179a7 100644
--- a/crates/engine/src/duplicate_spacing_tests.rs
+++ b/crates/engine/src/duplicate_spacing_tests.rs
@@ -157,3 +157,49 @@ fn an_alt_drag_into_auto_layout_sets_no_step() {
     cmd_d(&mut s);
     assert_eq!(s.doc().unwrap().node(f).unwrap().children.len(), n + 1, "Duplicate still adds one to the flow");
 }
+
+/// Drag `from` by `by` with no modifier: moving the selection, not copying it.
+fn drag_move(s: &mut Session, from: (f64, f64), by: (f64, f64)) {
+    let ev = |kind, (x, y): (f64, f64)| PointerEvent::at(kind, x, y, 1.0);
+    s.pointer(&ev(PointerKind::Down, from)).unwrap();
+    for k in 1..=4 {
+        let t = f64::from(k) / 4.0;
+        s.pointer(&ev(PointerKind::Move, (from.0 + by.0 * t, from.1 + by.1 * t))).unwrap();
+    }
+    s.pointer(&ev(PointerKind::Up, (from.0 + by.0, from.1 + by.1))).unwrap();
+}
+
+/// The reported path (#567): Cmd+D, drag the copy with the mouse, Cmd+D again. The other tests
+/// here set the copy's position with `node.set` or Alt-drag it; dragging is how it is usually done,
+/// and the step is measured from where the copy ended up, whichever way it got there.
+#[test]
+fn duplicate_repeats_the_step_set_by_dragging_the_copy() {
+    let mut s = Session::new();
+    let a = rect(&mut s, 0.0, 0.0);
+    ex(&mut s, "select.set", json!({"ids": [a]}));
+    let c1 = cmd_d(&mut s);
+    assert_eq!(at(&s, c1), (0.0, 0.0), "the first copy lands in place");
+
+    drag_move(&mut s, (50.0, 50.0), (150.0, 20.0));
+    assert_eq!(at(&s, c1), (150.0, 20.0), "the drag moved the copy, it did not make another one");
+    assert_eq!(s.selection(), vec![c1], "and left it selected");
+    assert_eq!(at(&s, a), (0.0, 0.0), "the original stays");
+
+    let c2 = cmd_d(&mut s);
+    assert_eq!(at(&s, c2), (300.0, 40.0), "the next one as far again");
+    let c3 = cmd_d(&mut s);
+    assert_eq!(at(&s, c3), (450.0, 60.0), "and again");
+}
+
+/// And a step set with the arrow keys, which is how a small offset is usually made exact.
+#[test]
+fn duplicate_repeats_a_nudged_step() {
+    let mut s = Session::new();
+    let a = rect(&mut s, 0.0, 0.0);
+    ex(&mut s, "select.set", json!({"ids": [a]}));
+    let c1 = cmd_d(&mut s);
+    ex(&mut s, "transform.nudge", json!({"dx": 40, "dy": 0}));
+    assert_eq!(at(&s, c1), (40.0, 0.0));
+    let c2 = cmd_d(&mut s);
+    assert_eq!(at(&s, c2), (80.0, 0.0), "the nudge is the step");
+}
diff --git a/crates/engine/src/effects_tests.rs b/crates/engine/src/effects_tests.rs
index be69fac20..607b77114 100644
--- a/crates/engine/src/effects_tests.rs
+++ b/crates/engine/src/effects_tests.rs
@@ -51,6 +51,32 @@ fn effect_set_edits_noise_texture_and_glass() {
     assert!(s.execute("effect.set", &json!({"ids": [r], "index": 0, "effect": {"type": "glass", "depth": "deep"}})).is_err());
 }
 
+/// A key an effect doesn't have is refused, naming what it takes: serde dropped it without a word,
+/// so a shadow given `offsetX`/`offsetY` (the names variable bindings use) kept the default offset.
+#[test]
+fn effects_refuse_keys_they_dont_have() {
+    let mut s = Session::new();
+    let r = rect(&mut s);
+    let shadow = json!({"type": "dropShadow", "color": "#00000040", "offsetX": 0, "offsetY": 1, "radius": 3});
+    let err = s.execute("node.set", &json!({"ids": [r], "props": {"effects": [shadow]}})).unwrap_err().to_string();
+    assert!(err.contains("effects[0]") && err.contains("offsetX, offsetY") && err.contains("offset"), "{err}");
+    assert!(s.doc().unwrap().node(r).unwrap().effects.is_empty(), "nothing stored");
+    let err = s.execute("effect.add", &json!({"ids": [r], "effect": {"type": "layerBlur", "radious": 8}})).unwrap_err().to_string();
+    assert!(err.contains("radious"), "{err}");
+    s.execute("effect.add", &json!({"ids": [r], "type": "dropShadow"})).unwrap();
+    let err = s.execute("effect.set", &json!({"ids": [r], "index": 0, "effect": {"type": "dropShadow", "spred": 2}})).unwrap_err().to_string();
+    assert!(err.contains("spred"), "{err}");
+    // Every kind's own keys still go in, camelCase or snake_case, and so does what inspect reports.
+    for ty in ["innerShadow", "layerBlur", "backgroundBlur", "noise", "texture", "glass"] {
+        s.execute("effect.add", &json!({"ids": [r], "type": ty})).unwrap();
+    }
+    let reported = crate::inspect::node_json(s.doc().unwrap(), r, 0)["effects"].clone();
+    s.execute("node.set", &json!({"ids": [r], "props": {"effects": reported}})).unwrap();
+    let camel = json!({"type": "dropShadow", "offset": [0, 1], "showBehind": true, "visible": true});
+    let snake = json!({"type": "innerShadow", "offset": [0, 1], "show_behind": false});
+    s.execute("node.set", &json!({"ids": [r], "props": {"effects": [camel, snake]}})).unwrap();
+}
+
 #[test]
 fn scaling_scales_grain_and_glass() {
     let mut s = Session::new();
diff --git a/crates/engine/src/fig_import_tests.rs b/crates/engine/src/fig_import_tests.rs
index d62414481..f0ea08866 100644
--- a/crates/engine/src/fig_import_tests.rs
+++ b/crates/engine/src/fig_import_tests.rs
@@ -50,3 +50,43 @@ fn local_samples_match_their_exports() {
         }
     }
 }
+
+/// Layers of an instance copy keep their link to the layer they stand for when the file is
+/// opened, also after they were renamed in the copy (a name is no identity), and the override
+/// that a rename is stays an override.
+#[test]
+fn opened_fig_links_instance_layers_by_identity_not_by_name() {
+    use base64::Engine as _;
+    let mut s = Session::new();
+    let make = |s: &mut Session, cmd: &str, p: serde_json::Value| s.execute(cmd, &p).unwrap()["id"].as_u64().map(figcraft_doc::NodeId).unwrap();
+    let body = make(&mut s, "frame.create", json!({"x": 0, "y": 0, "width": 40, "height": 20, "name": "Inner"}));
+    let label = make(&mut s, "text.create", json!({"text": "Label", "x": 2, "y": 2, "parent": body, "props": {"name": "Label"}}));
+    let inner = make(&mut s, "component.create", json!({"ids": [body]}));
+    let frame = make(&mut s, "frame.create", json!({"x": 100, "y": 0, "width": 200, "height": 60, "name": "Outer"}));
+    let outer = make(&mut s, "component.create", json!({"ids": [frame]}));
+    let slot = make(&mut s, "instance.create", json!({"component": inner, "x": 0, "y": 0, "parent": outer}));
+    s.execute("node.set", &json!({"id": slot, "props": {"name": "Slot"}})).unwrap();
+    let copy = make(&mut s, "instance.create", json!({"component": outer, "x": 0, "y": 200}));
+    let copy_slot = s.doc().unwrap().node(copy).unwrap().children[0];
+    let copy_label = s.doc().unwrap().node(copy_slot).unwrap().children[0];
+    s.execute("node.set", &json!({"id": copy_slot, "props": {"name": "Renamed slot"}})).unwrap();
+    s.execute("node.set", &json!({"id": copy_label, "props": {"name": "Renamed label"}})).unwrap();
+    let _ = label;
+
+    let exported = s.execute("file.export", &json!({"format": "fig"})).unwrap();
+    let path = std::env::temp_dir().join(format!("figcraft-slots-{}.fig", std::process::id()));
+    std::fs::write(&path, base64::engine::general_purpose::STANDARD.decode(exported["data"].as_str().unwrap()).unwrap()).unwrap();
+    let mut opened = Session::new();
+    let result = opened.execute("file.open", &json!({"path": path.to_string_lossy()}));
+    let _ = std::fs::remove_file(&path);
+    result.unwrap();
+    let doc = opened.doc().unwrap();
+    let outer = doc.nodes().find(|n| n.name == "Outer" && matches!(n.kind, NodeKind::Component { .. })).unwrap();
+    let copy = doc.nodes().find(|n| n.name == "Outer" && matches!(n.kind, NodeKind::Instance { .. })).unwrap();
+    let slot = doc.node(copy.children[0]).unwrap();
+    let label = doc.node(slot.children[0]).unwrap();
+    assert_eq!((slot.name.as_str(), label.name.as_str()), ("Renamed slot", "Renamed label"));
+    assert_eq!(slot.source, Some(outer.children[0]));
+    assert_eq!(label.source, Some(doc.node(outer.children[0]).unwrap().children[0]));
+    assert!(slot.overrides.contains("name") && label.overrides.contains("name"));
+}
diff --git a/crates/engine/src/file_access.rs b/crates/engine/src/file_access.rs
new file mode 100644
index 000000000..709b34a71
--- /dev/null
+++ b/crates/engine/src/file_access.rs
@@ -0,0 +1,305 @@
+//! Automation roots (#715): the folders the files an agent's commands read and write must lie in.
+//!
+//! `figcraft-cli mcp --automation-read-root DIR --automation-write-root DIR` and the desktop app
+//! started with the same flags run their work [`confined`] to [`Roots`]: while a scope is active on
+//! the thread, every file the engine reads must lie inside a read or a write root and every file it
+//! writes inside a write root; anything else is an ordinary error. The engine reaches the file
+//! system only through this module (`crates/engine/clippy.toml` denies `std::fs` and friends
+//! anywhere else), so every command, present or future, is covered. Without a scope nothing changes.
+//!
+//! A path is made absolute against the working directory and resolved before it is compared: its
+//! links are followed (`std::fs::canonicalize`), and for a file that doesn't exist yet its nearest
+//! existing folder is resolved and the rest must be plain names. The comparison is by whole
+//! components (`/work2` is not inside `/work`), and the I/O uses the resolved path, so what was
+//! checked is what is opened.
+#![allow(clippy::disallowed_methods)]
+
+use std::cell::RefCell;
+use std::ffi::{OsStr, OsString};
+use std::path::{Component, Path, PathBuf};
+use std::sync::Arc;
+
+use crate::{EngineError, Result};
+
+/// What a command does with a file.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Access {
+    Read,
+    Write,
+}
+
+/// The folders automation may read (read and write roots) and write (write roots), resolved.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Roots {
+    read: Vec<PathBuf>,
+    write: Vec<PathBuf>,
+}
+
+impl Roots {
+    /// Roots from the folders given (relative ones against the working directory). Each must be an
+    /// existing folder.
+    pub fn new(read: &[String], write: &[String]) -> std::result::Result<Self, String> {
+        let resolve = |flag: &str, dirs: &[String]| {
+            dirs.iter()
+                .map(|d| match std::fs::canonicalize(d) {
+                    Ok(p) if p.is_dir() => Ok(p),
+                    Ok(_) => Err(format!("{flag} {d}: not a folder")),
+                    Err(e) => Err(format!("{flag} {d}: {e}")),
+                })
+                .collect::<std::result::Result<Vec<_>, String>>()
+        };
+        Ok(Self { read: resolve("--automation-read-root", read)?, write: resolve("--automation-write-root", write)? })
+    }
+
+    /// The resolved path to use for `access` to `path`, or why it is refused.
+    pub fn check(&self, path: &Path, access: Access) -> std::result::Result<PathBuf, String> {
+        let asked = path.display();
+        let (roots, what) = match access {
+            Access::Read => ([self.read.as_slice(), self.write.as_slice()].concat(), "read"),
+            Access::Write => (self.write.clone(), "written"),
+        };
+        match resolve(path) {
+            Ok(resolved) if roots.iter().any(|r| resolved.starts_with(r)) => return Ok(resolved),
+            Ok(_) => {}
+            // Why a path can't be resolved says what exists there: only told for paths inside a root.
+            Err(why) if inside_as_far_as_it_exists(path, &roots) => return Err(format!("automation path rejected: {asked}: {why}")),
+            Err(_) => {}
+        }
+        if roots.is_empty() {
+            return Err(format!("automation path rejected: no folder may be {what} (no root for it was given): {asked}"));
+        }
+        let shown: Vec<String> = roots.iter().map(|r| shown(r)).collect();
+        Err(format!("automation path rejected: {asked} is outside the folders that may be {what}: {}", shown.join(", ")))
+    }
+
+    /// The folders as JSON, resolved: `{read: [every folder that may be read], write: [the write roots]}`.
+    pub fn to_json(&self) -> serde_json::Value {
+        let list = |v: &[PathBuf]| v.iter().map(|p| shown(p)).collect::<Vec<_>>();
+        serde_json::json!({"read": list(&[self.read.as_slice(), self.write.as_slice()].concat()), "write": list(&self.write)})
+    }
+}
+
+/// Whether `path` lies in one of `roots` once made absolute with its `.` and `..` taken by name and
+/// its longest leading part that exists resolved, so links on the way are followed as the roots'
+/// were (`/tmp/work/x` is inside root `/private/tmp/work`, a link out of a root leads out of it).
+fn inside_as_far_as_it_exists(path: &Path, roots: &[PathBuf]) -> bool {
+    let Ok(abs) = std::path::absolute(path) else { return false };
+    let mut lexical = PathBuf::new();
+    for c in abs.components() {
+        match c {
+            Component::ParentDir => {
+                lexical.pop();
+            }
+            Component::CurDir => {}
+            c => lexical.push(c),
+        }
+    }
+    let mut rest: Vec<&OsStr> = Vec::new();
+    let mut at = lexical.as_path();
+    let resolved = loop {
+        if let Ok(mut base) = std::fs::canonicalize(at) {
+            base.extend(rest.iter().rev());
+            break base;
+        }
+        let (Some(name), Some(parent)) = (at.file_name(), at.parent()) else { return false };
+        rest.push(name);
+        at = parent;
+    };
+    roots.iter().any(|r| resolved.starts_with(r))
+}
+
+/// Whether `path` lies in the app's own folder `folder`, both resolved (links and `..` followed);
+/// false when either can't be resolved.
+#[cfg_attr(target_arch = "wasm32", allow(dead_code))]
+pub(crate) fn within_app_folder(path: &Path, folder: &Path) -> bool {
+    matches!((std::fs::canonicalize(path), std::fs::canonicalize(folder)), (Ok(p), Ok(f)) if p.starts_with(&f))
+}
+
+/// `p` without Windows' `\\?\` prefix, for messages.
+fn shown(p: &Path) -> String {
+    let s = p.to_string_lossy();
+    match s.strip_prefix(r"\\?\UNC\") {
+        Some(unc) => format!(r"\\{unc}"),
+        None => s.strip_prefix(r"\\?\").unwrap_or(&s).to_string(),
+    }
+}
+
+/// `path` made absolute and resolved: links followed, and for a path that doesn't exist yet its
+/// nearest existing folder resolved with the rest appended (plain names only).
+fn resolve(path: &Path) -> std::result::Result<PathBuf, String> {
+    if path.as_os_str().is_empty() {
+        return Err("not a file path".into());
+    }
+    let abs = std::path::absolute(path).map_err(|e| e.to_string())?;
+    let mut rest: Vec<OsString> = Vec::new();
+    let mut at = abs.as_path();
+    loop {
+        match std::fs::canonicalize(at) {
+            Ok(mut base) => {
+                base.extend(rest.iter().rev());
+                return Ok(base);
+            }
+            Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
+                // Writing through a link that leads nowhere would create its target, wherever it is.
+                if std::fs::symlink_metadata(at).is_ok() {
+                    return Err("a link that leads nowhere".into());
+                }
+                match at.components().next_back() {
+                    Some(Component::Normal(name)) => {
+                        plain_name(name)?;
+                        rest.push(name.to_os_string());
+                    }
+                    Some(Component::CurDir) => {}
+                    _ => return Err("`..` (or a drive) below a folder that doesn't exist".into()),
+                }
+                at = at.parent().ok_or("no existing folder")?;
+            }
+            Err(e) => return Err(e.to_string()),
+        }
+    }
+}
+
+/// A name for a file or folder that doesn't exist yet: on Windows no device (`CON`, `NUL`, `COM1`…)
+/// and no alternate data stream (`a:b`).
+fn plain_name(name: &OsStr) -> std::result::Result<(), String> {
+    if cfg!(windows) {
+        let n = name.to_string_lossy();
+        let stem = n.split('.').next().unwrap_or_default().trim_end().to_ascii_uppercase();
+        let device = matches!(stem.as_str(), "CON" | "PRN" | "AUX" | "NUL" | "CONIN$" | "CONOUT$")
+            || ((stem.starts_with("COM") || stem.starts_with("LPT"))
+                && stem.chars().count() == 4
+                && stem.chars().last().is_some_and(|c| c.is_ascii_digit() || matches!(c, '¹' | '²' | '³')));
+        if device || n.contains(':') {
+            return Err(format!("`{n}` is a device or stream name, not a file"));
+        }
+    }
+    Ok(())
+}
+
+thread_local! {
+    static ROOTS: RefCell<Option<Arc<Roots>>> = const { RefCell::new(None) };
+}
+
+/// Run `f` with this thread's file access confined to `roots` (unchanged when `None`).
+pub fn confined<R>(roots: Option<&Arc<Roots>>, f: impl FnOnce() -> R) -> R {
+    match roots {
+        Some(roots) => scoped(Some(roots.clone()), f),
+        None => f(),
+    }
+}
+
+/// Run `f` unconfined: only for the app's own files, never for a path a command was given.
+// Only plugins read from disk use it, and the browser has no disk.
+#[cfg_attr(target_arch = "wasm32", allow(dead_code))]
+pub(crate) fn app_owned<R>(f: impl FnOnce() -> R) -> R {
+    scoped(None, f)
+}
+
+fn scoped<R>(roots: Option<Arc<Roots>>, f: impl FnOnce() -> R) -> R {
+    /// Puts the outer scope's roots back, also when `f` panics.
+    struct Restore(Option<Arc<Roots>>);
+    impl Drop for Restore {
+        fn drop(&mut self) {
+            let outer = self.0.take();
+            ROOTS.with(|r| *r.borrow_mut() = outer);
+        }
+    }
+    let _restore = Restore(ROOTS.with(|r| std::mem::replace(&mut *r.borrow_mut(), roots)));
+    f()
+}
+
+/// The roots this thread's file access is confined to now, if any.
+pub fn current() -> Option<Arc<Roots>> {
+    ROOTS.with(|r| r.borrow().clone())
+}
+
+/// The path to use for `access` to `path`: resolved when confined, else as given.
+pub fn allow(path: impl AsRef<Path>, access: Access) -> Result<PathBuf> {
+    let path = path.as_ref();
+    match current() {
+        Some(roots) => roots.check(path, access).map_err(EngineError::Other),
+        None => Ok(path.to_path_buf()),
+    }
+}
+
+/// Whether `path` may be accessed so now.
+pub fn allowed(path: impl AsRef<Path>, access: Access) -> bool {
+    allow(path, access).is_ok()
+}
+
+fn io(path: &Path) -> impl Fn(std::io::Error) -> EngineError + '_ {
+    move |e| EngineError::Other(format!("{}: {e}", path.display()))
+}
+
+/// The bytes of file `path`.
+pub fn read(path: impl AsRef<Path>) -> Result<Vec<u8>> {
+    let path = path.as_ref();
+    std::fs::read(allow(path, Access::Read)?).map_err(io(path))
+}
+
+/// The bytes of file `path`, refused when it isn't a file or is larger than `max`.
+pub fn read_capped(path: impl AsRef<Path>, max: u64) -> Result<Vec<u8>> {
+    let path = path.as_ref();
+    let p = allow(path, Access::Read)?;
+    let meta = std::fs::metadata(&p).map_err(io(path))?;
+    if !meta.is_file() || meta.len() > max {
+        return Err(EngineError::Other(format!("{}: not a file of at most {max} bytes", path.display())));
+    }
+    std::fs::read(p).map_err(io(path))
+}
+
+/// File `path` opened for reading.
+pub fn open(path: impl AsRef<Path>) -> Result<std::fs::File> {
+    let path = path.as_ref();
+    std::fs::File::open(allow(path, Access::Read)?).map_err(io(path))
+}
+
+/// What the file system says about `path` (links followed).
+pub fn metadata(path: impl AsRef<Path>) -> Result<std::fs::Metadata> {
+    let path = path.as_ref();
+    std::fs::metadata(allow(path, Access::Read)?).map_err(io(path))
+}
+
+/// Whether `path` is a folder (false when it may not be read).
+pub fn is_dir(path: impl AsRef<Path>) -> bool {
+    metadata(path).is_ok_and(|m| m.is_dir())
+}
+
+/// Whether `path` exists (false when it may not be read).
+pub fn exists(path: impl AsRef<Path>) -> bool {
+    metadata(path).is_ok()
+}
+
+/// The paths of the entries of folder `path`.
+pub fn read_dir(path: impl AsRef<Path>) -> Result<Vec<PathBuf>> {
+    let path = path.as_ref();
+    let dir = allow(path, Access::Read)?;
+    Ok(std::fs::read_dir(&dir).map_err(io(path))?.flatten().map(|e| e.path()).collect())
+}
+
+/// Write `bytes` to `path` through a uniquely named staging file and one atomic rename (see
+/// [`figcraft_format::write_file_atomic`]).
+pub fn write(path: impl AsRef<Path>, bytes: &[u8]) -> Result<()> {
+    let path = path.as_ref();
+    write_atomic(&allow(path, Access::Write)?, bytes).map_err(io(path))
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+fn write_atomic(path: &Path, bytes: &[u8]) -> std::io::Result<()> {
+    figcraft_format::write_file_atomic(path, bytes)
+}
+
+#[cfg(target_arch = "wasm32")]
+fn write_atomic(_: &Path, _: &[u8]) -> std::io::Result<()> {
+    Err(std::io::Error::new(std::io::ErrorKind::Unsupported, "no file system in the browser"))
+}
+
+/// Create folder `path` and the folders above it that are missing.
+pub fn create_dir_all(path: impl AsRef<Path>) -> Result<()> {
+    let path = path.as_ref();
+    std::fs::create_dir_all(allow(path, Access::Write)?).map_err(io(path))
+}
+
+#[cfg(test)]
+#[path = "file_access_tests.rs"]
+mod tests;
diff --git a/crates/engine/src/file_access_tests.rs b/crates/engine/src/file_access_tests.rs
new file mode 100644
index 000000000..ba55e1348
--- /dev/null
+++ b/crates/engine/src/file_access_tests.rs
@@ -0,0 +1,388 @@
+//! Automation roots: how paths are resolved and compared, and that commands run confined can't
+//! reach past them.
+
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+use serde_json::json;
+
+use super::{Access, Roots, allow, confined, current};
+use crate::Session;
+
+/// A fresh folder for one test: `<tmp>/figcraft-roots-<name>-<pid>`, holding `root/`, `root2/`
+/// (a sibling whose name starts like the root's) and `outside/`.
+struct Fixture(PathBuf);
+
+impl Fixture {
+    fn new(name: &str) -> Self {
+        let d = std::env::temp_dir().join(format!("figcraft-roots-{name}-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&d);
+        for sub in ["root/sub", "root2", "outside"] {
+            std::fs::create_dir_all(d.join(sub)).unwrap();
+        }
+        std::fs::write(d.join("root/in.txt"), b"in").unwrap();
+        std::fs::write(d.join("outside/secret.txt"), b"secret").unwrap();
+        Self(d)
+    }
+
+    fn p(&self, rel: &str) -> String {
+        self.0.join(rel).to_string_lossy().into_owned()
+    }
+
+    /// The root as both read and write root.
+    fn rw(&self) -> Roots {
+        Roots::new(&[], &[self.p("root")]).unwrap()
+    }
+}
+
+impl Drop for Fixture {
+    fn drop(&mut self) {
+        let _ = std::fs::remove_dir_all(&self.0);
+    }
+}
+
+#[cfg(unix)]
+fn symlink_dir(target: &Path, link: &Path) -> bool {
+    std::os::unix::fs::symlink(target, link).is_ok()
+}
+
+#[cfg(windows)]
+fn symlink_dir(target: &Path, link: &Path) -> bool {
+    std::os::windows::fs::symlink_dir(target, link).is_ok()
+}
+
+#[cfg(unix)]
+fn symlink_file(target: &Path, link: &Path) -> bool {
+    std::os::unix::fs::symlink(target, link).is_ok()
+}
+
+#[cfg(windows)]
+fn symlink_file(target: &Path, link: &Path) -> bool {
+    std::os::windows::fs::symlink_file(target, link).is_ok()
+}
+
+#[test]
+fn inside_is_allowed_and_resolved_outside_is_refused() {
+    let f = Fixture::new("inside");
+    let r = f.rw();
+    let got = r.check(Path::new(&f.p("root/in.txt")), Access::Read).unwrap();
+    assert_eq!(got, std::fs::canonicalize(f.p("root/in.txt")).unwrap(), "the I/O uses the resolved path");
+    assert!(r.check(Path::new(&f.p("root/new.png")), Access::Write).is_ok());
+    let e = r.check(Path::new(&f.p("outside/secret.txt")), Access::Read).unwrap_err();
+    assert!(e.starts_with("automation path rejected:") && e.contains("outside the folders that may be read"), "{e}");
+    assert!(r.check(Path::new(&f.p("outside/new.png")), Access::Write).is_err());
+    // The root itself is inside.
+    assert!(r.check(Path::new(&f.p("root")), Access::Read).is_ok());
+}
+
+#[test]
+fn a_sibling_whose_name_starts_like_the_root_is_outside() {
+    let f = Fixture::new("prefix");
+    let r = f.rw();
+    for p in ["root2/x.png", "root2", "root.png"] {
+        assert!(r.check(Path::new(&f.p(p)), Access::Write).is_err(), "{p}");
+        assert!(r.check(Path::new(&f.p(p)), Access::Read).is_err(), "{p}");
+    }
+}
+
+#[test]
+fn traversal_is_resolved_before_comparing() {
+    let f = Fixture::new("dots");
+    let r = f.rw();
+    assert!(r.check(Path::new(&f.p("root/sub/../../outside/secret.txt")), Access::Read).is_err());
+    assert!(r.check(Path::new(&f.p("root/sub/../../outside/new.txt")), Access::Write).is_err());
+    assert!(r.check(Path::new(&f.p("root/sub/../in.txt")), Access::Read).is_ok());
+    assert!(r.check(Path::new(&f.p("root/./sub/../new.txt")), Access::Write).is_ok());
+    // `..` below a folder that doesn't exist can't be resolved (on Windows it is taken lexically,
+    // as the system does, and stays inside).
+    let deep = f.p("root/missing/../../outside/x.txt");
+    assert!(r.check(Path::new(&deep), Access::Write).is_err(), "{deep}");
+}
+
+#[test]
+fn files_that_dont_exist_yet_resolve_through_their_nearest_folder() {
+    let f = Fixture::new("missing");
+    let r = f.rw();
+    let got = r.check(Path::new(&f.p("root/a/b/c.png")), Access::Write).unwrap();
+    assert_eq!(got, std::fs::canonicalize(f.p("root")).unwrap().join("a").join("b").join("c.png"));
+    assert!(r.check(Path::new(&f.p("outside/a/b/c.png")), Access::Write).is_err());
+}
+
+#[test]
+fn relative_paths_are_resolved_against_the_working_directory() {
+    // `cargo test` runs in the crate's folder, which holds Cargo.toml.
+    let cwd = std::env::current_dir().unwrap().to_string_lossy().into_owned();
+    let here = Roots::new(std::slice::from_ref(&cwd), &[]).unwrap();
+    assert_eq!(here.check(Path::new("Cargo.toml"), Access::Read).unwrap(), std::fs::canonicalize("Cargo.toml").unwrap());
+    assert!(here.check(Path::new("src/../Cargo.toml"), Access::Read).is_ok());
+    let f = Fixture::new("relative");
+    assert!(f.rw().check(Path::new("Cargo.toml"), Access::Read).is_err());
+    // Relative roots too.
+    assert_eq!(Roots::new(&[".".into()], &[]).unwrap(), here);
+}
+
+#[test]
+fn read_and_write_authority_are_separate() {
+    let f = Fixture::new("modes");
+    let read_only = Roots::new(&[f.p("root")], &[]).unwrap();
+    assert!(read_only.check(Path::new(&f.p("root/in.txt")), Access::Read).is_ok());
+    let e = read_only.check(Path::new(&f.p("root/out.png")), Access::Write).unwrap_err();
+    assert!(e.contains("no folder may be written"), "{e}");
+    // A write root may be read too; a read root elsewhere doesn't make it writable.
+    let both = Roots::new(&[f.p("outside")], &[f.p("root")]).unwrap();
+    assert!(both.check(Path::new(&f.p("root/in.txt")), Access::Read).is_ok());
+    assert!(both.check(Path::new(&f.p("outside/secret.txt")), Access::Read).is_ok());
+    assert!(both.check(Path::new(&f.p("outside/new.txt")), Access::Write).is_err());
+    // Several roots of each kind.
+    let many = Roots::new(&[f.p("root"), f.p("root2")], &[f.p("root2"), f.p("outside")]).unwrap();
+    assert!(many.check(Path::new(&f.p("outside/new.txt")), Access::Write).is_ok());
+    assert!(many.check(Path::new(&f.p("root/new.txt")), Access::Write).is_err());
+}
+
+#[test]
+fn roots_must_be_existing_folders() {
+    let f = Fixture::new("bad-roots");
+    assert!(Roots::new(&[f.p("nope")], &[]).unwrap_err().contains("--automation-read-root"));
+    assert!(Roots::new(&[], &[f.p("root/in.txt")]).unwrap_err().contains("not a folder"));
+    assert!(Roots::new(&[], &[String::new()]).is_err());
+    assert!(f.rw().check(Path::new(""), Access::Read).is_err());
+}
+
+#[test]
+fn links_that_lead_out_of_a_root_are_outside() {
+    let f = Fixture::new("links");
+    let r = f.rw();
+    if !symlink_dir(&f.0.join("outside"), &f.0.join("root/escape")) || !symlink_file(&f.0.join("outside/secret.txt"), &f.0.join("root/secret.txt")) {
+        eprintln!("skipped: this system doesn't let tests make symbolic links");
+        return;
+    }
+    assert!(r.check(Path::new(&f.p("root/escape/secret.txt")), Access::Read).is_err());
+    assert!(r.check(Path::new(&f.p("root/escape/new.txt")), Access::Write).is_err());
+    assert!(r.check(Path::new(&f.p("root/secret.txt")), Access::Read).is_err());
+    assert!(r.check(Path::new(&f.p("root/secret.txt")), Access::Write).is_err());
+    // A link that leads nowhere: writing through it would create its target.
+    assert!(symlink_file(&f.0.join("outside/not-yet.txt"), &f.0.join("root/dangling.txt")));
+    let e = r.check(Path::new(&f.p("root/dangling.txt")), Access::Write).unwrap_err();
+    assert!(e.contains("leads nowhere"), "{e}");
+    // A link inside the root to the root is fine.
+    assert!(symlink_dir(&f.0.join("root/sub"), &f.0.join("root/alias")));
+    assert!(r.check(Path::new(&f.p("root/alias/x.png")), Access::Write).is_ok());
+}
+
+#[cfg(windows)]
+#[test]
+fn windows_case_devices_and_streams() {
+    let f = Fixture::new("windows");
+    let r = f.rw();
+    // Case is taken from the disk: another spelling of the root is the root.
+    let upper = f.0.join("ROOT").join("IN.TXT");
+    assert!(r.check(&upper, Access::Read).is_ok());
+    for name in ["CON", "nul.txt", "Com1.png", "LPT9", "a.txt:stream", "conout$"] {
+        assert!(r.check(&f.0.join("root").join(name), Access::Write).is_err(), "{name}");
+    }
+    assert!(r.check(&f.0.join("root").join("console.png"), Access::Write).is_ok());
+    // The `\\?\` form of a path inside is inside; of a path outside, outside.
+    let verbatim = std::fs::canonicalize(f.p("root")).unwrap().join("v.png");
+    assert!(verbatim.to_string_lossy().starts_with(r"\\?\"));
+    assert!(r.check(&verbatim, Access::Write).is_ok());
+    assert!(r.check(&std::fs::canonicalize(f.p("outside")).unwrap().join("v.png"), Access::Write).is_err());
+    // Messages don't show the prefix.
+    let e = r.check(Path::new(&f.p("outside/x.png")), Access::Write).unwrap_err();
+    assert!(!e.contains(r"\\?\"), "{e}");
+}
+
+#[test]
+fn a_scope_confines_the_thread_and_ends_with_it() {
+    let f = Fixture::new("scope");
+    let roots = Arc::new(f.rw());
+    assert!(current().is_none());
+    confined(Some(&roots), || {
+        assert!(allow(f.p("outside/secret.txt"), Access::Read).is_err());
+        assert!(super::read(f.p("outside/secret.txt")).is_err());
+        assert_eq!(super::read(f.p("root/in.txt")).unwrap(), b"in");
+        // Not confined: the app's own files.
+        assert_eq!(super::app_owned(|| super::read(f.p("outside/secret.txt")).unwrap()), b"secret");
+        assert!(current().is_some(), "back in the scope after app_owned");
+        // Another thread isn't confined by this one's scope.
+        let p = f.p("outside/secret.txt");
+        assert!(std::thread::spawn(move || current().is_none() && allow(p, Access::Read).is_ok()).join().unwrap());
+    });
+    assert!(current().is_none());
+    assert!(allow(f.p("outside/secret.txt"), Access::Read).is_ok());
+    // A panic inside the scope still ends it.
+    let r = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| confined(Some(&roots), || panic!("boom"))));
+    assert!(r.is_err());
+    assert!(current().is_none());
+    // `None` changes nothing.
+    assert!(confined(None, || current().is_none()));
+}
+
+#[test]
+fn commands_run_confined_read_and_write_only_inside() {
+    let f = Fixture::new("commands");
+    std::fs::create_dir_all(f.0.join("outside/readable")).unwrap();
+    let roots = Arc::new(Roots::new(&[f.p("outside/readable")], &[f.p("root")]).unwrap());
+    // Unconfined, the outside is writable: the bait files a confined command must not reach.
+    let bait = f.p("outside/bait.figcraft");
+    let mut s = Session::new();
+    s.execute("frame.create", &json!({"x": 0, "y": 0, "width": 20, "height": 10})).unwrap();
+    s.execute("file.saveAs", &json!({"path": bait})).unwrap();
+    std::fs::copy(&bait, f.0.join("outside/readable/ok.figcraft")).unwrap();
+    let mut s = Session::new();
+    s.execute("frame.create", &json!({"x": 0, "y": 0, "width": 20, "height": 10})).unwrap();
+    s.prefs.recent_files = vec![bait.clone(), f.p("root/in.txt")];
+    confined(Some(&roots), || {
+        let e = s.execute("file.export", &json!({"format": "png", "path": f.p("outside/x.png")})).unwrap_err().to_string();
+        assert!(e.contains("automation path rejected"), "{e}");
+        assert!(s.execute("file.export", &json!({"format": "png", "path": f.p("root/x.png")})).is_ok());
+        assert!(s.execute("file.exportLayers", &json!({"dir": f.p("outside/layers")})).is_err());
+        assert!(s.execute("file.open", &json!({"path": bait})).is_err());
+        assert!(s.execute("file.import", &json!({"path": bait})).is_err());
+        assert!(s.execute("file.placeImage", &json!({"path": f.p("outside/secret.txt")})).is_err());
+        assert!(s.execute("file.open", &json!({"path": f.p("outside/readable/ok.figcraft")})).is_ok(), "read roots may be read");
+        assert!(s.execute("file.save", &json!({})).is_err(), "but not written");
+        assert!(s.execute("file.saveAs", &json!({"path": f.p("root/ok.figcraft")})).is_ok());
+        // Recent files outside the roots aren't listed.
+        let recent = s.execute("file.openRecent", &json!({})).unwrap().to_string();
+        assert!(!recent.contains("bait") && recent.contains("in.txt"), "{recent}");
+        assert!(s.execute("file.openRecent", &json!({"path": bait})).is_err());
+    });
+    assert!(f.0.join("root/x.png").is_file() && !f.0.join("outside/x.png").exists() && !f.0.join("outside/layers").exists());
+}
+
+/// Every command, given paths outside the roots in its usual path parameters, writes nothing
+/// there and opens nothing from there: they all reach files through `file_access`.
+#[test]
+fn no_command_reaches_outside_the_roots() {
+    let f = Fixture::new("sweep");
+    let roots = Arc::new(f.rw());
+    let outside = f.0.join("outside");
+    // Bait the sweep could pick up: a document, an SVG, a PNG and variables JSON, each holding a
+    // name that must never show up in a document or a result.
+    let mut s = Session::new();
+    s.execute("frame.create", &json!({"x": 0, "y": 0, "width": 20, "height": 10, "name": "BAIT-LAYER"})).unwrap();
+    s.execute("file.saveAs", &json!({"path": f.p("outside/bait.figcraft")})).unwrap();
+    s.execute("file.export", &json!({"format": "png", "path": f.p("outside/bait.png")})).unwrap();
+    std::fs::write(
+        outside.join("bait.svg"),
+        r#"<svg xmlns="http://www.w3.org/2000/svg" width="9" height="9"><rect id="BAIT-LAYER" width="9" height="9"/></svg>"#,
+    )
+    .unwrap();
+    let before: Vec<_> = std::fs::read_dir(&outside).unwrap().flatten().map(|e| e.file_name()).collect();
+    // The bait is what an unconfined command finds.
+    for (cmd, bait) in [("file.open", "bait.figcraft"), ("file.import", "bait.svg")] {
+        let mut s = Session::new();
+        s.execute(cmd, &json!({"path": f.p(&format!("outside/{bait}"))})).unwrap();
+        assert!(crate::inspect::document(&s, 64, true).to_string().contains("BAIT-LAYER"), "{cmd} {bait}");
+    }
+    let mut s = Session::new();
+    s.execute("file.placeImage", &json!({"path": f.p("outside/bait.png")})).unwrap();
+    assert!(!s.doc().unwrap().images.is_empty());
+    for bait in ["bait.figcraft", "bait.svg", "bait.png", "new.figcraft", "new.png"] {
+        let path = f.p(&format!("outside/{bait}"));
+        let params = json!({"path": path, "dir": f.p("outside"), "file": path, "variables": path, "folder": f.p("outside"), "confirm": true});
+        for c in crate::all_commands() {
+            let mut s = Session::new();
+            let r = confined(Some(&roots), || s.execute(c.id, &params));
+            let shown = format!("{r:?}");
+            assert!(!shown.contains("BAIT-LAYER"), "{} read {bait}: {shown}", c.id);
+            let docs = crate::inspect::document(&s, 64, true).to_string();
+            assert!(!docs.contains("BAIT-LAYER"), "{} opened {bait}", c.id);
+            assert!(s.docs.iter().all(|ds| ds.doc.images.is_empty()), "{} placed {bait}", c.id);
+            let now: Vec<_> = std::fs::read_dir(&outside).unwrap().flatten().map(|e| e.file_name()).collect();
+            assert_eq!(now, before, "{} wrote outside the roots with {bait}", c.id);
+        }
+    }
+}
+
+#[test]
+fn recent_files_outside_the_roots_are_never_opened_removed_or_named() {
+    let f = Fixture::new("recents");
+    let roots = Arc::new(f.rw());
+    let (bait, gone, ok) = (f.p("outside/bait.figcraft"), f.p("outside/gone.figcraft"), f.p("root/ok.figcraft"));
+    let mut s = Session::new();
+    s.execute("frame.create", &json!({"x": 0, "y": 0, "width": 20, "height": 10})).unwrap();
+    s.execute("file.saveAs", &json!({"path": bait})).unwrap();
+    s.execute("file.saveAs", &json!({"path": ok})).unwrap();
+    let mut s = Session::new();
+    let recents = vec![bait.clone(), gone.clone(), ok.clone()];
+    s.prefs.recent_files = recents.clone();
+    let quiet = |r: &crate::Result<serde_json::Value>| {
+        let shown = format!("{r:?}");
+        assert!(!shown.contains("bait") && !shown.contains("gone"), "an outside recent file was named: {shown}");
+    };
+    confined(Some(&roots), || {
+        let listing = s.execute("file.openRecent", &json!({}));
+        quiet(&listing);
+        assert_eq!(listing.unwrap()["files"].as_array().unwrap().len(), 1);
+        // `index` counts the files listed: 0 is the first one inside the roots.
+        let opened = s.execute("file.openRecent", &json!({"index": 0}));
+        quiet(&opened);
+        assert!(opened.is_ok(), "{opened:?}");
+        assert_eq!(s.ds().unwrap().path.as_deref(), Some(ok.as_str()));
+        for i in [1, 2] {
+            let r = s.execute("file.openRecent", &json!({"index": i}));
+            quiet(&r);
+            assert!(r.is_err());
+        }
+        // A path outside is refused like any outside path, and never dropped from the list.
+        let e = s.execute("file.openRecent", &json!({"path": gone})).unwrap_err().to_string();
+        assert!(e.contains("is outside the folders that may be read") && !e.contains("no longer exists"), "{e}");
+        quiet(&s.execute("file.openRecent", &json!({"remove": bait})));
+        assert!(s.prefs.recent_files.contains(&bait) && s.prefs.recent_files.contains(&gone));
+        // Clear clears what is listed.
+        quiet(&s.execute("file.openRecent", &json!({"clear": true})));
+    });
+    assert_eq!(s.prefs.recent_files, vec![bait, gone]);
+    // Unconfined, a recent file that is gone is still dropped.
+    s.execute("file.openRecent", &json!({"index": 1})).unwrap_err();
+    assert_eq!(s.prefs.recent_files.len(), 1);
+}
+
+#[test]
+fn outside_paths_are_refused_alike_whatever_exists_there() {
+    let f = Fixture::new("oracle");
+    let r = f.rw();
+    let refusal = |p: &str| r.check(Path::new(p), Access::Write).unwrap_err();
+    let standard = |p: &str| format!("automation path rejected: {} is outside the folders that may be written:", Path::new(p).display());
+    let mut outside = vec![f.p("outside/secret.txt"), f.p("outside/none.txt"), f.p("outside/missing/../x.txt"), f.p("nowhere/deeper/x.txt")];
+    if symlink_file(&f.0.join("outside/not-yet.txt"), &f.0.join("outside/dangling.txt")) {
+        outside.push(f.p("outside/dangling.txt"));
+        // Reached through a link in the root, it is outside all the same.
+        if symlink_dir(&f.0.join("outside"), &f.0.join("root/escape")) {
+            outside.push(f.p("root/escape/dangling.txt"));
+        }
+    }
+    for p in &outside {
+        let e = refusal(p);
+        assert!(e.starts_with(&standard(p)), "{p}: {e}");
+    }
+    // Inside a root the reason is given.
+    if symlink_file(&f.0.join("outside/not-yet.txt"), &f.0.join("root/dangling.txt")) {
+        assert!(refusal(&f.p("root/dangling.txt")).contains("leads nowhere"));
+    }
+}
+
+#[test]
+fn a_root_given_through_a_link_tells_why_paths_in_it_are_refused() {
+    let f = Fixture::new("linked-root");
+    if !symlink_dir(&f.0.join("root"), &f.0.join("via")) || !symlink_file(&f.0.join("outside/not-yet.txt"), &f.0.join("root/dangling.txt")) {
+        eprintln!("skipped: this system doesn't let tests make symbolic links");
+        return;
+    }
+    // Like `/tmp/work` on macOS, where `/tmp` leads to `/private/tmp`.
+    let r = Roots::new(&[], &[f.p("via")]).unwrap();
+    let e = r.check(Path::new(&f.p("via/dangling.txt")), Access::Write).unwrap_err();
+    assert!(e.contains("leads nowhere"), "{e}");
+}
+
+#[test]
+fn only_resolved_paths_count_as_the_apps_own_folder() {
+    let f = Fixture::new("own");
+    let install = f.0.join("root");
+    assert!(super::within_app_folder(&install.join("in.txt"), &install));
+    assert!(!super::within_app_folder(&install.join("..").join("outside").join("secret.txt"), &install), "`..` leaves it");
+    assert!(!super::within_app_folder(&f.0.join("root2"), &install), "a folder named like it is another");
+    assert!(!super::within_app_folder(&install.join("missing.wasm"), &install));
+    assert!(!super::within_app_folder(&install.join("in.txt"), &f.0.join("no-such-folder")));
+}
diff --git a/crates/engine/src/fill_none_tests.rs b/crates/engine/src/fill_none_tests.rs
new file mode 100644
index 000000000..74fe62316
--- /dev/null
+++ b/crates/engine/src/fill_none_tests.rs
@@ -0,0 +1,88 @@
+//! `props.fill` and `props.stroke` accept `"none"` (either case) and `null` as no paint, the
+//! same as an empty `fills`/`strokes` list (#1036): an outline-only shape in one call.
+
+use figcraft_doc::NodeId;
+use serde_json::{Value, json};
+
+use crate::Session;
+
+fn id(v: Value) -> NodeId {
+    NodeId(v["id"].as_u64().unwrap())
+}
+
+fn ex(s: &mut Session, cmd: &str, p: Value) -> Value {
+    s.execute(cmd, &p).unwrap_or_else(|e| panic!("{cmd} {p}: {e}"))
+}
+
+fn create_rect(s: &mut Session, fill: Value) -> NodeId {
+    id(ex(
+        s,
+        "node.create",
+        json!({
+            "type": "rectangle", "x": 0, "y": 0, "width": 10, "height": 10,
+            "props": {"fill": fill, "stroke": "#000000", "strokeWeight": 1}
+        }),
+    ))
+}
+
+#[test]
+fn fill_none_or_null_makes_an_outline_only_shape_in_one_call() {
+    for none in [json!("none"), json!("None"), json!("NONE"), json!(null)] {
+        let mut s = Session::new();
+        let r = create_rect(&mut s, none.clone());
+        let n = s.doc().unwrap().node(r).unwrap().clone();
+        assert!(n.fills.is_empty(), "{none:?}: fills not empty");
+        assert_eq!(n.strokes.len(), 1, "{none:?}: stroke kept");
+    }
+}
+
+#[test]
+fn fill_none_clears_an_existing_fill_as_one_undo_step() {
+    let mut s = Session::new();
+    let r = create_rect(&mut s, json!("#FF0000"));
+    assert_eq!(s.doc().unwrap().node(r).unwrap().fills.len(), 1);
+    ex(&mut s, "node.set", json!({"id": r, "props": {"fill": "none"}}));
+    assert!(s.doc().unwrap().node(r).unwrap().fills.is_empty());
+    ex(&mut s, "edit.undo", json!({}));
+    assert_eq!(s.doc().unwrap().node(r).unwrap().fills.len(), 1);
+}
+
+#[test]
+fn stroke_none_or_null_clears_the_strokes() {
+    for none in [json!("none"), json!(null)] {
+        let mut s = Session::new();
+        let r = create_rect(&mut s, json!("#FF0000"));
+        ex(&mut s, "node.set", json!({"id": r, "props": {"stroke": none}}));
+        assert!(s.doc().unwrap().node(r).unwrap().strokes.is_empty(), "{none:?}");
+        assert_eq!(s.doc().unwrap().node(r).unwrap().fills.len(), 1, "{none:?}");
+    }
+}
+
+#[test]
+fn text_with_fill_none_gets_no_automatic_colour() {
+    let mut s = Session::new();
+    let t = id(ex(
+        &mut s,
+        "node.create",
+        json!({
+            "type": "text", "x": 0, "y": 0, "text": "Hi", "props": {"fill": "none"}
+        }),
+    ));
+    assert!(s.doc().unwrap().node(t).unwrap().fills.is_empty());
+}
+
+#[test]
+fn an_unknown_string_still_names_the_key() {
+    let mut s = Session::new();
+    let e = s
+        .execute(
+            "node.create",
+            &json!({
+                "type": "rectangle", "x": 0, "y": 0, "width": 10, "height": 10,
+                "props": {"fill": "nope"}
+            }),
+        )
+        .unwrap_err();
+    let msg = e.to_string();
+    assert!(msg.contains("`fill`") && msg.contains("none"), "{msg}");
+}
diff --git a/crates/engine/src/finite_geometry_tests.rs b/crates/engine/src/finite_geometry_tests.rs
new file mode 100644
index 000000000..416b250c8
--- /dev/null
+++ b/crates/engine/src/finite_geometry_tests.rs
@@ -0,0 +1,40 @@
+//! Commands never leave a layer with a non-finite position or size: such a file saves but can't be
+//! reopened (JSON writes NaN and infinity as null).
+
+use serde_json::json;
+
+use crate::Session;
+
+fn rect(s: &mut Session) -> crate::NodeId {
+    let r = s.execute("node.create", &json!({"type": "rectangle", "x": 0, "y": 10, "width": 100, "height": 50})).unwrap();
+    crate::params::id_of(&r["id"]).unwrap()
+}
+
+fn assert_roundtrips(s: &Session) {
+    let bytes = figcraft_format::save_bytes(s.doc().unwrap(), None).unwrap();
+    assert!(figcraft_format::load_bytes(&bytes).is_ok(), "the saved file reopens");
+}
+
+#[test]
+fn huge_moves_are_refused_and_the_file_still_reopens() {
+    let mut s = Session::new();
+    let r = rect(&mut s);
+    s.execute("transform.move", &json!({"ids": [r], "dx": 1e308, "dy": 0})).ok();
+    let second = s.execute("transform.move", &json!({"ids": [r], "dx": 1e308, "dy": 1e308}));
+    assert!(second.is_err(), "a move past the f64 range is refused");
+    let n = s.doc().unwrap().node(r).unwrap();
+    assert!(n.transform.as_coeffs().iter().all(|c| c.is_finite()), "{:?}", n.transform);
+    assert_roundtrips(&s);
+}
+
+#[test]
+fn huge_scale_is_refused_and_the_file_still_reopens() {
+    let mut s = Session::new();
+    let r = rect(&mut s);
+    s.execute("transform.scale", &json!({"ids": [r], "factor": 1e300})).ok();
+    let second = s.execute("transform.scale", &json!({"ids": [r], "factor": 1e300}));
+    assert!(second.is_err(), "a size past the f64 range is refused");
+    let n = s.doc().unwrap().node(r).unwrap();
+    assert!(n.width.is_finite() && n.height.is_finite(), "{} x {}", n.width, n.height);
+    assert_roundtrips(&s);
+}
diff --git a/crates/engine/src/fonts.rs b/crates/engine/src/fonts.rs
new file mode 100644
index 000000000..672d4f2ca
--- /dev/null
+++ b/crates/engine/src/fonts.rs
@@ -0,0 +1,160 @@
+//! Fonts a document names that this machine doesn't have (#752): text layers, their styled
+//! ranges, text styles and the string variables bound to a font family. Text in such a family
+//! is drawn in a fallback font, so the user is told which ones are missing. Once such a font is
+//! there, [`refit`] lets auto-sizing text measure its box in it again.
+
+use std::collections::{BTreeMap, BTreeSet};
+
+use figcraft_doc::{Document, NodeId, NodeKind, StyleKind, VariableValue, Variables};
+use serde_json::{Value, json};
+
+use crate::cmd::CommandSpec;
+use crate::params::{get, req_targets};
+use crate::{Result, Session, spec};
+
+/// A family the document names that no installed or built-in font provides.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Missing {
+    /// As the document spells it.
+    pub family: String,
+    /// Text layers that use it (0: only a text style or a variable names it).
+    pub layers: usize,
+}
+
+/// The families `doc` names that the font database doesn't have, by name. On the desktop the
+/// installed fonts are indexed in the background: ask once that's done
+/// (`figcraft_text::installed_fonts_known`), or every installed family counts as missing.
+pub fn missing(doc: &Document) -> Vec<Missing> {
+    // Lower-case family → (spelling, layers).
+    let mut used: BTreeMap<String, (String, usize)> = BTreeMap::new();
+    let mut add = |family: &str, layer: bool| {
+        let family = family.trim();
+        if family.is_empty() {
+            return;
+        }
+        let e = used.entry(family.to_lowercase()).or_insert_with(|| (family.to_string(), 0));
+        e.1 += usize::from(layer);
+    };
+    for n in doc.nodes() {
+        if let NodeKind::Text(t) = &n.kind {
+            let mut families: Vec<&str> = t.spans().into_iter().map(|(_, _, st)| st.font_family.as_str()).collect();
+            families.push(&t.style.font_family);
+            families.sort_by_key(|f| f.trim().to_lowercase());
+            families.dedup_by_key(|f| f.trim().to_lowercase());
+            for f in families {
+                add(f, true);
+            }
+        }
+        if let Some(var) = n.bound.get("fontFamily") {
+            for f in string_values(&doc.variables, var) {
+                add(&f, false);
+            }
+        }
+    }
+    for st in &doc.styles {
+        if let StyleKind::Text { style } = &st.kind {
+            add(&style.font_family, false);
+        }
+        if let Some(var) = st.bound.get("fontFamily") {
+            for f in string_values(&doc.variables, var) {
+                add(&f, false);
+            }
+        }
+    }
+    used.into_values().filter(|(family, _)| !figcraft_text::has_family(family)).map(|(family, layers)| Missing { family, layers }).collect()
+}
+
+/// Every string value of variable `id` in any mode, following aliases (at most 32 deep).
+fn string_values(vars: &Variables, id: &str) -> Vec<String> {
+    let mut out = Vec::new();
+    let mut todo = vec![(id.to_string(), 0)];
+    while let Some((id, depth)) = todo.pop() {
+        let Some(var) = vars.get(&id) else { continue };
+        for v in var.values.values() {
+            match v {
+                VariableValue::String(s) => out.push(s.clone()),
+                VariableValue::Alias(a) if depth < 32 => todo.push((a.clone(), depth + 1)),
+                _ => {}
+            }
+        }
+    }
+    out
+}
+
+/// Auto-sizing text layers measure their boxes again: a box measured while its family was missing
+/// (in a fallback font) follows the real face once that's installed or loaded. Only layers under
+/// `under` (every layer: `None`) that use one of `families` (any family: `None`). Returns the
+/// layers whose size changed.
+pub fn refit(doc: &mut Document, under: Option<&[NodeId]>, families: Option<&[String]>) -> Vec<NodeId> {
+    let want: Option<BTreeSet<String>> = families.map(|f| f.iter().map(|x| x.trim().to_lowercase()).collect());
+    let scope: Option<BTreeSet<NodeId>> = under.map(|ids| ids.iter().flat_map(|i| doc.subtree(*i)).collect());
+    let ids: Vec<NodeId> = doc
+        .nodes()
+        .filter(|n| scope.as_ref().is_none_or(|s| s.contains(&n.id)))
+        .filter(|n| {
+            let NodeKind::Text(t) = &n.kind else { return false };
+            let uses = |w: &BTreeSet<String>| {
+                w.contains(&t.style.font_family.trim().to_lowercase())
+                    || t.spans().iter().any(|(_, _, st)| w.contains(&st.font_family.trim().to_lowercase()))
+            };
+            want.as_ref().is_none_or(uses)
+                && figcraft_text::auto_size(n).is_some_and(|(w, h)| (w - n.width).abs() > 1e-6 || (h - n.height).abs() > 1e-6)
+        })
+        .map(|n| n.id)
+        .collect();
+    if !ids.is_empty() {
+        let before = doc.clone();
+        doc.mark_dirty(ids.iter().copied());
+        crate::normalize(doc, &before);
+    }
+    ids
+}
+
+/// [`refit`] in the open document, if there is one.
+pub(crate) fn refit_open(s: &mut Session, under: Option<&[NodeId]>, families: Option<&[String]>) -> Vec<NodeId> {
+    match s.doc_mut() {
+        Ok(doc) => refit(doc, under, families),
+        Err(_) => Vec::new(),
+    }
+}
+
+/// `text.refit`: the layers `ids` names (an `ids` that isn't a list of layers is refused), else the
+/// whole document.
+fn refit_text(s: &mut Session, p: &Value) -> Result<Value> {
+    let under = match get(p, "ids") {
+        None | Some(Value::Null) => None,
+        Some(_) => Some(req_targets("text.refit", s, p)?),
+    };
+    s.doc()?;
+    Ok(json!({"refitted": refit_open(s, under.as_deref(), None)}))
+}
+
+fn missing_fonts(s: &mut Session, _: &Value) -> Result<Value> {
+    let families: Vec<Value> = missing(s.doc()?).into_iter().map(|m| json!({"family": m.family, "layers": m.layers})).collect();
+    s.request_ui("dialog.missingFonts", json!({}));
+    Ok(json!({"families": families}))
+}
+
+/// The font commands: `text.missingFonts` and `text.refit`.
+pub fn specs() -> Vec<CommandSpec> {
+    vec![
+        spec!(
+            "text.missingFonts",
+            "Missing fonts",
+            "{}  fonts the open document names that aren't installed (text layers, styled ranges, text styles, font family variables); the app shows them → {families: [{family, layers}]}",
+            false,
+            missing_fonts
+        ),
+        spec!(
+            "text.refit",
+            "Fit text to fonts",
+            "{ids? (these layers and the text in them; default: the whole document)}  auto-sizing text measures its box again, e.g. a box measured in a fallback font while its family was missing → {refitted: [ids whose size changed]}",
+            true,
+            refit_text
+        ),
+    ]
+}
+
+#[cfg(test)]
+#[path = "fonts_tests.rs"]
+mod tests;
diff --git a/crates/engine/src/fonts_tests.rs b/crates/engine/src/fonts_tests.rs
new file mode 100644
index 000000000..0fe6dcb3f
--- /dev/null
+++ b/crates/engine/src/fonts_tests.rs
@@ -0,0 +1,215 @@
+use serde_json::json;
+
+use super::*;
+use crate::params::id_of;
+use figcraft_doc::{Style, StyleRun, TextStyle};
+
+fn text(s: &mut Session, family: &str) -> figcraft_doc::NodeId {
+    let id = id_of(&s.execute("text.create", &json!({"text": "Hamburgefonstiv", "x": 0, "y": 0})).unwrap()["id"]).unwrap();
+    if let NodeKind::Text(t) = &mut s.doc_mut().unwrap().get_mut(id).unwrap().kind {
+        t.style.font_family = family.into();
+    }
+    id
+}
+
+fn families(s: &mut Session) -> Vec<(String, u64)> {
+    let r = s.execute("text.missingFonts", &json!({})).unwrap();
+    r["families"].as_array().unwrap().iter().map(|f| (f["family"].as_str().unwrap().to_string(), f["layers"].as_u64().unwrap())).collect()
+}
+
+/// An installed family (built in, or found by the system scan), if this machine has any.
+fn installed() -> Option<String> {
+    figcraft_text::scan_system_fonts();
+    figcraft_text::family_names().into_iter().next()
+}
+
+#[test]
+fn lists_families_of_layers_ranges_styles_and_variables_once_each() {
+    let mut s = Session::new();
+    text(&mut s, "FigCraft Missing A");
+    let b = text(&mut s, "figcraft missing a");
+    if let NodeKind::Text(t) = &mut s.doc_mut().unwrap().get_mut(b).unwrap().kind {
+        let style = TextStyle { font_family: "FigCraft Missing B".into(), ..t.style.clone() };
+        t.runs.push(StyleRun { start: 0, end: 3, style });
+    }
+    let doc = s.doc_mut().unwrap();
+    doc.styles.push(Style {
+        id: "S:1".into(),
+        name: "Heading".into(),
+        description: String::new(),
+        kind: StyleKind::Text { style: TextStyle { font_family: "FigCraft Missing C".into(), ..TextStyle::default() } },
+        bound: Default::default(),
+    });
+    s.execute("variable.createCollection", &json!({"name": "Type", "modes": ["Light", "Dark"]})).unwrap();
+    s.execute("variable.create", &json!({"collection": "Type", "name": "Family", "type": "string", "value": "FigCraft Missing D"})).unwrap();
+    s.execute("variable.set", &json!({"variable": "Family", "mode": "Dark", "value": "FigCraft Missing H"})).unwrap();
+    let var = s.doc().unwrap().variables.get("Family").unwrap().id.clone();
+    s.doc_mut().unwrap().get_mut(b).unwrap().bound.insert("fontFamily".into(), var);
+
+    assert_eq!(
+        families(&mut s),
+        vec![
+            ("FigCraft Missing A".to_string(), 2),
+            ("FigCraft Missing B".to_string(), 1),
+            ("FigCraft Missing C".to_string(), 0),
+            ("FigCraft Missing D".to_string(), 0),
+            ("FigCraft Missing H".to_string(), 0),
+        ]
+    );
+    assert!(s.ui_requests.iter().any(|r| r.kind == "dialog.missingFonts"));
+}
+
+#[test]
+fn installed_families_are_not_listed() {
+    let Some(family) = installed() else {
+        eprintln!("skipped: no fonts on this machine");
+        return;
+    };
+    let mut s = Session::new();
+    text(&mut s, &family);
+    text(&mut s, &family.to_uppercase());
+    text(&mut s, "FigCraft Missing E");
+    assert_eq!(families(&mut s), vec![("FigCraft Missing E".to_string(), 1)]);
+}
+
+#[test]
+fn a_family_found_only_by_the_system_scan_is_not_missing() {
+    figcraft_text::scan_system_fonts();
+    let embedded: Vec<String> = figcraft_text::CRAFT_FONTS.iter().map(|f| f.family.to_lowercase()).collect();
+    let Some(family) = figcraft_text::family_names().into_iter().find(|f| !embedded.contains(&f.to_lowercase())) else {
+        eprintln!("skipped: no system fonts on this machine");
+        return;
+    };
+    let mut s = Session::new();
+    text(&mut s, &family);
+    assert!(families(&mut s).is_empty(), "{family} is installed");
+}
+
+#[test]
+fn blank_families_and_aliases_are_handled() {
+    let mut s = Session::new();
+    text(&mut s, "  ");
+    s.execute("variable.createCollection", &json!({"name": "Type"})).unwrap();
+    s.execute("variable.create", &json!({"collection": "Type", "name": "Base", "type": "string", "value": "FigCraft Missing F"})).unwrap();
+    let base = s.doc().unwrap().variables.get("Base").unwrap().id.clone();
+    let t = text(&mut s, "FigCraft Missing G");
+    let doc = s.doc_mut().unwrap();
+    // A variable that only aliases another, and one aliasing itself.
+    let mut alias = doc.variables.get(&base).unwrap().clone();
+    alias.id = "V:alias".into();
+    alias.name = "Alias".into();
+    for v in alias.values.values_mut() {
+        *v = VariableValue::Alias(base.clone());
+    }
+    let mut cycle = alias.clone();
+    cycle.id = "V:cycle".into();
+    cycle.name = "Cycle".into();
+    for v in cycle.values.values_mut() {
+        *v = VariableValue::Alias("V:cycle".into());
+    }
+    doc.variables.variables.push(alias);
+    doc.variables.variables.push(cycle);
+    doc.get_mut(t).unwrap().bound.insert("fontFamily".into(), "V:alias".into());
+    let other = text(&mut s, "FigCraft Missing G");
+    s.doc_mut().unwrap().get_mut(other).unwrap().bound.insert("fontFamily".into(), "V:cycle".into());
+    // The bound layer takes the value its alias resolves to (bindings are applied after the next
+    // command); the cycle resolves to nothing.
+    let NodeKind::Text(bound) = &s.doc().unwrap().node(t).unwrap().kind else { panic!() };
+    assert_eq!(bound.style.font_family, "FigCraft Missing F");
+    assert_eq!(families(&mut s), vec![("FigCraft Missing F".to_string(), 1), ("FigCraft Missing G".to_string(), 1)]);
+}
+
+#[test]
+fn needs_an_open_document() {
+    let mut s = Session::empty();
+    assert!(s.execute("text.missingFonts", &json!({})).is_err());
+}
+
+/// Make `id`'s box stale, as if it was measured in another font: `dw` wider than its content.
+fn stale(s: &mut Session, id: figcraft_doc::NodeId, dw: f64) -> f64 {
+    let doc = s.doc_mut().unwrap();
+    let n = doc.get_mut(id).unwrap();
+    let want = figcraft_text::auto_size(n).unwrap().0;
+    n.width = want + dw;
+    doc.take_dirty();
+    want
+}
+
+/// The width of layer `id`.
+fn width(s: &Session, id: figcraft_doc::NodeId) -> f64 {
+    s.doc().unwrap().node(id).unwrap().width
+}
+
+/// The ids a refit reports.
+fn refitted(r: &Value) -> Vec<u64> {
+    r["refitted"].as_array().unwrap().iter().map(|v| v.as_u64().unwrap()).collect()
+}
+
+/// Stale boxes fit their text again, by family, by layer or everywhere; fixed boxes keep theirs.
+#[test]
+fn refit_measures_stale_text_boxes_again() {
+    let mut s = Session::new();
+    let a = text(&mut s, "FigCraft Refit A");
+    let b = text(&mut s, "FigCraft Refit B");
+    let fixed = text(&mut s, "FigCraft Refit A");
+    if let NodeKind::Text(t) = &mut s.doc_mut().unwrap().get_mut(fixed).unwrap().kind {
+        t.auto_resize = figcraft_doc::TextAutoResize::None;
+    }
+    s.execute("select.none", &json!({})).unwrap();
+    let want_a = stale(&mut s, a, -30.0);
+    let want_b = stale(&mut s, b, 25.0);
+    s.doc_mut().unwrap().get_mut(fixed).unwrap().width = 7.0;
+    s.doc_mut().unwrap().take_dirty();
+    // Only the families asked for.
+    let only_a = super::refit(s.doc_mut().unwrap(), None, Some(&["figcraft refit a".to_string()]));
+    assert_eq!(only_a, vec![a]);
+    assert_eq!(width(&s, a), want_a);
+    assert_eq!(width(&s, b), want_b + 25.0);
+    // Only the layers asked for, then everything; a fixed box keeps its size.
+    stale(&mut s, a, 12.0);
+    assert!(refitted(&s.execute("text.refit", &json!({"ids": [b]})).unwrap()) == vec![b.0]);
+    assert_eq!((width(&s, a), width(&s, b)), (want_a + 12.0, want_b));
+    assert!(refitted(&s.execute("text.refit", &json!({})).unwrap()) == vec![a.0]);
+    assert_eq!(width(&s, a), want_a);
+    assert_eq!(width(&s, fixed), 7.0);
+    // Nothing stale: nothing changes.
+    assert!(refitted(&s.execute("text.refit", &json!({})).unwrap()).is_empty());
+    assert!(s.execute("text.refit", &json!({"ids": ["nope"]})).is_err());
+    // An `ids` that isn't a list is refused, not taken as the whole document.
+    stale(&mut s, a, 9.0);
+    assert!(s.execute("text.refit", &json!({"ids": a.0.to_string()})).is_err());
+    assert_eq!(width(&s, a), want_a + 9.0);
+    assert!(Session::empty().execute("text.refit", &json!({})).is_err());
+}
+
+/// Text inside an instance is refitted too.
+#[test]
+fn refit_reaches_text_in_instances() {
+    let mut s = Session::new();
+    let t = text(&mut s, "FigCraft Refit C");
+    let comp = id_of(&s.execute("component.create", &json!({"ids": [t]})).unwrap()["id"]).unwrap();
+    let inst = id_of(&s.execute("instance.create", &json!({"component": comp, "x": 300, "y": 0})).unwrap()["id"]).unwrap();
+    let copy = s.doc().unwrap().node(inst).unwrap().children[0];
+    let want = stale(&mut s, copy, -20.0);
+    let r = s.execute("text.refit", &json!({"ids": [inst]})).unwrap();
+    assert_eq!(refitted(&r), vec![copy.0]);
+    assert_eq!(width(&s, copy), want);
+}
+
+/// `text.loadFont` refuses what isn't a font file; `text.rescanFonts` reports what it added.
+#[test]
+fn fonts_load_from_files_and_rescans_report_new_families() {
+    let mut s = Session::new();
+    assert!(s.execute("text.loadFont", &json!({})).is_err());
+    assert!(s.execute("text.loadFont", &json!({"data": "bm90IGEgZm9udA=="})).is_err(), "not a font file");
+    assert!(s.execute("text.loadFont", &json!({"data": "%%%"})).is_err());
+    assert!(s.execute("text.loadFont", &json!({"path": "no-such-dir/x.ttf"})).is_err());
+    if let Some(f) = figcraft_text::CRAFT_FONTS.first() {
+        use base64::Engine as _;
+        let data = base64::engine::general_purpose::STANDARD.encode(f.bytes);
+        let r = s.execute("text.loadFont", &json!({"data": data})).unwrap();
+        assert_eq!(r["families"].as_array().map(Vec::len), Some(1));
+    }
+    let r = s.execute("text.rescanFonts", &json!({})).unwrap();
+    assert!(r["added"].is_array());
+}
diff --git a/crates/engine/src/frame_label_tests.rs b/crates/engine/src/frame_label_tests.rs
index 8e9ede7ba..3da9522fc 100644
--- a/crates/engine/src/frame_label_tests.rs
+++ b/crates/engine/src/frame_label_tests.rs
@@ -1,6 +1,7 @@
 //! Frame name labels as pointer targets: a press on a label (its area as the canvas drew it,
 //! turned with a rotated frame) selects the frame and drags it in one undo step, hovering it
-//! highlights the frame, and labels of locked, hidden, deleted or other pages' frames do nothing.
+//! highlights the frame, a double-click asks the UI to rename it there, and labels of locked,
+//! hidden, deleted or other pages' frames do nothing.
 
 use figcraft_doc::NodeId;
 use figcraft_geom::Point;
@@ -90,3 +91,24 @@ fn labels_of_frames_that_cant_be_picked_do_nothing() {
     let flat = [Point::new(1.0, 1.0); 4];
     assert_eq!(label_at(s.doc().unwrap(), page, &[(f, nan), (f, flat)], Point::new(1.0, 1.0)), None);
 }
+
+#[test]
+fn double_clicking_a_label_asks_to_rename_its_frame() {
+    let (mut s, f, q) = setup();
+    let c = center(&q);
+    let before = s.doc().unwrap().world_bounds(f).unwrap();
+    let undo = s.ds().unwrap().history.undo.len();
+    for kind in [PointerKind::Down, PointerKind::Up, PointerKind::Down, PointerKind::DoubleClick] {
+        s.pointer(&ev(kind, c)).unwrap();
+    }
+    assert_eq!(s.selection(), vec![f]);
+    let asked = s.ui_requests.iter().find(|r| r.kind == "canvas.renameLabel").map(|r| id_of(&r.data["id"]));
+    assert_eq!(asked, Some(Some(f)), "the UI renames the frame at its label");
+    assert_eq!(s.doc().unwrap().world_bounds(f), Some(before), "not moved");
+    assert_eq!(s.ds().unwrap().history.undo.len(), undo, "nothing to undo yet");
+    // Other tools ignore the label.
+    s.ui_requests.clear();
+    s.set_tool(crate::tools::ToolId::Hand);
+    s.pointer(&ev(PointerKind::DoubleClick, c)).unwrap();
+    assert!(s.ui_requests.iter().all(|r| r.kind != "canvas.renameLabel"));
+}
diff --git a/crates/engine/src/fx_behaviour_tests.rs b/crates/engine/src/fx_behaviour_tests.rs
index eb8da9b24..d9d93592d 100644
--- a/crates/engine/src/fx_behaviour_tests.rs
+++ b/crates/engine/src/fx_behaviour_tests.rs
@@ -53,6 +53,29 @@ fn the_eyedropper_picks_the_colour_seen_and_fills_the_selection() {
     assert_eq!(s.doc().unwrap().node(b).unwrap().fills[0].solid_color().map(|c| c.to_hex()), Some("00FF00".into()));
 }
 
+#[test]
+fn the_eyedropper_of_a_colour_picker_samples_without_filling() {
+    // Opened from a colour picker (`apply: false`), the eyedropper hands the colour to the picker,
+    // which writes it to its own paint (a stroke, an effect...): the fill stays as it was.
+    let mut s = Session::new();
+    s.execute("page.setBackground", &json!({"color": "#FFFFFF"})).unwrap();
+    rect(&mut s, None, (0.0, 0.0, 100.0, 100.0), "#FF0000");
+    let b = rect(&mut s, None, (200.0, 0.0, 50.0, 50.0), "#00FF00");
+    s.execute("select.set", &json!({"ids": [b]})).unwrap();
+    let undo = s.undo_depth().0;
+    s.execute("edit.pickColor", &json!({"apply": false})).unwrap();
+    s.pointer(&PointerEvent::at(PointerKind::Down, 50.0, 50.0, 1.0)).unwrap();
+    assert_eq!(s.doc().unwrap().node(b).unwrap().fills[0].solid_color().map(|c| c.to_hex()), Some("00FF00".into()));
+    assert_eq!(s.undo_depth().0, undo, "nothing to undo");
+    assert_eq!(s.tool.picked.take().map(|c| c.to_hex()), Some("FF0000".into()));
+    assert_eq!(s.tool.tool, ToolId::Move, "picking ends the eyedropper");
+    // The I key's eyedropper fills the selection again.
+    s.execute("edit.pickColor", &json!({})).unwrap();
+    s.pointer(&PointerEvent::at(PointerKind::Down, 50.0, 50.0, 1.0)).unwrap();
+    assert_eq!(s.doc().unwrap().node(b).unwrap().fills[0].solid_color().map(|c| c.to_hex()), Some("FF0000".into()));
+    assert_eq!(s.tool.picked, None);
+}
+
 #[test]
 fn blend_modes_and_effects_through_commands() {
     let mut s = Session::new();
diff --git a/crates/engine/src/huge_stroke_tests.rs b/crates/engine/src/huge_stroke_tests.rs
new file mode 100644
index 000000000..7efabb484
--- /dev/null
+++ b/crates/engine/src/huge_stroke_tests.rs
@@ -0,0 +1,28 @@
+//! An absurd stroke weight must not take the renderer down with it: saving (thumbnail) and exporting still work.
+
+use serde_json::{Value, json};
+
+use crate::Session;
+use crate::params::id_of;
+use figcraft_doc::NodeId;
+
+fn id(v: Value) -> NodeId {
+    id_of(&v["id"]).unwrap()
+}
+
+#[test]
+fn huge_stroke_weight_with_round_caps_still_saves_and_exports() {
+    for weight in [1e6, 1e7, 1e10, 1e30] {
+        let mut s = Session::new();
+        let f = id(s.execute("frame.create", &json!({"x": 0, "y": 0, "width": 100, "height": 100})).unwrap());
+        let v = id(s.execute("vector.create", &json!({"parent": f, "path": "M0 0.8333 L7.5 6.25 L15 0.8333"})).unwrap());
+        s.execute("node.set", &json!({"id": v, "props": {"stroke": "#ff0000", "strokeWeight": weight, "strokeCap": "round", "strokeJoin": "round"}}))
+            .unwrap();
+        let path = std::env::temp_dir().join(format!("figcraft-huge-stroke-{}-{weight}.figcraft", std::process::id()));
+        let saved = s.execute("file.saveAs", &json!({"path": path.to_string_lossy()}));
+        let _ = std::fs::remove_file(&path);
+        assert!(saved.is_ok(), "saveAs at weight {weight}: {:?}", saved.err());
+        let exported = s.execute("file.export", &json!({"ids": [f], "format": "png"}));
+        assert!(exported.is_ok(), "export at weight {weight}: {:?}", exported.err());
+    }
+}
diff --git a/crates/engine/src/id_params_behaviour_tests.rs b/crates/engine/src/id_params_behaviour_tests.rs
new file mode 100644
index 000000000..c5207b44e
--- /dev/null
+++ b/crates/engine/src/id_params_behaviour_tests.rs
@@ -0,0 +1,161 @@
+//! Layer ids in params: naming something that isn't a layer is a mistake, and says so, rather than
+//! quietly meaning "none".
+//!
+//! `node.create`'s `parent` was `id(p, "parent").unwrap_or(page)`, so any value that isn't an id —
+//! a `{"$step": n}` nothing had resolved, a name, a negative number — became "no parent" and the
+//! layer landed on the page while the call reported success. The same shape sat on `image.place`
+//! and `instance.create`'s parents, on `index`, and on the `ids` of every command that targets
+//! layers (an entry that wasn't an id was dropped and the rest ran).
+
+use crate::params::id_of;
+use crate::{EngineError, Session};
+use figcraft_doc::*;
+use serde_json::{Value, json};
+
+/// The page's children, by name (bottom first).
+fn top(s: &Session) -> Vec<String> {
+    let doc = s.doc().unwrap();
+    let page = s.page().unwrap();
+    doc.node(page).unwrap().children.iter().filter_map(|c| doc.node(*c).map(|n| n.name.clone())).collect()
+}
+
+/// The message of a failure, or `None` when the call went through.
+fn failed(r: std::result::Result<Value, EngineError>) -> Option<String> {
+    match r {
+        Ok(_) => None,
+        Err(e) => Some(e.to_string()),
+    }
+}
+
+fn rect(parent: Value) -> Value {
+    json!({"type": "rectangle", "name": "child", "parent": parent, "x": 0, "y": 0, "width": 10, "height": 10})
+}
+
+fn card(s: &mut Session) -> NodeId {
+    let v = s.execute("node.create", &json!({"type": "frame", "name": "Card", "x": 0, "y": 0, "width": 100, "height": 100})).unwrap();
+    id_of(&v["id"]).unwrap()
+}
+
+#[test]
+fn a_parent_that_is_not_an_id_is_refused_rather_than_becoming_the_page() {
+    let mut s = Session::new();
+    let card = card(&mut s);
+    for parent in [json!({"$step": 0}), json!("Card"), json!(-1), json!(true)] {
+        let msg = failed(s.execute("node.create", &rect(parent.clone()))).unwrap_or_else(|| panic!("{parent} must be refused"));
+        assert!(msg.contains("`parent` must be a node id"), "{parent}: {msg}");
+    }
+    assert_eq!(top(&s), ["Card"], "nothing landed on the page");
+    let doc = s.doc().unwrap();
+    assert!(doc.node(card).unwrap().children.is_empty(), "nor inside the frame");
+}
+
+#[test]
+fn leaving_the_parent_out_or_null_still_means_the_page() {
+    let mut s = Session::new();
+    let card = card(&mut s);
+    for parent in [None, Some(json!(null))] {
+        let mut p = rect(json!(0));
+        match parent {
+            None => _ = p.as_object_mut().unwrap().remove("parent"),
+            Some(v) => p["parent"] = v,
+        }
+        s.execute("node.create", &p).unwrap();
+    }
+    assert_eq!(top(&s), ["Card", "child", "child"]);
+    let doc = s.doc().unwrap();
+    assert!(doc.node(card).unwrap().children.is_empty());
+}
+
+#[test]
+fn a_parent_id_that_names_nothing_is_still_reported() {
+    let mut s = Session::new();
+    card(&mut s);
+    let msg = failed(s.execute("node.create", &rect(json!(99999)))).unwrap_or_else(|| panic!("a missing layer must fail"));
+    assert!(msg.contains("no such node 99999"), "{msg}");
+}
+
+#[test]
+fn an_index_that_is_not_a_whole_non_negative_number_is_refused() {
+    let mut s = Session::new();
+    let card = card(&mut s);
+    // (A boolean is a number to `f64_of` — `true` reads as 1 — as for `x`, `width` and every
+    // other number, so it is deliberately not in this list.)
+    for index in [json!("last"), json!(1.5), json!(-1), json!(-0.5), json!(1e12)] {
+        let mut p = rect(json!(card));
+        p["index"] = index.clone();
+        let msg = failed(s.execute("node.create", &p)).unwrap_or_else(|| panic!("index {index} must be refused"));
+        assert!(msg.contains("`index`"), "{index}: {msg}");
+    }
+    let doc = s.doc().unwrap();
+    assert!(doc.node(card).unwrap().children.is_empty(), "nothing was inserted");
+}
+
+#[test]
+fn a_whole_index_still_inserts_where_it_says() {
+    let mut s = Session::new();
+    let card = card(&mut s);
+    for name in ["a", "b"] {
+        s.execute("node.create", &json!({"type": "rectangle", "name": name, "parent": card, "x": 0, "y": 0, "width": 10, "height": 10})).unwrap();
+    }
+    s.execute("node.create", &json!({"type": "rectangle", "name": "mid", "parent": card, "index": 1, "x": 0, "y": 0, "width": 10, "height": 10}))
+        .unwrap();
+    let doc = s.doc().unwrap();
+    let names: Vec<&str> = doc.node(card).unwrap().children.iter().filter_map(|c| doc.node(*c).map(|n| n.name.as_str())).collect();
+    assert_eq!(names, ["a", "mid", "b"]);
+}
+
+#[test]
+fn ids_entries_that_are_not_ids_are_refused_instead_of_being_dropped() {
+    let mut s = Session::new();
+    let card = card(&mut s);
+    // The junk used to be dropped and the rest applied, so `["nope", card]` renamed the frame.
+    for ids in [json!(["nope"]), json!(["nope", card]), json!([{"$step": 0}, card]), json!([null])] {
+        let msg =
+            failed(s.execute("node.set", &json!({"ids": ids, "props": {"name": "renamed"}}))).unwrap_or_else(|| panic!("{ids} must be refused"));
+        assert!(msg.contains("`ids`"), "{ids}: {msg}");
+    }
+    let doc = s.doc().unwrap();
+    assert_eq!(doc.node(card).unwrap().name, "Card", "nothing was renamed");
+}
+
+#[test]
+fn an_ids_that_is_not_an_array_is_refused_but_null_means_the_selection() {
+    let mut s = Session::new();
+    let card = card(&mut s);
+    let msg =
+        failed(s.execute("node.set", &json!({"ids": "nope", "props": {"name": "renamed"}}))).unwrap_or_else(|| panic!("a non-array ids must fail"));
+    assert!(msg.contains("`ids` must be an array"), "{msg}");
+    // An explicit null says the same as leaving it out: the selection.
+    s.execute("select.set", &json!({"ids": [card]})).unwrap();
+    s.execute("node.set", &json!({"ids": null, "props": {"name": "Selected"}})).unwrap();
+    assert_eq!(s.doc().unwrap().node(card).unwrap().name, "Selected");
+}
+
+#[test]
+fn a_single_id_that_is_not_an_id_is_refused() {
+    let mut s = Session::new();
+    card(&mut s);
+    let msg =
+        failed(s.execute("node.set", &json!({"id": {"$step": 0}, "props": {"name": "renamed"}}))).unwrap_or_else(|| panic!("a bad id must fail"));
+    assert!(msg.contains("`id` must be a node id"), "{msg}");
+}
+
+#[test]
+fn an_image_and_an_instance_parent_are_checked_the_same_way() {
+    let mut s = Session::new();
+    card(&mut s);
+    let img = failed(s.execute("image.place", &json!({"data": "aGk=", "parent": {"$step": 0}})));
+    assert!(img.unwrap_or_default().contains("`parent` must be a node id"), "image.place");
+    let inst = failed(s.execute("instance.create", &json!({"component": 99999, "parent": {"$step": 0}})));
+    assert!(inst.is_some(), "instance.create refuses both a bad component and a bad parent");
+}
+
+#[test]
+fn a_huge_bad_value_is_cut_short_in_the_error() {
+    let mut s = Session::new();
+    card(&mut s);
+    let junk = "é".repeat(10_000);
+    let msg = failed(s.execute("node.set", &json!({"ids": junk, "props": {"name": "renamed"}}))).unwrap_or_else(|| panic!("must fail"));
+    assert!(msg.contains("`ids` must be an array") && msg.ends_with("…)"), "{msg}");
+    assert!(msg.chars().count() < 200, "{} chars", msg.chars().count());
+}
diff --git a/crates/engine/src/import_journal_tests.rs b/crates/engine/src/import_journal_tests.rs
new file mode 100644
index 000000000..f8fa84efc
--- /dev/null
+++ b/crates/engine/src/import_journal_tests.rs
@@ -0,0 +1,51 @@
+//! Imported file bytes already live in the document: the command log keeps no second copy.
+
+use base64::Engine as _;
+use serde_json::{Value, json};
+
+use crate::Session;
+
+const SVG: &str = r##"<svg xmlns="http://www.w3.org/2000/svg" width="40" height="20"><rect width="40" height="20" fill="#3366cc"/></svg>"##;
+
+fn payload() -> String {
+    base64::engine::general_purpose::STANDARD.encode(SVG)
+}
+
+fn holds_payload(journal: &[(String, Value)]) -> bool {
+    let payload = payload();
+    journal.iter().any(|(_, params)| params.to_string().contains(&payload))
+}
+
+#[test]
+fn byte_imports_keep_no_payload_in_the_journal() {
+    let mut s = Session::new();
+    let before = s.doc().unwrap().node_count();
+    s.execute("file.import", &json!({"data": payload(), "name": "pasted.svg"})).unwrap();
+    assert!(!holds_payload(&s.journal), "the journal must not retain the Base64 file");
+    // Not journaling is no change to the edit itself: still one undo step.
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(s.doc().unwrap().node_count(), before);
+}
+
+#[test]
+fn batch_wrappers_do_not_retain_import_payloads() {
+    let mut s = Session::new();
+    let nested =
+        json!({"command": "command.batch", "params": {"commands": [{"command": "file.import", "params": {"data": payload(), "name": "a.svg"}}]}});
+    s.execute("command.batch", &json!({"commands": [nested]})).unwrap();
+    assert!(!holds_payload(&s.journal));
+}
+
+#[test]
+fn path_imports_and_ordinary_edits_are_still_journaled() {
+    let dir = std::env::temp_dir().join(format!("figcraft-import-journal-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("kit.svg");
+    std::fs::write(&path, SVG).unwrap();
+    let mut s = Session::new();
+    s.execute("file.import", &json!({"path": path.to_string_lossy()})).unwrap();
+    s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 10, "height": 10})).unwrap();
+    let ids: Vec<_> = s.journal.iter().map(|(id, _)| id.as_str()).collect();
+    assert_eq!(ids, ["file.import", "shape.rectangle"]);
+    std::fs::remove_dir_all(&dir).ok();
+}
diff --git a/crates/engine/src/inspect.rs b/crates/engine/src/inspect.rs
index 1f461c60a..d30f5f511 100644
--- a/crates/engine/src/inspect.rs
+++ b/crates/engine/src/inspect.rs
@@ -135,6 +135,9 @@ pub fn node_json(doc: &Document, id: NodeId, depth: usize) -> Value {
         if !n.exports.is_empty() {
             o.insert("exports".into(), serde_json::to_value(&n.exports).unwrap_or(Value::Null));
         }
+        if let Some(b) = &n.board {
+            o.insert("board".into(), serde_json::to_value(b).unwrap_or(Value::Null));
+        }
         if !n.annotations.is_empty() {
             o.insert("annotations".into(), serde_json::to_value(&n.annotations).unwrap_or(Value::Null));
         }
@@ -165,6 +168,10 @@ pub fn node_json(doc: &Document, id: NodeId, depth: usize) -> Value {
             o.insert("operandOperation".into(), json!(op));
         }
     }
+    // Layer data written with `node.set {props: {pluginData}}` (pages too).
+    if !n.plugin_data.is_empty() {
+        o.insert("pluginData".into(), json!(n.plugin_data));
+    }
     match &n.kind {
         NodeKind::Text(t) => {
             o.insert("characters".into(), json!(t.characters));
@@ -191,7 +198,7 @@ pub fn node_json(doc: &Document, id: NodeId, depth: usize) -> Value {
                 o.insert("textDecorationSkipInk".into(), json!(l.skip_ink));
                 o.insert("textDecorationColor".into(), l.color.map_or(json!("auto"), |c| json!(format!("#{}", c.to_hex()))));
             }
-            // Lists: one style for the layer, or each paragraph's type and nesting level.
+            // Lists: one style for the layer, or each paragraph's type, nesting level and start.
             if t.paragraphs.is_empty() {
                 if t.list != figcraft_doc::ListStyle::None {
                     o.insert("listStyle".into(), json!(t.list));
@@ -199,6 +206,9 @@ pub fn node_json(doc: &Document, id: NodeId, depth: usize) -> Value {
             } else {
                 o.insert("lineTypes".into(), t.paragraphs.iter().map(|p| json!(p.list)).collect());
                 o.insert("lineIndentations".into(), t.paragraphs.iter().map(|p| json!(p.indent)).collect());
+                if t.paragraphs.iter().any(|p| p.start_offset > 0) {
+                    o.insert("listStartOffsets".into(), t.paragraphs.iter().map(|p| json!(p.start_offset)).collect());
+                }
             }
             if t.list_spacing != 0.0 {
                 o.insert("listSpacing".into(), json!(t.list_spacing));
@@ -305,6 +315,7 @@ pub fn document(s: &Session, depth: usize, all_pages: bool) -> Value {
         doc.pages.iter().map(|p| if all_pages || *p == ds.page { node_json(doc, *p, depth) } else { node_json(doc, *p, 0) }).collect();
     json!({
         "name": doc.name,
+        "kind": doc.kind.id(),
         "path": ds.path,
         "dirty": ds.is_dirty(),
         "currentPage": ds.page,
diff --git a/crates/engine/src/inspect_behaviour_tests.rs b/crates/engine/src/inspect_behaviour_tests.rs
index a52cac86f..c4bcc6be6 100644
--- a/crates/engine/src/inspect_behaviour_tests.rs
+++ b/crates/engine/src/inspect_behaviour_tests.rs
@@ -214,6 +214,26 @@ fn css_for_common_layers() {
     }
 }
 
+/// Individual stroke sides are borders on those sides only: a header with a divider under it isn't
+/// boxed in, and a side bound to a variable names it.
+#[test]
+fn css_borders_follow_individual_stroke_sides() {
+    let mut s = Session::new();
+    let r = rect(&mut s, 0.0, 0.0, 100.0, 50.0, None);
+    set(&mut s, &[r], json!({"strokes": ["#000000"], "strokeWeight": 1, "strokeSides": [0, 0, 2, 0]}));
+    let c = css(&mut s, r);
+    assert!(c.contains("border-bottom: 2px solid #000000;"), "{c}");
+    assert!(!c.contains("border:") && !c.contains("border-top") && !c.contains("border-right") && !c.contains("border-left"), "{c}");
+
+    let col = ex(&mut s, "variable.createCollection", json!({"name": "Borders"}));
+    let col = col["id"].as_str().unwrap().to_string();
+    ex(&mut s, "variable.create", json!({"collection": col, "name": "border/top", "type": "number", "value": 3}));
+    ex(&mut s, "variable.bind", json!({"ids": [r], "field": "strokeTopWeight", "variable": "border/top"}));
+    let c = css(&mut s, r);
+    assert!(c.contains("border-top: var(--border-top, 3px) solid #000000;"), "{c}");
+    assert!(c.contains("border-bottom: 2px solid #000000;"), "{c}");
+}
+
 #[test]
 fn native_code_for_a_simple_layer() {
     let mut s = Session::new();
diff --git a/crates/engine/src/instance_modes_tests.rs b/crates/engine/src/instance_modes_tests.rs
new file mode 100644
index 000000000..43de3ca47
--- /dev/null
+++ b/crates/engine/src/instance_modes_tests.rs
@@ -0,0 +1,196 @@
+//! Variable modes on instances: an instance is on the modes its main component sets, under the
+//! ones set on the instance itself, so switching variants or changing the main's mode reaches it.
+
+use serde_json::{Value, json};
+
+use crate::Session;
+use crate::params::id_of;
+use figcraft_doc::NodeId;
+
+fn run(s: &mut Session, cmd: &str, p: Value) -> Value {
+    s.execute(cmd, &p).unwrap_or_else(|e| panic!("{cmd} {p}: {e}"))
+}
+
+fn id(v: Value) -> NodeId {
+    id_of(&v["id"]).unwrap()
+}
+
+fn fill(s: &Session, n: NodeId) -> String {
+    s.doc().unwrap().node(n).unwrap().fills.first().and_then(|p| p.solid_color()).map(|c| c.to_hex()).unwrap_or_default()
+}
+
+fn set_mode(s: &mut Session, n: NodeId, mode: Value) {
+    run(s, "variable.setMode", json!({"ids": [n], "collection": "Tone", "mode": mode}));
+}
+
+/// A "Tone" collection whose variable `c` is red in mode A and blue in mode B.
+fn tone(s: &mut Session) {
+    run(s, "variable.createCollection", json!({"name": "Tone", "modes": ["A", "B"]}));
+    run(s, "variable.create", json!({"collection": "Tone", "name": "c", "type": "color", "values": {"A": "#FF0000", "B": "#0000FF"}}));
+}
+
+/// A component filled from `c`, on `mode` when one is given.
+fn swatch(s: &mut Session, name: &str, mode: Option<&str>) -> NodeId {
+    let f = id(run(s, "frame.create", json!({"x": 0, "y": 0, "width": 40, "height": 40, "name": name})));
+    run(s, "variable.bind", json!({"ids": [f], "field": "fill", "variable": "c"}));
+    if let Some(m) = mode {
+        set_mode(s, f, json!(m));
+    }
+    id(run(s, "component.create", json!({"ids": [f]})))
+}
+
+/// A set "Kind" whose variants A and B each set their own Tone mode.
+fn kinds(s: &mut Session) -> (NodeId, NodeId) {
+    tone(s);
+    let a = swatch(s, "Kind=A", Some("A"));
+    let b = swatch(s, "Kind=B", Some("B"));
+    let set = id(run(s, "component.combineVariants", json!({"ids": [a, b]})));
+    (set, b)
+}
+
+fn instance(s: &mut Session, component: NodeId) -> NodeId {
+    id(run(s, "instance.create", json!({"component": component, "x": 200, "y": 0})))
+}
+
+fn switch(s: &mut Session, i: NodeId, kind: &str) {
+    run(s, "instance.setProperties", json!({"ids": [i], "properties": {"Kind": kind}}));
+}
+
+#[test]
+fn switching_variants_takes_the_new_variants_mode() {
+    let mut s = Session::new();
+    let (set, _) = kinds(&mut s);
+    let i = instance(&mut s, set);
+    assert_eq!(fill(&s, i), "FF0000");
+    switch(&mut s, i, "B");
+    assert_eq!(fill(&s, i), "0000FF", "variant B sets mode B");
+    switch(&mut s, i, "A");
+    assert_eq!(fill(&s, i), "FF0000");
+    assert!(s.doc().unwrap().node(i).unwrap().var_modes.is_empty(), "the instance sets no mode of its own");
+}
+
+#[test]
+fn instances_follow_a_mode_their_main_sets_later() {
+    let mut s = Session::new();
+    tone(&mut s);
+    let main = swatch(&mut s, "Chip", None);
+    let i = instance(&mut s, main);
+    assert_eq!(fill(&s, i), "FF0000", "no mode set: the collection's default");
+    set_mode(&mut s, main, json!("B"));
+    assert_eq!(fill(&s, i), "0000FF");
+    set_mode(&mut s, main, Value::Null);
+    assert_eq!(fill(&s, i), "FF0000", "the main back on Auto");
+}
+
+#[test]
+fn a_mode_set_on_the_instance_wins_and_stays_through_variant_switches() {
+    let mut s = Session::new();
+    let (set, _) = kinds(&mut s);
+    let i = instance(&mut s, set);
+    set_mode(&mut s, i, json!("B"));
+    assert_eq!(fill(&s, i), "0000FF");
+    for kind in ["B", "A"] {
+        switch(&mut s, i, kind);
+        assert_eq!(fill(&s, i), "0000FF", "own mode B on variant {kind}");
+    }
+    set_mode(&mut s, i, Value::Null);
+    assert_eq!(fill(&s, i), "FF0000", "back on Auto: variant A's mode");
+}
+
+#[test]
+fn a_main_mode_is_closer_than_the_frame_around_the_instance() {
+    let mut s = Session::new();
+    let (_, b) = kinds(&mut s);
+    let frame = id(run(&mut s, "frame.create", json!({"x": 0, "y": 300, "width": 200, "height": 100})));
+    set_mode(&mut s, frame, json!("A"));
+    let i = id(run(&mut s, "instance.create", json!({"component": b, "x": 10, "y": 10, "parent": frame})));
+    assert_eq!(fill(&s, i), "0000FF", "the main's mode B, not the frame's A");
+    // Nested: an outer component on mode A holding an instance of B.
+    let outer_frame = id(run(&mut s, "frame.create", json!({"x": 0, "y": 500, "width": 100, "height": 100, "name": "Outer"})));
+    run(&mut s, "instance.create", json!({"component": b, "x": 0, "y": 0, "parent": outer_frame}));
+    set_mode(&mut s, outer_frame, json!("A"));
+    let outer = id(run(&mut s, "component.create", json!({"ids": [outer_frame]})));
+    let copy = instance(&mut s, outer);
+    let nested = s.doc().unwrap().node(copy).unwrap().children[0];
+    assert_eq!(fill(&s, nested), "0000FF");
+}
+
+#[test]
+fn detaching_keeps_the_mode_it_took_from_its_main() {
+    let mut s = Session::new();
+    let (set, b) = kinds(&mut s);
+    let i = instance(&mut s, set);
+    switch(&mut s, i, "B");
+    run(&mut s, "component.detach", json!({"ids": [i]}));
+    set_mode(&mut s, b, json!("A"));
+    assert_eq!(fill(&s, i), "0000FF", "the detached frame keeps mode B");
+    assert_eq!(s.doc().unwrap().node(i).unwrap().var_modes.len(), 1);
+}
+
+/// A "Button" holding an instance of a swatch "Icon" on mode A, and a "Modal" holding a Button
+/// instance whose icon copy was set to mode B: (the Button main, its icon layer, the copy in Modal).
+fn modal(s: &mut Session) -> (NodeId, NodeId, NodeId) {
+    tone(s);
+    let icon = swatch(s, "Icon", None);
+    let frame = id(run(s, "frame.create", json!({"x": 100, "y": 0, "width": 60, "height": 40, "name": "Button"})));
+    let button_icon = id(run(s, "instance.create", json!({"component": icon, "x": 10, "y": 10, "parent": frame})));
+    set_mode(s, button_icon, json!("A"));
+    let button = id(run(s, "component.create", json!({"ids": [frame]})));
+    let outer = id(run(s, "frame.create", json!({"x": 300, "y": 0, "width": 200, "height": 100, "name": "Modal"})));
+    let close = id(run(s, "instance.create", json!({"component": button, "x": 10, "y": 10, "parent": outer})));
+    let nested = s.doc().unwrap().node(close).unwrap().children[0];
+    set_mode(s, nested, json!("B"));
+    run(s, "component.create", json!({"ids": [outer]}));
+    (button, button_icon, nested)
+}
+
+#[test]
+fn a_mode_set_on_a_layer_inside_an_instance_is_an_override() {
+    let mut s = Session::new();
+    let (button, button_icon, nested) = modal(&mut s);
+    assert_eq!(fill(&s, nested), "0000FF");
+    // An edit the copies can't take as they are rebuilds the Button instance.
+    run(&mut s, "node.set", json!({"ids": [button], "layout": "horizontal"}));
+    assert_eq!(fill(&s, nested), "0000FF", "a rebuild keeps the mode set on the copy");
+    // The main's layer choosing another mode doesn't reach it either.
+    set_mode(&mut s, button_icon, json!("B"));
+    set_mode(&mut s, button_icon, Value::Null);
+    assert_eq!(fill(&s, nested), "0000FF");
+    run(&mut s, "component.resetOverride", json!({"id": nested, "group": "modes"}));
+    assert_eq!(fill(&s, nested), "FF0000", "reset: the main's layer is on Auto (mode A)");
+    assert!(s.doc().unwrap().node(nested).unwrap().var_modes.is_empty());
+}
+
+#[test]
+fn a_mode_set_on_an_icon_inside_a_placed_instance_survives_main_edits() {
+    let mut s = Session::new();
+    let (button, _, _) = modal(&mut s);
+    // A Button placed on the page, its icon recoloured through the icon's mode.
+    let placed = instance(&mut s, button);
+    let icon = s.doc().unwrap().node(placed).unwrap().children[0];
+    set_mode(&mut s, icon, json!("B"));
+    assert!(s.doc().unwrap().node(icon).unwrap().overrides.contains("modes"), "it shows as an override");
+    run(&mut s, "node.set", json!({"ids": [button], "layout": "vertical"}));
+    assert_eq!(fill(&s, icon), "0000FF", "a rebuild of the Button keeps it");
+    run(&mut s, "component.resetInstance", json!({"ids": [placed]}));
+    assert_eq!(fill(&s, icon), "FF0000", "reset all brings back the main's mode");
+}
+
+#[test]
+fn a_file_from_before_modes_were_overrides_keeps_the_modes_chosen_inside_its_instances() {
+    let mut s = Session::new();
+    let (button, _, nested) = modal(&mut s);
+    // Saved before `modes` was an override group: the copy has its mode but no marker.
+    s.doc_mut().unwrap().node_mut(nested).unwrap().overrides.remove("modes");
+    let path = std::env::temp_dir().join(format!("figcraft-instance-modes-{}.figcraft", std::process::id()));
+    let p = path.to_string_lossy().into_owned();
+    run(&mut s, "file.saveAs", json!({"path": p}));
+    let mut s = Session::new();
+    run(&mut s, "file.open", json!({"path": p}));
+    let _ = std::fs::remove_file(&path);
+    let doc = s.doc().unwrap();
+    assert!(doc.node(nested).unwrap().overrides.contains("modes"), "opening it marks the mode the copy chose");
+    assert!(doc.nodes().filter(|n| n.id != nested).all(|n| !n.overrides.contains("modes")), "layers on their main's modes stay unmarked");
+    run(&mut s, "node.set", json!({"ids": [button], "layout": "horizontal"}));
+    assert_eq!(fill(&s, nested), "0000FF", "a rebuild keeps it");
+}
diff --git a/crates/engine/src/instance_resizing_tests.rs b/crates/engine/src/instance_resizing_tests.rs
new file mode 100644
index 000000000..43386af96
--- /dev/null
+++ b/crates/engine/src/instance_resizing_tests.rs
@@ -0,0 +1,190 @@
+//! Size and resizing overrides of layers inside instances: a layer in an instance can hug, fill or
+//! keep a fixed size of its own, and that override is kept through relayout, edits of the main
+//! (only the overridden property stays), undo, save and reopen (native and .fig), REST import,
+//! detach and reset.
+
+use base64::Engine;
+use serde_json::{Value, json};
+
+use crate::Session;
+use crate::components::tests::{copy_of, ex, healthy, idv, node};
+use figcraft_doc::*;
+
+/// A "Field" component: a 240×40 fixed horizontal auto layout frame (no padding or gap) holding
+/// "Atom", an auto layout frame hugging its 20×20 "Dot" with a min width of 100; and an instance of
+/// it. Returns (component, atom, dot, instance).
+fn field(s: &mut Session) -> (NodeId, NodeId, NodeId, NodeId) {
+    let f = idv(&ex(s, "frame.create", json!({"x": 0, "y": 0, "width": 240, "height": 40, "name": "Field"})));
+    ex(s, "node.set", json!({"id": f, "props": {"layout": "horizontal", "padding": 0, "gap": 0, "sizingH": "fixed", "sizingV": "fixed"}}));
+    let atom = idv(&ex(s, "frame.create", json!({"x": 0, "y": 0, "width": 50, "height": 20, "parent": f, "name": "Atom"})));
+    ex(
+        s,
+        "node.set",
+        json!({"id": atom, "props": {"layout": "horizontal", "padding": 0, "gap": 0, "sizingH": "hug", "sizingV": "hug", "minWidth": 100}}),
+    );
+    let dot = idv(&ex(s, "shape.rectangle", json!({"x": 0, "y": 0, "width": 20, "height": 20, "parent": atom, "props": {"name": "Dot"}})));
+    let c = idv(&ex(s, "component.create", json!({"ids": [f]})));
+    let i = idv(&ex(s, "instance.create", json!({"component": c, "x": 0, "y": 100})));
+    (c, atom, dot, i)
+}
+
+fn sizing_h(s: &Session, id: NodeId) -> Sizing {
+    node(s, id).child_layout.sizing_h
+}
+
+/// The layer named `name` below instance `inst`.
+fn named(s: &Session, inst: NodeId, name: &str) -> NodeId {
+    let doc = s.doc().unwrap();
+    doc.subtree(inst).into_iter().find(|d| *d != inst && doc.node(*d).is_some_and(|n| n.name == name)).unwrap()
+}
+
+/// The first instance in the document.
+fn instance(s: &Session) -> NodeId {
+    s.doc().unwrap().nodes().find(|n| matches!(n.kind, NodeKind::Instance { .. })).unwrap().id
+}
+
+fn open(s: &mut Session, bytes: &[u8], name: &str) {
+    ex(s, "file.open", json!({"data": base64::engine::general_purpose::STANDARD.encode(bytes), "name": name}));
+}
+
+#[test]
+fn a_layer_in_an_instance_fills_and_keeps_it_through_main_edits() {
+    let mut s = Session::new();
+    let (c, atom, dot, i) = field(&mut s);
+    let (ia, idot) = (copy_of(&s, i, atom), copy_of(&s, i, dot));
+    assert_eq!((sizing_h(&s, ia), node(&s, ia).width), (Sizing::Hug, 100.0), "hugs its dot, at least 100 wide");
+    ex(&mut s, "node.set", json!({"id": ia, "props": {"sizingH": "fill"}}));
+    assert_eq!((sizing_h(&s, ia), node(&s, ia).width), (Sizing::Fill, 240.0), "fills the instance");
+    assert!(node(&s, ia).overrides.contains("resizing"), "{:?}", node(&s, ia).overrides);
+    // Edits of the main relay the instance out: the override stays, other properties follow.
+    ex(&mut s, "node.set", json!({"id": dot, "props": {"width": 30, "fill": "#ff0000"}}));
+    assert_eq!((node(&s, ia).width, node(&s, idot).width), (240.0, 30.0));
+    ex(&mut s, "node.set", json!({"id": atom, "props": {"minWidth": 120, "fill": "#00ff00"}}));
+    assert_eq!(node(&s, atom).width, 120.0);
+    assert_eq!((sizing_h(&s, ia), node(&s, ia).width, node(&s, ia).child_layout.min_w), (Sizing::Fill, 240.0, Some(100.0)));
+    assert_eq!(node(&s, ia).fills, node(&s, atom).fills, "the fill isn't overridden: it follows the main");
+    // The main fixing its own width is the same property: the instance keeps filling.
+    ex(&mut s, "node.set", json!({"id": atom, "props": {"width": 80}}));
+    assert_eq!((sizing_h(&s, atom), sizing_h(&s, ia), node(&s, ia).width), (Sizing::Fixed, Sizing::Fill, 240.0));
+    // A structure edit of the main rebuilds the instance: the atom fills what the new layer leaves.
+    ex(&mut s, "shape.rectangle", json!({"x": 0, "y": 0, "width": 5, "height": 5, "parent": c}));
+    assert_eq!((sizing_h(&s, ia), node(&s, ia).width), (Sizing::Fill, 235.0));
+    healthy(&s);
+    // Back to the main's resizing: no override left.
+    ex(&mut s, "component.resetOverride", json!({"id": ia, "group": "resizing"}));
+    assert_eq!((sizing_h(&s, ia), node(&s, ia).width), (Sizing::Fixed, node(&s, atom).width));
+    assert!(!node(&s, ia).overrides.contains("resizing"));
+    healthy(&s);
+}
+
+#[test]
+fn size_and_resizing_overrides_undo_reset_and_detach() {
+    let mut s = Session::new();
+    let (_, atom, dot, i) = field(&mut s);
+    let (ia, idot) = (copy_of(&s, i, atom), copy_of(&s, i, dot));
+    ex(&mut s, "node.set", json!({"id": ia, "props": {"sizingH": "fill"}}));
+    ex(&mut s, "edit.undo", json!({}));
+    assert_eq!((sizing_h(&s, ia), node(&s, ia).width), (Sizing::Hug, 100.0));
+    assert!(node(&s, ia).overrides.is_empty());
+    // A fixed size of its own: kept when the main resizes the layer.
+    ex(&mut s, "node.set", json!({"id": idot, "props": {"width": 50, "height": 10}}));
+    assert!(node(&s, idot).overrides.contains("size"));
+    ex(&mut s, "node.set", json!({"id": dot, "props": {"width": 30}}));
+    assert_eq!((node(&s, idot).width, node(&s, idot).height, node(&s, dot).width), (50.0, 10.0, 30.0));
+    // A min width of its own.
+    ex(&mut s, "node.set", json!({"id": ia, "props": {"minWidth": 150}}));
+    assert_eq!(node(&s, ia).width, 150.0);
+    ex(&mut s, "node.set", json!({"id": atom, "props": {"minWidth": 90}}));
+    assert_eq!(node(&s, ia).width, 150.0);
+    healthy(&s);
+    // Reset all changes: the main's values again.
+    ex(&mut s, "component.resetInstance", json!({"ids": [i]}));
+    assert_eq!((node(&s, ia).width, node(&s, idot).width), (90.0, 30.0));
+    assert!(node(&s, ia).overrides.is_empty() && node(&s, idot).overrides.is_empty());
+    // Detaching keeps what the instance showed.
+    ex(&mut s, "node.set", json!({"id": ia, "props": {"sizingH": "fill"}}));
+    ex(&mut s, "component.detach", json!({"ids": [i]}));
+    assert_eq!((sizing_h(&s, ia), node(&s, ia).width, node(&s, ia).source), (Sizing::Fill, 240.0, None));
+    healthy(&s);
+}
+
+#[test]
+fn layers_in_instances_resize_but_keep_their_place() {
+    let mut s = Session::new();
+    let f = idv(&ex(&mut s, "frame.create", json!({"x": 0, "y": 0, "width": 200, "height": 100, "name": "Card"})));
+    let title = idv(&ex(&mut s, "text.create", json!({"text": "Hello", "x": 10, "y": 10, "parent": f, "props": {"name": "Title"}})));
+    let c = idv(&ex(&mut s, "component.create", json!({"ids": [f]})));
+    let i = idv(&ex(&mut s, "instance.create", json!({"component": c, "x": 300, "y": 0})));
+    let it = copy_of(&s, i, title);
+    ex(&mut s, "node.set", json!({"id": it, "props": {"width": 150}}));
+    assert_eq!(node(&s, it).width, 150.0, "a text box resizes");
+    assert!(node(&s, it).overrides.contains("size"));
+    // Its place, rotation and constraints are still the main's.
+    for props in [json!({"x": 50}), json!({"rotation": 15}), json!({"constraints": {"horizontal": "right"}})] {
+        assert!(s.execute("node.set", &json!({"id": it, "props": props})).is_err(), "{props} is refused");
+    }
+    // The instance's own resizing is its own, not an override.
+    ex(&mut s, "node.set", json!({"id": i, "props": {"minWidth": 100}}));
+    assert!(!node(&s, i).overrides.contains("resizing"));
+    healthy(&s);
+}
+
+#[test]
+fn resizing_overrides_survive_save_and_reopen() {
+    let mut s = Session::new();
+    let (_, atom, dot, i) = field(&mut s);
+    let (ia, idot) = (copy_of(&s, i, atom), copy_of(&s, i, dot));
+    ex(&mut s, "node.set", json!({"id": ia, "props": {"sizingH": "fill"}}));
+    ex(&mut s, "node.set", json!({"id": idot, "props": {"width": 40}}));
+    let native = figcraft_format::save_bytes(s.doc().unwrap(), None).unwrap();
+    let (fig, _) = figcraft_format::fig::export(s.doc().unwrap(), None).unwrap();
+    for (bytes, name) in [(native, "field.figcraft"), (fig, "field.fig")] {
+        let mut s = Session::new();
+        open(&mut s, &bytes, name);
+        let i = instance(&s);
+        let (ia, idot) = (named(&s, i, "Atom"), named(&s, i, "Dot"));
+        assert!(node(&s, ia).overrides.contains("resizing"), "{name}: {:?}", node(&s, ia).overrides);
+        assert!(node(&s, idot).overrides.contains("size"), "{name}: {:?}", node(&s, idot).overrides);
+        // An edit of the main relays the instance out.
+        let main = |s: &Session, id: NodeId| node(s, id).source.unwrap();
+        let (atom, dot) = (main(&s, ia), main(&s, idot));
+        ex(&mut s, "node.set", json!({"id": atom, "props": {"minWidth": 120}}));
+        ex(&mut s, "node.set", json!({"id": dot, "props": {"width": 30}}));
+        assert_eq!((sizing_h(&s, ia), node(&s, ia).width, node(&s, idot).width), (Sizing::Fill, 240.0, 40.0), "{name}");
+        healthy(&s);
+    }
+}
+
+#[test]
+fn imported_resizing_overrides_survive_relayout() {
+    let at = |x: f64, y: f64| json!([[1, 0, x], [0, 1, y]]);
+    let dot = |id: &str| json!({"id": id, "name": "Dot", "type": "RECTANGLE", "relativeTransform": at(0.0, 0.0), "size": {"x": 20, "y": 20}});
+    let atom = |id: &str, dot_id: &str, w: f64, more: Value| {
+        let mut a = json!({"id": id, "name": "Atom", "type": "FRAME", "relativeTransform": at(0.0, 0.0), "size": {"x": w, "y": 20},
+            "layoutMode": "HORIZONTAL", "primaryAxisSizingMode": "AUTO", "counterAxisSizingMode": "AUTO", "minWidth": 100, "children": [dot(dot_id)]});
+        a.as_object_mut().unwrap().extend(more.as_object().unwrap().clone());
+        a
+    };
+    let field = |id: &str, ty: &str, y: f64, kids: Value| {
+        json!({"id": id, "name": "Field", "type": ty, "relativeTransform": at(0.0, y), "size": {"x": 240, "y": 40}, "layoutMode": "HORIZONTAL",
+            "primaryAxisSizingMode": "FIXED", "counterAxisSizingMode": "FIXED", "children": kids})
+    };
+    let mut inst =
+        field("2:1", "INSTANCE", 100.0, json!([atom("I2:1;1:2", "I2:1;1:3", 240.0, json!({"layoutSizingHorizontal": "FILL", "layoutGrow": 1}))]));
+    inst["componentId"] = json!("1:1");
+    inst["overrides"] = json!([{"id": "I2:1;1:2", "overriddenFields": ["layoutSizingHorizontal", "layoutGrow"]}]);
+    let file = json!({"name": "Field", "document": {"id": "0:0", "type": "DOCUMENT", "children": [
+        {"id": "0:1", "name": "Page", "type": "CANVAS", "children": [field("1:1", "COMPONENT", 0.0, json!([atom("1:2", "1:3", 100.0, json!({}))])), inst]}
+    ]}, "components": {"1:1": {"key": "k", "name": "Field", "description": ""}}, "styles": {}});
+    let mut s = Session::new();
+    open(&mut s, file.to_string().as_bytes(), "field.json");
+    let i = instance(&s);
+    let ia = named(&s, i, "Atom");
+    assert_eq!((sizing_h(&s, ia), node(&s, ia).width), (Sizing::Fill, 240.0));
+    assert!(node(&s, ia).overrides.contains("resizing"), "{:?}", node(&s, ia).overrides);
+    // The main's first edit relays every instance out from it.
+    let main_atom = node(&s, ia).source.unwrap();
+    ex(&mut s, "node.set", json!({"id": main_atom, "props": {"minWidth": 120}}));
+    assert_eq!((sizing_h(&s, ia), node(&s, ia).width), (Sizing::Fill, 240.0));
+    healthy(&s);
+}
diff --git a/crates/engine/src/keymap.rs b/crates/engine/src/keymap.rs
index c5e3c3346..6f0641db1 100644
--- a/crates/engine/src/keymap.rs
+++ b/crates/engine/src/keymap.rs
@@ -193,6 +193,15 @@ pub static KEYS: &[Binding] = &[
     k(Tools, "tool.text", &["T"]),
     k(Tools, "tool.comment", &["C"]),
     k(Tools, "tool.shapeBuilder", &["Shift+M"]),
+    // Board tools (on boards only), on keys nothing else uses.
+    k(Tools, "tool.sticky", &["Q"]),
+    k(Tools, "tool.shape", &["B"]),
+    k(Tools, "tool.connector", &["X"]),
+    k(Tools, "tool.marker", &["M"]),
+    k(Tools, "tool.highlighter", &["U"]),
+    k(Tools, "tool.eraser", &["E"]),
+    k(Tools, "tool.stamp", &["W"]),
+    k(Tools, "board.nextSticky", &["Shift+Cmd+Enter"]).label("Board: a new sticky beside the selected one").both(),
     // View
     // The documentation gives both keys for the pixel grid in different places.
     k(View, "view.pixelGrid", &["Shift+'", "Cmd+'"]),
@@ -220,8 +229,10 @@ pub static KEYS: &[Binding] = &[
     k(View, "view.prevPage", &["PageUp"]),
     k(View, "view.nextPage", &["PageDown"]),
     // Zoom
-    k(Zoom, "view.zoomIn", &["Cmd+=", "Shift+=", "Shift+Cmd+="]),
-    k(Zoom, "view.zoomOut", &["Cmd+-", "-", "Shift+-"]),
+    // Each zoom-in key has its zoom-out twin on the key beside it: `-` alone zooms out, so `=`
+    // alone (the `+` key without Shift) zooms in (#973).
+    k(Zoom, "view.zoomIn", &["Cmd+=", "Shift+=", "Shift+Cmd+=", "="]),
+    k(Zoom, "view.zoomOut", &["Cmd+-", "-", "Shift+-", "Shift+Cmd+-"]),
     k(Zoom, "view.zoom100", &["Shift+0", "Cmd+0"]),
     k(Zoom, "view.zoomFit", &["Shift+1"]),
     k(Zoom, "view.zoomSelection", &["Shift+2"]),
diff --git a/crates/engine/src/keymap_tests.rs b/crates/engine/src/keymap_tests.rs
index 38775d3b4..f624ecfbb 100644
--- a/crates/engine/src/keymap_tests.rs
+++ b/crates/engine/src/keymap_tests.rs
@@ -168,6 +168,25 @@ fn display_per_platform() {
     assert_eq!(primary("polygon.none", mac), None);
 }
 
+/// Each way of zooming in has its zoom-out twin on the key beside it, as the keys arrive from a US
+/// keyboard (#973: `-` alone zoomed out but `=` alone did nothing, so zooming back in was stuck).
+#[test]
+fn zoom_keys_come_in_pairs() {
+    let none = Mods::default();
+    let shift = mods(true, false, false, false);
+    let cmd = mods(false, false, true, false);
+    let shift_cmd = mods(true, false, true, false);
+    for p in PLATFORMS {
+        for (zoom_in, zoom_out, m) in [("Equals", "Minus", none), ("Equals", "Minus", cmd), ("Plus", "Minus", shift_cmd), ("Plus", "Minus", shift)] {
+            assert_eq!(id_for(p, Context::Canvas, zoom_in, m), Some("view.zoomIn"), "{zoom_in} {m:?} on {p:?}");
+            assert_eq!(id_for(p, Context::Canvas, zoom_out, m), Some("view.zoomOut"), "{zoom_out} {m:?} on {p:?}");
+        }
+        // The menus still show Cmd/Ctrl and `+`.
+        assert_eq!(primary("view.zoomIn", p), Some("Cmd+="));
+        assert_eq!(primary("view.zoomOut", p), Some("Cmd+-"));
+    }
+}
+
 #[test]
 fn tool_keys_come_from_the_keymap() {
     assert_eq!(ToolId::Move.shortcut(), "V");
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index 34653bd5f..2cd224e72 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -6,11 +6,14 @@
 //! change is one undo step. Pointer tools ([`tools`]) and text editing reduce to the same document
 //! edits and are journaled the same way.
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
+// Tests make and inspect files directly; shipped code goes through `file_access` (clippy.toml).
+#![cfg_attr(test, allow(clippy::disallowed_methods))]
 
 pub mod al_keys;
 pub mod annotations;
 pub mod arc_handles;
 pub mod background;
+pub mod board;
 pub mod booleans;
 pub mod branches;
 pub mod catalog;
@@ -24,7 +27,10 @@ pub mod dev_resources;
 pub mod devcompare;
 pub mod devinspect;
 pub mod distance;
+pub mod doc_urls;
 pub mod drop;
+pub mod file_access;
+pub mod fonts;
 pub mod guard;
 pub mod guides;
 pub mod inspect;
@@ -43,6 +49,9 @@ pub mod plugins;
 pub mod proto_run;
 pub mod rename;
 pub mod rotation_origin;
+pub mod selection_colors;
+pub mod selection_reorder;
+pub mod selection_spacing;
 pub mod shape_handles;
 pub mod shapebuilder;
 pub mod snap;
@@ -357,8 +366,8 @@ pub struct DocState {
     versions_changed: bool,
     /// A version shown in place of the document (read-only).
     pub preview: Option<VersionPreview>,
-    /// The document under a live text preview (a hovered text style or font instance, a dragged
-    /// axis slider): `doc` shows the preview until [`textpreview::end`] puts this back.
+    /// The document under a live text preview (a hovered font family or style, text style or
+    /// font instance, a dragged axis slider): `doc` shows the preview until [`textpreview::end`] puts this back.
     pub text_preview: Option<Arc<Document>>,
     /// The document as of the last version saved or restored (none yet): autosaves, restores and
     /// merges only add a checkpoint for changes since.
@@ -369,6 +378,8 @@ pub struct DocState {
     pub guide: Option<(NodeId, usize)>,
     /// The selection's rotation origin, when moved or shown (see [`rotation_origin`]; not saved).
     pub(crate) rotation_origin: Option<rotation_origin::RotationOrigin>,
+    /// The View toggles the preferences keep were applied ([`Session::apply_view_prefs`]).
+    view_from_prefs: bool,
     /// The last duplicate while its copies are the selection: Duplicate repeats its offset (see
     /// [`cmd::edit::Duplicated`]; not saved).
     pub(crate) last_duplicate: Option<cmd::edit::Duplicated>,
@@ -390,7 +401,8 @@ pub struct VersionPreview {
 /// Why edits are refused while a version is shown.
 pub const PREVIEW_READ_ONLY: &str = "you're viewing an earlier version: restore it or go back to the current version to edit";
 
-/// Commands that first end a version preview: they act on the document itself.
+/// Commands that first end a version preview: they act on the document itself. Saving does so
+/// only with a native destination; export copies and pending format choices keep the preview.
 const ENDS_PREVIEW: &[&str] = &["file.save", "file.saveAs", "file.close", "file.revert", "file.saveVersion", "file.duplicate", "version.restore"];
 
 static NEXT_UID: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
@@ -401,6 +413,9 @@ impl DocState {
             doc.repair();
         }
         doc.link_layer_text_styles();
+        cmd::styles::apply_paint_bindings_on_load(&mut doc);
+        components::mark_layer_modes(&mut doc);
+        // Initial import settlement belongs to the saved baseline, not the user's first edit.
         let page = doc.current_page.filter(|p| doc.pages.contains(p)).or_else(|| doc.first_page()).unwrap_or(NodeId(0));
         let doc = Arc::new(doc);
         let mut st = Self {
@@ -427,6 +442,7 @@ impl DocState {
             focus: None,
             guide: None,
             rotation_origin: None,
+            view_from_prefs: false,
             last_duplicate: None,
         };
         st.zoom_to_fit();
@@ -590,6 +606,23 @@ impl DocState {
     }
 }
 
+/// The smallest and largest interface size, relative to the system's display scale (1.0 is the
+/// system's own size).
+pub const UI_SCALE_MIN: f64 = 0.75;
+pub const UI_SCALE_MAX: f64 = 3.0;
+
+/// `scale` kept between [`UI_SCALE_MIN`] and [`UI_SCALE_MAX`]; not a finite number: `None`.
+pub fn clamp_ui_scale(scale: f64) -> Option<f64> {
+    scale.is_finite().then(|| scale.clamp(UI_SCALE_MIN, UI_SCALE_MAX))
+}
+
+/// Reads the saved interface size. Anything but a number reads as 1 (the system's size) and a
+/// number out of range is clamped, so a settings file edited by hand never costs the other
+/// preferences.
+fn read_ui_scale<'de, D: serde::Deserializer<'de>>(d: D) -> std::result::Result<f64, D::Error> {
+    Ok(Value::deserialize(d)?.as_f64().and_then(clamp_ui_scale).unwrap_or(1.0))
+}
+
 /// App-wide preferences that commands read (nudge amounts, behaviours).
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 #[serde(default)]
@@ -606,6 +639,9 @@ pub struct Prefs {
     /// The widths of the main window's left and right panels (the interface keeps them within its
     /// limits; other windows have their own while they are open).
     pub panel_widths: (f32, f32),
+    /// The height asked for the main window's pages list, dragged at its lower edge (`None`: a
+    /// share of the panel; the interface keeps it within its limits).
+    pub pages_height: Option<f32>,
     /// The interface language: a language code ("en", "es", "pt-BR") or "system" (the OS or browser
     /// language). Languages without a catalog show English.
     pub language: String,
@@ -614,9 +650,16 @@ pub struct Prefs {
     /// Reduce motion: the interface's own animations are off (the system's setting turns them off
     /// too). Prototype transitions still play.
     pub reduce_motion: bool,
+    /// How large the whole interface is drawn, relative to the system's display scale: 1.0 is the
+    /// system's own size, 1.25 a quarter larger (kept between [`UI_SCALE_MIN`] and
+    /// [`UI_SCALE_MAX`]). The canvas zoom is separate.
+    #[serde(deserialize_with = "read_ui_scale")]
+    pub ui_scale: f64,
     /// Files that have a path are saved by themselves a few seconds after they change (the app's
     /// timer; off: only File ▸ Save writes them).
     pub auto_save: bool,
+    /// The desktop app starts on the Home screen instead of in a new file.
+    pub start_on_home: bool,
     /// `figcraft://` invite links open this app (`collab.registerLinks`); `None`: on for installed
     /// builds, off for development builds.
     pub invite_links: Option<bool>,
@@ -652,8 +695,20 @@ pub struct Prefs {
     pub home_sort: String,
     /// Which way: `"desc"` (newest first, Z to A) or `"asc"`.
     pub home_order: String,
+    /// The View menu's toggles turned on or off (rulers, pixel grid, snapping…), by command id:
+    /// files opened or made later start with them. Missing: the toggle's default.
+    #[serde(skip_serializing_if = "BTreeMap::is_empty")]
+    pub view: BTreeMap<String, bool>,
+    /// Recently run actions (the Actions palette's Recents), newest first, at most
+    /// [`MAX_RECENT_ACTIONS`]. Entries are `command:<id>`, `plugin:<plugin>/<command>` or
+    /// `widget:<plugin>`.
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub recent_actions: Vec<String>,
 }
 
+/// Recently run actions kept for the Actions palette (newest first).
+pub const MAX_RECENT_ACTIONS: usize = 5;
+
 impl Default for Prefs {
     fn default() -> Self {
         Self {
@@ -666,10 +721,13 @@ impl Default for Prefs {
             show_dimensions: true,
             theme: "system".into(),
             panel_widths: (240.0, 240.0),
+            pages_height: None,
             language: "system".into(),
             user_name: cmd::comment::DEFAULT_AUTHOR.into(),
             reduce_motion: false,
+            ui_scale: 1.0,
             auto_save: false,
+            start_on_home: false,
             invite_links: None,
             plugins: Vec::new(),
             plugin_settings: BTreeMap::new(),
@@ -681,6 +739,8 @@ impl Default for Prefs {
             home_views: BTreeMap::new(),
             home_sort: "modified".into(),
             home_order: "desc".into(),
+            view: BTreeMap::new(),
+            recent_actions: Vec::new(),
         }
     }
 }
@@ -704,6 +764,8 @@ pub struct Clipboard {
     /// The page-space bounds of the copied selection.
     pub bounds: Option<figcraft_geom::Rect>,
     pub source_doc: u64,
+    /// Copied component/set roots, excluding cuts and originals discarded by undo (ids are reused).
+    pub copied_components: std::collections::BTreeSet<NodeId>,
     /// The document copied from (pastes into other files follow its mains) and its file path.
     pub source: Option<Arc<Document>>,
     pub source_path: Option<String>,
@@ -721,7 +783,8 @@ pub struct Session {
     /// dark page colour while it is dark (added pages take the current page's). Headless sessions (CLI, MCP, exports) have no
     /// theme, so what scripts make is the same everywhere.
     pub ui_dark: Option<bool>,
-    /// Command log (id + params) for actions/automation.
+    /// Command log (id + params) for actions/automation. File imports that carry the file bytes
+    /// (`file.import` with `data`) are not logged, so the log never holds a copy of a pasted file.
     pub journal: Vec<(String, Value)>,
     /// Recently used colours.
     pub recent_colors: Vec<figcraft_color::Color>,
@@ -746,6 +809,19 @@ impl Default for Session {
     }
 }
 
+/// Whether a command, or a batch wrapping one, imports a file passed as Base64 `data`.
+fn command_carries_import_bytes(id: &str, params: &Value) -> bool {
+    match id {
+        "file.import" => params::get(params, "data").is_some(),
+        "command.batch" => params.get("commands").and_then(Value::as_array).is_some_and(|commands| {
+            commands.iter().any(|c| {
+                c.get("command").and_then(Value::as_str).zip(c.get("params")).is_some_and(|(id, params)| command_carries_import_bytes(id, params))
+            })
+        }),
+        _ => false,
+    }
+}
+
 impl Session {
     /// A session with one new document.
     pub fn new() -> Self {
@@ -818,6 +894,14 @@ impl Session {
         s
     }
 
+    /// Files new to the session start with the View toggles the preferences keep.
+    pub fn apply_view_prefs(&mut self) {
+        for ds in self.docs.iter_mut().filter(|d| !d.view_from_prefs) {
+            cmd::view::apply_kept(&self.prefs, &mut ds.view);
+            ds.view_from_prefs = true;
+        }
+    }
+
     pub fn ds(&self) -> Result<&DocState> {
         self.docs.get(self.active).ok_or(EngineError::NoDocument)
     }
@@ -854,11 +938,13 @@ impl Session {
     /// as it was.
     pub fn execute(&mut self, id: &str, params: &Value) -> Result<Value> {
         let spec = find_command(id).ok_or_else(|| EngineError::UnknownCommand(id.to_string()))?;
+        board::refuse_on_board(self, id)?;
         // Revert replaces the document's uid: refuse before ending previews or syncing branches.
         if id == "file.revert" && self.live().doc_uid.is_some() {
             return Err(EngineError::Disabled(id.into(), "leave the live session before reverting to the saved file".into()));
         }
         branches::sync(self);
+        self.apply_view_prefs();
         if textpreview::COMMANDS.contains(&id) {
             // A live preview is no edit: no undo step, normalisation or rollback here.
             let r = guard::run(id, || (spec.run)(self, params));
@@ -870,6 +956,7 @@ impl Session {
         // Every other command acts on the document itself, not on a live text preview.
         textpreview::end(self);
         if ENDS_PREVIEW.contains(&id)
+            && (!matches!(id, "file.save" | "file.saveAs") || cmd::file::save_ends_preview(self, id, params))
             && let Ok(ds) = self.ds_mut()
         {
             ds.end_preview();
@@ -878,16 +965,22 @@ impl Session {
         let result = guard::run(id, || (spec.run)(self, params))
             .and_then(|v| self.check_instance_structure(id, &before).map(|()| v))
             .and_then(|v| self.check_preview(id, &before).map(|()| v))
-            .and_then(|v| self.check_live_access(id, &before).map(|()| v));
+            .and_then(|v| self.check_live_access(id, &before).map(|()| v))
+            .and_then(|v| self.check_finite_geometry(id, &before).map(|()| v));
         match &result {
             Ok(_) => {
                 self.after_command(spec, before);
+                self.apply_view_prefs();
                 if spec.history && id != "edit.repeat" {
                     self.last_command = Some((id.to_string(), params.clone()));
                 }
-                self.journal.push((id.to_string(), params.clone()));
-                if self.journal.len() > 5000 {
-                    self.journal.drain(..1000);
+                // Imported bytes already live in the document: a Base64 copy in the log would stay
+                // for the whole session.
+                if !command_carries_import_bytes(id, params) {
+                    self.journal.push((id.to_string(), params.clone()));
+                    if self.journal.len() > 5000 {
+                        self.journal.drain(..1000);
+                    }
                 }
             }
             Err(_) => {
@@ -916,6 +1009,22 @@ impl Session {
         Err(EngineError::Disabled(id.to_string(), PREVIEW_READ_ONLY.into()))
     }
 
+    /// A layer's position and size stay finite: infinity and NaN are written as `null`, so a file
+    /// holding them saves but can't be reopened. Refuse such an edit (it is rolled back).
+    fn check_finite_geometry(&self, id: &str, before: &Option<(Arc<Document>, Vec<NodeId>, NodeId, u64)>) -> Result<()> {
+        let Some((bdoc, _, _, uid)) = before else { return Ok(()) };
+        let Some(ds) = self.docs.iter().find(|d| d.uid == *uid) else { return Ok(()) };
+        if Arc::ptr_eq(&ds.doc, bdoc) {
+            return Ok(());
+        }
+        let broken = |n: &Node| !(n.transform.as_coeffs().iter().all(|c| c.is_finite()) && n.width.is_finite() && n.height.is_finite());
+        let untouched = |n: &Node| bdoc.node_arc(n.id).zip(ds.doc.node_arc(n.id)).is_some_and(|(a, b)| Arc::ptr_eq(a, b));
+        match ds.doc.nodes().find(|n| broken(n) && !untouched(n)) {
+            Some(n) => Err(bad(id, format!("\"{}\" would get a position or size beyond the number range", n.name))),
+            None => Ok(()),
+        }
+    }
+
     /// A live session's document you may only view (or that is on its way to a server) is
     /// read-only: refuse an edit (it is rolled back).
     fn check_live_access(&self, id: &str, before: &Option<(Arc<Document>, Vec<NodeId>, NodeId, u64)>) -> Result<()> {
@@ -956,7 +1065,9 @@ impl Session {
         };
         let Some(ds) = self.docs.iter_mut().find(|d| d.uid == uid) else { return };
         let changed = !Arc::ptr_eq(&ds.doc, &bdoc);
-        if changed {
+        // Saving may adopt the chosen filename as the document title. The encoded snapshot is
+        // already final; normalising it again would detach it from the saved baseline.
+        if changed && !matches!(spec.id, "file.save" | "file.saveAs") {
             normalize(ds.doc_mut(), &bdoc);
         }
         let edit = changed && ds.interaction.is_none();
@@ -1021,8 +1132,11 @@ impl Session {
         let Some(it) = ds.interaction.clone() else { return Err(EngineError::Other("no gesture in progress".into())) };
         let mut doc = (*it.doc).clone();
         let mut sel = it.selection.clone();
+        // What the gesture changes on the selected layers is an explicit edit.
+        let before = cmd::styles::bound_before(&doc, &it.selection);
         let res = f(&mut doc, &mut sel);
         if res.is_ok() {
+            cmd::styles::detach_edited(&mut doc, &before);
             normalize(&mut doc, &it.doc);
             // The same preview again (a handle held still) keeps the document: a new one would
             // re-render the canvas for nothing.
@@ -1089,6 +1203,13 @@ impl Session {
         }
         ds.clean_selection();
         ds.revision += 1;
+        let (uid, doc) = (ds.uid, ds.doc.clone());
+        if self.clipboard.source_doc == uid {
+            self.clipboard.copied_components.retain(|id| {
+                doc.node(*id)
+                    .is_some_and(|n| matches!(n.kind, figcraft_doc::NodeKind::Component { .. } | figcraft_doc::NodeKind::ComponentSet { .. }))
+            });
+        }
         Ok(true)
     }
 
@@ -1135,13 +1256,22 @@ impl Session {
         self.grouped(label, |s| {
             let mut results: Vec<Value> = Vec::with_capacity(cmds.len());
             for (step, (id, p)) in cmds.iter().enumerate() {
-                let p = if id == "command.batch" { p.clone() } else { resolve_step_refs(p, &results, step, 0)? };
-                results.push(s.execute(id, &p)?);
+                let v = s.batch_step(&results, step, id, p)?;
+                results.push(v);
             }
             Ok(results)
         })
     }
 
+    /// One step of a batch: `{"$step": n}` in `params` resolves against `results` (the results of
+    /// the steps before it), then the command runs. [`Session::batch`] runs a list of these as one
+    /// undo step; a caller with its own list — the CLI's script runner — uses this so its steps
+    /// resolve `$step` the same way, inside its own [`Session::grouped`].
+    pub fn batch_step(&mut self, results: &[Value], step: usize, cmd: &str, params: &Value) -> Result<Value> {
+        let p = if cmd == "command.batch" { params.clone() } else { resolve_step_refs(params, results, step, 0)? };
+        self.execute(cmd, &p)
+    }
+
     /// Run `f` as one undo step called `label`: the commands it executes push no steps of their
     /// own, and when it fails the documents stay at their group-start state.
     pub fn grouped<T>(&mut self, label: &str, f: impl FnOnce(&mut Self) -> Result<T>) -> Result<T> {
@@ -1267,7 +1397,9 @@ pub fn normalize(doc: &mut Document, before: &Document) {
         figcraft_layout::coherent_sizing(doc, id);
     }
     touched.extend(doc.take_dirty());
-    // 1. Text auto-size.
+    // 1. Text auto-size (a sticky's note first takes the size its length calls for).
+    board::settle_text(doc, before, &touched);
+    touched.extend(doc.take_dirty());
     for id in live(doc, &touched) {
         let Some(n) = doc.node(id) else { continue };
         if let Some((w, h)) = figcraft_text::auto_size(n)
@@ -1348,6 +1480,9 @@ pub fn normalize(doc: &mut Document, before: &Document) {
         }
     }
     touched.extend(doc.take_dirty());
+    // 4b. Board connectors follow the layers they join; their labels sit at their middles.
+    board::settle_routes(doc, before, &touched);
+    touched.extend(doc.take_dirty());
     // 5. Ready-for-dev layers whose contents changed show "Changed".
     mark_dev_changes(doc, before, &touched);
     doc.take_dirty();
@@ -1374,21 +1509,35 @@ fn affects_layout(before: &Document, doc: &Document, id: NodeId) -> bool {
 }
 
 /// The layers whose variable bindings an edit may have changed: every bound layer when a variable
-/// changed, else the touched layers and everything below those that moved, are new or chose
-/// another variable mode (modes are inherited).
+/// changed, else the touched layers and everything below those that moved, are new, chose
+/// another variable mode or became an instance of another main (modes are inherited, an
+/// instance's from its main too), and the instances of a main that chose another mode.
 fn binding_scope(doc: &Document, before: &Document, touched: &BTreeSet<NodeId>) -> Option<BTreeSet<NodeId>> {
     if doc.variables != before.variables {
         return None;
     }
+    let main = |n: &Node| match n.kind {
+        figcraft_doc::NodeKind::Instance { component, .. } => Some(component),
+        _ => None,
+    };
     let mut out = BTreeSet::new();
     for &id in touched {
         let Some(n) = doc.node(id) else { continue };
-        let inherited = before.node(id).is_none_or(|b| b.var_modes != n.var_modes || b.parent != n.parent);
-        if inherited {
+        let Some(b) = before.node(id) else {
+            out.extend(doc.subtree(id));
+            continue;
+        };
+        let modes = b.var_modes != n.var_modes;
+        if modes || b.parent != n.parent || main(b) != main(n) {
             out.extend(doc.subtree(id));
         } else {
             out.insert(id);
         }
+        if modes && matches!(n.kind, figcraft_doc::NodeKind::Component { .. }) {
+            for i in components::instances_of(doc, id) {
+                out.extend(doc.subtree(i));
+            }
+        }
     }
     Some(out)
 }
@@ -1466,8 +1615,14 @@ mod batch_step_ref_tests;
 #[cfg(test)]
 mod binding_lists_tests;
 #[cfg(test)]
+mod board_tests;
+#[cfg(test)]
+mod board_tools_tests;
+#[cfg(test)]
 mod booleans_tests;
 #[cfg(test)]
+mod bound_alpha_tests;
+#[cfg(test)]
 mod branch_tests;
 #[cfg(test)]
 mod branch_versions_tests;
@@ -1500,6 +1655,8 @@ mod cursor_tests;
 #[cfg(test)]
 mod dark_page_text_tests;
 #[cfg(test)]
+mod design_paste_tests;
+#[cfg(test)]
 mod dev_resources_tests;
 #[cfg(test)]
 mod devcompare_tests;
@@ -1508,6 +1665,12 @@ mod devfocus_tests;
 #[cfg(test)]
 mod devinspect_tests;
 #[cfg(test)]
+mod devmode_behaviour_tests;
+#[cfg(test)]
+mod devmode_tail_tests;
+#[cfg(test)]
+mod doc_urls_tests;
+#[cfg(test)]
 mod double_click_tests;
 #[cfg(test)]
 mod draw_tools_tests;
@@ -1528,6 +1691,10 @@ mod fig_export_tests;
 #[cfg(test)]
 mod fig_import_tests;
 #[cfg(test)]
+mod fill_none_tests;
+#[cfg(test)]
+mod finite_geometry_tests;
+#[cfg(test)]
 mod frame_guides_tests;
 #[cfg(test)]
 mod frame_label_tests;
@@ -1548,16 +1715,28 @@ mod history_behaviour_tests;
 #[cfg(test)]
 mod html_codegen_tests;
 #[cfg(test)]
+mod huge_stroke_tests;
+#[cfg(test)]
+mod id_params_behaviour_tests;
+#[cfg(test)]
 mod import_export_tests;
 #[cfg(test)]
+mod import_journal_tests;
+#[cfg(test)]
 mod inspect_behaviour_tests;
 #[cfg(test)]
+mod instance_modes_tests;
+#[cfg(test)]
+mod instance_resizing_tests;
+#[cfg(test)]
 mod interaction_rollback_tests;
 #[cfg(test)]
 mod invite_links_tests;
 #[cfg(test)]
 mod keymap_tests;
 #[cfg(test)]
+mod library_path_tests;
+#[cfg(test)]
 mod library_range_styles_tests;
 #[cfg(test)]
 mod library_variables_tests;
@@ -1584,16 +1763,22 @@ mod menu_gaps_tests;
 #[cfg(test)]
 mod nested_override_tests;
 #[cfg(test)]
+mod node_set_refusals_tests;
+#[cfg(test)]
 mod online_tests;
 #[cfg(test)]
 mod open_issues_tests;
 #[cfg(test)]
 mod outline_options_tests;
 #[cfg(test)]
+mod page_clipboard_tests;
+#[cfg(test)]
 mod page_copy_navigation_tests;
 #[cfg(test)]
 mod page_target_tests;
 #[cfg(test)]
+mod paint_index_tests;
+#[cfg(test)]
 mod paint_reorder_tests;
 #[cfg(test)]
 mod paint_tests;
@@ -1602,12 +1787,16 @@ mod panels_behaviour_tests;
 #[cfg(test)]
 mod pdf_print_tests;
 #[cfg(test)]
+mod pen_end_tests;
+#[cfg(test)]
 mod pen_overlay_tests;
 #[cfg(test)]
 mod pixel_preview_tests;
 #[cfg(test)]
 mod playground_tests;
 #[cfg(test)]
+mod plugin_data_tests;
+#[cfg(test)]
 mod plugin_directory_tests;
 #[cfg(test)]
 mod plugin_panels_tests;
@@ -1634,6 +1823,8 @@ mod proto_run_tests;
 #[cfg(test)]
 mod proto_tail_tests;
 #[cfg(test)]
+mod rest_slot_tests;
+#[cfg(test)]
 mod retained_walk_tests;
 #[cfg(test)]
 mod rotated_guides_tests;
@@ -1642,6 +1833,8 @@ mod rotated_select_tests;
 #[cfg(test)]
 mod rotation_origin_tests;
 #[cfg(test)]
+mod save_format_tests;
+#[cfg(test)]
 mod scale_tool_tests;
 #[cfg(test)]
 mod section_contents_tests;
@@ -1704,12 +1897,20 @@ mod variables_behaviour_tests;
 #[cfg(test)]
 mod variables_editor_tests;
 #[cfg(test)]
+mod variables_import_shapes_tests;
+#[cfg(test)]
 mod variables_io_tests;
 #[cfg(test)]
+mod variants_discovery_tests;
+#[cfg(test)]
 mod vector_behaviour_tests;
 #[cfg(test)]
+mod vector_fill_rule_tests;
+#[cfg(test)]
 mod vector_multi_behaviour_tests;
 #[cfg(test)]
+mod vector_offset_tests;
+#[cfg(test)]
 mod version_preview_tests;
 #[cfg(test)]
 mod version_tests;
@@ -1717,3 +1918,8 @@ mod version_tests;
 mod view_behaviour_tests;
 #[cfg(test)]
 mod widgets_tests;
+
+#[cfg(test)]
+mod selection_reorder_tests;
+#[cfg(test)]
+mod selection_spacing_tests;
diff --git a/crates/engine/src/library.rs b/crates/engine/src/library.rs
index 73c599a45..af322076b 100644
--- a/crates/engine/src/library.rs
+++ b/crates/engine/src/library.rs
@@ -449,9 +449,27 @@ struct Stamp {
 #[derive(Clone, Debug)]
 struct Entry {
     stamp: Option<Stamp>,
+    /// When the file was read: a stamp only proves the file unchanged once its modification time
+    /// is safely older than that, since file systems keep the time in coarse ticks.
+    read_at: Option<std::time::SystemTime>,
     result: std::result::Result<Arc<PublishedLibrary>, String>,
 }
 
+/// How far a file's modification time must lie before its read for the stamp to be trusted.
+const RACY_STAMP: std::time::Duration = std::time::Duration::from_secs(2);
+
+impl Entry {
+    /// A file stamped in the future (clock skew, unpacked archives) never settles: it is re-read on
+    /// every load until the clock passes it.
+    fn still_valid(&self, now: &Stamp) -> bool {
+        let settled = match (now.modified, self.read_at) {
+            (Some(modified), Some(read_at)) => modified.checked_add(RACY_STAMP).is_some_and(|t| t < read_at),
+            _ => false,
+        };
+        settled && self.stamp.as_ref() == Some(now)
+    }
+}
+
 /// Library files read by a session, by path (re-read when they change on disk).
 #[derive(Clone, Debug, Default)]
 pub struct Cache {
@@ -473,6 +491,11 @@ impl Cache {
                 None => Err(EngineError::Other(crate::library_server::NOT_FETCHED.into())),
             };
         }
+        // The path comes from a document: a network share would be contacted (and on Windows get
+        // the opener's credentials) by the stat below.
+        if !craft_docpath::is_local(path) {
+            return Err(EngineError::Other(format!("{path}: a library is opened only from this computer")));
+        }
         let stamp = stat(path);
         // Checked before the cache: the limit is the caller's.
         if let Ok(st) = &stamp
@@ -481,10 +504,11 @@ impl Cache {
             return Err(EngineError::Other(format!("{path} is too large to use as a library (the limit is {} MB)", max_bytes / 1024 / 1024)));
         }
         if let (Some(e), Ok(st)) = (self.entries.get(path), &stamp)
-            && e.stamp.as_ref() == Some(st)
+            && e.still_valid(st)
         {
             return e.result.clone().map_err(EngineError::Other);
         }
+        let read_at = now();
         let result = match &stamp {
             Ok(_) => read_file(path).map(Arc::new),
             Err(e) => Err(e.clone()),
@@ -492,7 +516,7 @@ impl Cache {
         if self.entries.len() >= MAX_CACHED && !self.entries.contains_key(path) {
             self.entries.clear();
         }
-        self.entries.insert(path.to_string(), Entry { stamp: stamp.ok(), result: result.clone() });
+        self.entries.insert(path.to_string(), Entry { stamp: stamp.ok(), read_at, result: result.clone() });
         result.map_err(EngineError::Other)
     }
 
@@ -506,13 +530,23 @@ impl Cache {
         if self.entries.len() >= MAX_CACHED && !self.entries.contains_key(path) {
             self.entries.clear();
         }
-        self.entries.insert(path.to_string(), Entry { stamp: None, result });
+        self.entries.insert(path.to_string(), Entry { stamp: None, read_at: None, result });
     }
 }
 
+#[cfg(not(target_arch = "wasm32"))]
+fn now() -> Option<std::time::SystemTime> {
+    Some(std::time::SystemTime::now())
+}
+
+#[cfg(target_arch = "wasm32")]
+fn now() -> Option<std::time::SystemTime> {
+    None
+}
+
 #[cfg(not(target_arch = "wasm32"))]
 fn stat(path: &str) -> std::result::Result<Stamp, String> {
-    let m = std::fs::metadata(path).map_err(|e| format!("{path}: {e}"))?;
+    let m = crate::file_access::metadata(path).map_err(|e| e.to_string())?;
     if !m.is_file() {
         return Err(format!("{path} is not a file"));
     }
@@ -524,11 +558,18 @@ fn stat(_path: &str) -> std::result::Result<Stamp, String> {
     Err(NO_FILES.into())
 }
 
+/// A library read from a file or a server, with the modes chosen inside its instances marked when
+/// it was published before they were overrides ([`crate::components::mark_layer_modes`]).
+pub(crate) fn settled(mut lib: PublishedLibrary) -> PublishedLibrary {
+    crate::components::mark_layer_modes(Arc::make_mut(&mut lib.doc));
+    lib
+}
+
 #[cfg(not(target_arch = "wasm32"))]
 fn read_file(path: &str) -> std::result::Result<PublishedLibrary, String> {
-    let f = std::fs::File::open(path).map_err(|e| format!("{path}: {e}"))?;
+    let f = crate::file_access::open(path).map_err(|e| e.to_string())?;
     match figcraft_format::read_library(std::io::BufReader::new(f)) {
-        Ok(Some(lib)) => Ok(lib),
+        Ok(Some(lib)) => Ok(settled(lib)),
         Ok(None) => Err(format!("{path} has no published library: open it and publish it first (Libraries ▸ Publish library…)")),
         Err(e) => Err(format!("{path}: {e}")),
     }
@@ -1221,9 +1262,16 @@ pub fn check_read_only(cmd: &str, before: &Document, after: &Document) -> std::r
     if !variables_unchanged(before, after) {
         return Err(READ_ONLY.into());
     }
-    let Some(store) = after.library_store().or_else(|| before.library_store()) else { return Ok(()) };
-    let touched = |d: &Document, id: NodeId| d.contains(id) && d.page_of(id) == Some(store);
-    if after.dirty().iter().any(|id| touched(before, *id) || touched(after, *id)) {
+    let changed_remote = |id| {
+        if !before.is_remote(id) && !after.is_remote(id) {
+            return false;
+        }
+        match (before.node_arc(id), after.node_arc(id)) {
+            (Some(old), Some(new)) => !Arc::ptr_eq(old, new),
+            _ => true,
+        }
+    };
+    if after.dirty().iter().any(|id| changed_remote(*id)) {
         return Err(READ_ONLY.into());
     }
     Ok(())
diff --git a/crates/engine/src/library_path_tests.rs b/crates/engine/src/library_path_tests.rs
new file mode 100644
index 000000000..de40128a8
--- /dev/null
+++ b/crates/engine/src/library_path_tests.rs
@@ -0,0 +1,39 @@
+//! A library link is stored in the document, so it is followed only on this computer
+//! ([`crate::library_server`]): a path on another server would make opening someone else's file
+//! contact that server, and on Windows send the credentials of whoever opened it.
+
+use crate::Session;
+
+#[test]
+fn a_library_is_opened_only_from_this_computer() {
+    let mut s = Session::new();
+    for path in [
+        r"\\attacker.example\share\lib.figcraft",
+        "//attacker.example/share/lib.figcraft",
+        "file://attacker.example/share/lib.figcraft",
+        r"\\?\UNC\attacker.example\share\lib.figcraft",
+        r"\\.\pipe\lib",
+        "https://attacker.example/lib.figcraft",
+    ] {
+        let e = s.fetch_library(path, false).expect_err(&format!("{path} must be refused"));
+        assert!(e.to_string().contains("only from this computer"), "{path}: {e}");
+    }
+}
+
+#[test]
+fn a_local_library_path_is_still_followed() {
+    let mut s = Session::new();
+    // Refused for being absent, not for where it is: the gate let it through.
+    let missing = std::env::temp_dir().join("figcraft-no-such-library.figcraft");
+    let e = s.fetch_library(&missing.to_string_lossy(), false).expect_err("the file does not exist");
+    assert!(!e.to_string().contains("only from this computer"), "a local path must not be refused as remote: {e}");
+}
+
+#[test]
+fn the_library_cache_refuses_a_path_off_this_computer() {
+    let mut cache = crate::library::Cache::default();
+    for path in [r"\\attacker.example\share\lib.figcraft", "//attacker.example/share/lib.figcraft"] {
+        let e = cache.load(path).expect_err(&format!("{path} must be refused"));
+        assert!(e.to_string().contains("only from this computer"), "{path}: {e}");
+    }
+}
diff --git a/crates/engine/src/library_server.rs b/crates/engine/src/library_server.rs
index dbd97a0b2..10852b5fd 100644
--- a/crates/engine/src/library_server.rs
+++ b/crates/engine/src/library_server.rs
@@ -53,7 +53,7 @@ pub fn archive(lib: &PublishedLibrary) -> Result<Vec<u8>> {
 /// The library in an archive from a server (untrusted: read with the library file's limits).
 pub fn read_archive(bytes: &[u8]) -> std::result::Result<PublishedLibrary, String> {
     match figcraft_format::read_library(Cursor::new(bytes)) {
-        Ok(Some(lib)) => Ok(lib),
+        Ok(Some(lib)) => Ok(crate::library::settled(lib)),
         Ok(None) => Err("the server sent a file without a library".into()),
         Err(e) => Err(format!("the server sent a library that can't be read ({e})")),
     }
@@ -129,6 +129,13 @@ impl Session {
     /// document uses the library.
     pub fn fetch_library(&mut self, path: &str, fresh: bool) -> Result<Arc<PublishedLibrary>> {
         if !is_server_link(path) {
+            // A library link is stored in the document, so opening someone else's file would
+            // otherwise reach whatever path it names. Only a path on this computer is followed: a
+            // network share would make opening a document contact that server, and on Windows
+            // send the credentials of whoever opened it.
+            if !craft_docpath::is_local(path) {
+                return Err(EngineError::Other(format!("{path}: a library is opened only from this computer")));
+            }
             return self.libraries.load(path);
         }
         let have = match self.libraries.cached(path) {
diff --git a/crates/engine/src/library_tests.rs b/crates/engine/src/library_tests.rs
index 23d5af090..27c9e6162 100644
--- a/crates/engine/src/library_tests.rs
+++ b/crates/engine/src/library_tests.rs
@@ -45,6 +45,38 @@ fn path_str(p: &std::path::Path) -> String {
     p.to_string_lossy().into_owned()
 }
 
+fn dirty_library_document() -> (Document, NodeId) {
+    let mut doc = Document::new("Dirty library cache");
+    let store = doc.ensure_library_store();
+    let remote = doc.alloc_id();
+    doc.insert(Node::new(remote, NodeKind::Frame, "Remote", 10.0, 10.0), store, None).unwrap();
+    (doc, remote)
+}
+
+/// An imported cache is dirty until the first edit; that alone is no edit of the library copies.
+#[test]
+fn read_only_allows_unchanged_predirty_remote_nodes() {
+    let (before, remote) = dirty_library_document();
+    assert!(before.dirty().contains(&remote));
+
+    let mut after = before.clone();
+    after.add_page("Unrelated page");
+    assert!(after.dirty().contains(&remote), "the imported remote node remains in the pending dirty set");
+    check_read_only("page.add", &before, &after).unwrap();
+
+    let mut edited = before.clone();
+    edited.get_mut(remote).unwrap().opacity = 0.5;
+    assert_eq!(check_read_only("node.set", &before, &edited), Err(READ_ONLY.into()));
+
+    let mut moved = before.clone();
+    moved.reparent(remote, before.first_page().unwrap(), None).unwrap();
+    assert_eq!(check_read_only("node.reparent", &before, &moved), Err(READ_ONLY.into()));
+
+    let mut deleted = before.clone();
+    deleted.remove(remote).unwrap();
+    assert_eq!(check_read_only("edit.delete", &before, &deleted), Err(READ_ONLY.into()));
+}
+
 /// The library file's layers.
 struct Kit {
     button: NodeId,
@@ -179,8 +211,16 @@ fn add_place_and_update_keep_overrides() {
         NodeKind::Instance { component, .. } => component,
         _ => panic!("not an instance"),
     };
+    let unchanged = s.doc().unwrap().clone();
     let e = s.execute("node.set", &json!({"id": remote_button, "props": {"fill": "#ff0000"}})).unwrap_err();
     assert!(e.to_string().contains("can't be edited"), "{e}");
+    assert_eq!(s.doc().unwrap(), &unchanged, "a refused remote edit rolls back");
+    for (cmd, args) in
+        [("node.reparent", json!({"ids": [remote_button], "parent": s.page().unwrap()})), ("edit.delete", json!({"ids": [remote_button]}))]
+    {
+        assert!(s.execute(cmd, &args).is_err(), "{cmd} must preserve read-only copies");
+        assert_eq!(s.doc().unwrap(), &unchanged, "refused {cmd} rolls back");
+    }
     let style = s.doc().unwrap().styles[0].id.clone();
     assert!(s.execute("style.update", &json!({"style": style, "name": "Mine"})).is_err());
     assert!(s.execute("style.delete", &json!({"style": style})).is_err());
@@ -281,10 +321,16 @@ fn library_styles_apply_and_import_with_pages() {
     let copy = doc.nodes().find(|n| n.name == node(&s, inst).name && matches!(n.kind, NodeKind::Instance { .. }) && !doc.is_remote(n.id)).unwrap();
     let NodeKind::Instance { component, .. } = copy.kind else { panic!("not an instance") };
     assert!(doc.is_remote(component));
+    let store_roots = |s: &Session| {
+        let doc = s.doc().unwrap();
+        doc.library_store().and_then(|id| doc.node(id)).map_or(0, |n| n.children.len())
+    };
+    assert_eq!(store_roots(&t), 2, "recorded copies are not copied twice");
     // A second import shares the copies it already has.
     ex(&mut t, "file.import", json!({"path": path}));
     healthy(&t);
     assert_eq!(t.doc().unwrap().libraries.components.len(), 2);
+    assert_eq!(store_roots(&t), 2);
     let _ = std::fs::remove_dir_all(&d);
 }
 
@@ -399,3 +445,21 @@ fn library_survives_saving_with_versions() {
     healthy(&user);
     let _ = std::fs::remove_dir_all(&d);
 }
+
+#[test]
+fn a_file_stamp_from_the_moment_it_was_read_does_not_prove_it_unchanged() {
+    use std::time::{Duration, SystemTime};
+    let read_at = SystemTime::now();
+    let entry = |modified: SystemTime| Entry {
+        stamp: Some(Stamp { len: 10, modified: Some(modified) }),
+        read_at: Some(read_at),
+        result: Err("unused".into()),
+    };
+    // Written in the same coarse tick as the read: a same-length rewrite would keep this stamp.
+    let fresh = entry(read_at);
+    assert!(!fresh.still_valid(&Stamp { len: 10, modified: Some(read_at) }));
+    // Written well before the read: an unchanged stamp means an unchanged file.
+    let old = read_at - Duration::from_secs(10);
+    assert!(entry(old).still_valid(&Stamp { len: 10, modified: Some(old) }));
+    assert!(!entry(old).still_valid(&Stamp { len: 11, modified: Some(old) }));
+}
diff --git a/crates/engine/src/library_variables_tests.rs b/crates/engine/src/library_variables_tests.rs
index 4fc778a7d..b4a4171a4 100644
--- a/crates/engine/src/library_variables_tests.rs
+++ b/crates/engine/src/library_variables_tests.rs
@@ -344,3 +344,67 @@ fn library_style_bindings_ignore_unrelated_local_variables() {
     healthy(&s);
     let _ = std::fs::remove_dir_all(&d);
 }
+
+/// A library "Modal" holding a Button instance whose icon copy is on mode Dark: (the Button main,
+/// the icon copy in Modal).
+fn nested_mode_kit(lib: &mut Session) -> (NodeId, NodeId) {
+    theme(lib);
+    let f = idv(&ex(lib, "frame.create", json!({"x": 0, "y": 0, "width": 20, "height": 20, "name": "Icon"})));
+    ex(lib, "variable.bind", json!({"ids": [f], "field": "fill", "variable": "primary"}));
+    let icon = idv(&ex(lib, "component.create", json!({"ids": [f]})));
+    let b = idv(&ex(lib, "frame.create", json!({"x": 100, "y": 0, "width": 60, "height": 40, "name": "Button"})));
+    ex(lib, "instance.create", json!({"component": icon, "x": 10, "y": 10, "parent": b}));
+    let button = idv(&ex(lib, "component.create", json!({"ids": [b]})));
+    let m = idv(&ex(lib, "frame.create", json!({"x": 300, "y": 0, "width": 200, "height": 100, "name": "Modal"})));
+    let close = idv(&ex(lib, "instance.create", json!({"component": button, "x": 10, "y": 10, "parent": m})));
+    let nested = lib.doc().unwrap().node(close).unwrap().children[0];
+    ex(lib, "variable.setMode", json!({"ids": [nested], "collection": "Theme", "mode": "Dark"}));
+    ex(lib, "component.create", json!({"ids": [m]}));
+    (button, nested)
+}
+
+/// The icon inside the Button inside library Modal instance `inst`.
+fn modal_icon(s: &Session, inst: NodeId) -> NodeId {
+    let doc = s.doc().unwrap();
+    doc.node(doc.node(inst).unwrap().children[0]).unwrap().children[0]
+}
+
+#[test]
+fn modes_set_inside_nested_instances_come_along() {
+    let d = dir("nested-modes");
+    let lib_path = path_str(&d.join("kit.figcraft"));
+    let mut lib = Session::new();
+    let (button, _) = nested_mode_kit(&mut lib);
+    let lid = publish_to(&mut lib, &lib_path);
+
+    let mut s = Session::new();
+    ex(&mut s, "library.add", json!({"path": lib_path}));
+    let inst = idv(&ex(&mut s, "library.place", json!({"library": lid, "component": "Modal", "x": 0, "y": 0})));
+    let copy = |s: &Session| modal_icon(s, inst);
+    assert_eq!(fill(&s, copy(&s)), "FFFFFF", "the Dark mode set on the nested icon comes along");
+    // An update that rebuilds the Button copies keeps it too.
+    ex(&mut lib, "node.set", json!({"ids": [button], "layout": "horizontal"}));
+    republish(&mut lib);
+    ex(&mut s, "library.acceptUpdates", json!({}));
+    assert_eq!(fill(&s, copy(&s)), "FFFFFF");
+    healthy(&s);
+    let _ = std::fs::remove_dir_all(&d);
+}
+
+#[test]
+fn a_library_published_before_modes_were_overrides_keeps_the_modes_set_inside_nested_instances() {
+    let d = dir("nested-modes-old");
+    let lib_path = path_str(&d.join("kit.figcraft"));
+    let mut lib = Session::new();
+    let (_, nested) = nested_mode_kit(&mut lib);
+    // Published before `modes` was an override group: the copy has its mode but no marker.
+    lib.doc_mut().unwrap().node_mut(nested).unwrap().overrides.remove("modes");
+    let lid = publish_to(&mut lib, &lib_path);
+
+    let mut s = Session::new();
+    ex(&mut s, "library.add", json!({"path": lib_path}));
+    let inst = idv(&ex(&mut s, "library.place", json!({"library": lid, "component": "Modal", "x": 0, "y": 0})));
+    assert_eq!(fill(&s, modal_icon(&s, inst)), "FFFFFF", "the Dark mode comes along");
+    healthy(&s);
+    let _ = std::fs::remove_dir_all(&d);
+}
diff --git a/crates/engine/src/live.rs b/crates/engine/src/live.rs
index 4001b1563..cd8a0f03b 100644
--- a/crates/engine/src/live.rs
+++ b/crates/engine/src/live.rs
@@ -81,11 +81,15 @@ pub const PEOPLE: [&str; 8] = ["#0D99FF", "#9747FF", "#14AE5C", "#F24822", "#D97
 
 /// `#RRGGBB` → (r, g, b); `None` for anything else.
 pub fn parse_color(s: &str) -> Option<(u8, u8, u8)> {
-    let hex = s.strip_prefix('#').filter(|h| h.len() == 6 && h.is_ascii())?;
+    let hex = s.strip_prefix('#').filter(|h| h.len() == 6 && h.bytes().all(|b| b.is_ascii_hexdigit()))?;
     let byte = |i: usize| hex.get(i..i + 2).and_then(|b| u8::from_str_radix(b, 16).ok());
     Some((byte(0)?, byte(2)?, byte(4)?))
 }
 
+/// Why a join failed when a message from the host is over this app's size limit (`{mb}`: the
+/// limit in MB). The UI translates it.
+pub const TOO_LARGE_TO_JOIN: &str = "This file is too large to join here (up to {mb} MB)";
+
 /// The connection to a live session.
 #[derive(Clone, Debug, Default, PartialEq, Serialize)]
 #[serde(rename_all = "camelCase", tag = "state")]
diff --git a/crates/engine/src/live_access_tests.rs b/crates/engine/src/live_access_tests.rs
index 7f5a4488f..c2c75bb5e 100644
--- a/crates/engine/src/live_access_tests.rs
+++ b/crates/engine/src/live_access_tests.rs
@@ -265,7 +265,7 @@ fn revert_offline_file_works_while_another_file_is_live_and_after_leaving() {
     s.execute("file.new", &json!({})).unwrap();
     let offline_path = saved_file(&mut s);
     s.execute("file.revert", &json!({})).unwrap();
-    assert_eq!(s.doc().unwrap().name, "Untitled");
+    assert_eq!(s.doc().unwrap().name, offline_path.file_stem().unwrap().to_string_lossy());
     assert!(!s.ds().unwrap().is_dirty());
     assert_eq!(s.ds().unwrap().versions.len(), 1);
     assert_eq!(s.live_of(uid).doc_uid, Some(uid));
@@ -273,7 +273,7 @@ fn revert_offline_file_works_while_another_file_is_live_and_after_leaving() {
     s.execute("doc.switch", &json!({"index": 0})).unwrap();
     s.execute("collab.leave", &json!({})).unwrap();
     s.execute("file.revert", &json!({})).unwrap();
-    assert_eq!(s.doc().unwrap().name, "Untitled");
+    assert_eq!(s.doc().unwrap().name, path.file_stem().unwrap().to_string_lossy());
     assert!(!s.ds().unwrap().is_dirty());
     assert_eq!(s.ds().unwrap().versions.len(), 1);
     assert_eq!(s.live().doc_uid, None);
diff --git a/crates/engine/src/live_tests.rs b/crates/engine/src/live_tests.rs
index cacc4f378..5cdccf698 100644
--- a/crates/engine/src/live_tests.rs
+++ b/crates/engine/src/live_tests.rs
@@ -507,3 +507,11 @@ fn hosting_commands_check_what_they_are_given() {
     assert!(e.contains("join a file"), "{e}");
     assert!(s.execute("collab.report", &json!({"reason": " \n "})).unwrap_err().to_string().contains("few words"));
 }
+
+#[test]
+fn parse_color_rejects_signs_and_non_hex() {
+    use crate::live::parse_color;
+    assert_eq!(parse_color("#+1+2+3"), None);
+    assert_eq!(parse_color("#-1-2-3"), None);
+    assert_eq!(parse_color("#0D99FF"), Some((13, 153, 255)));
+}
diff --git a/crates/engine/src/nested_override_tests.rs b/crates/engine/src/nested_override_tests.rs
index f684a693b..0d61edf7e 100644
--- a/crates/engine/src/nested_override_tests.rs
+++ b/crates/engine/src/nested_override_tests.rs
@@ -198,3 +198,179 @@ fn copied_instances_keep_their_overrides() {
     assert!(node(&s, t).source.is_none() && node(&s, t).overrides.is_empty());
     healthy(&s);
 }
+
+/// `button()` with the main's copy of the icon's Shape filled red, and an instance-swap property
+/// `Icon` on the nested icon: (icon, shape, button, nested).
+fn button_with_icon_override(s: &mut Session) -> (NodeId, NodeId, NodeId, NodeId) {
+    let (icon_main, shape, button, nested) = button(s);
+    let main_shape = copy_of(s, nested, shape);
+    ex(s, "node.set", json!({"id": main_shape, "props": {"fill": "#ff0000"}}));
+    ex(s, "component.addProperty", json!({"id": button, "name": "Icon", "type": "instanceSwap", "default": icon_main, "layer": nested}));
+    (icon_main, shape, button, nested)
+}
+
+/// Swap instance `i`'s icon to `to` by its instance-swap property `Icon`.
+fn swap_icon(s: &mut Session, i: NodeId, to: NodeId) {
+    ex(s, "instance.setProperties", json!({"ids": [i], "properties": {"Icon": to}}));
+    healthy(s);
+}
+
+#[test]
+fn a_main_override_carries_onto_a_swapped_nested_instance() {
+    // Documented: overrides survive a swap when layer names match, and a swapped icon takes the
+    // colour the main component set (forum thread with staff replies). Rows: by the instance-swap
+    // property and by instance.swap, onto a matching and an unmatched name. The main's size
+    // override is geometry and stays out; the instance's own override wins over the main's.
+    let mut s = Session::new();
+    let (_icon, shape, button, nested) = button_with_icon_override(&mut s);
+    let main_shape = copy_of(&s, nested, shape);
+    ex(&mut s, "node.set", json!({"id": main_shape, "props": {"width": 10}}));
+    let other = icon(&mut s, 200.0, "Other", "Shape");
+    let unmatched = icon(&mut s, 300.0, "Unmatched", "Glyph");
+    for (by_property, to, want) in [(true, other, "FF0000"), (false, other, "FF0000"), (true, unmatched, "111111"), (false, unmatched, "111111")] {
+        let i = idv(&ex(&mut s, "instance.create", json!({"component": button, "x": 300, "y": 400})));
+        if by_property {
+            swap_icon(&mut s, i, to);
+        } else {
+            let inested = copy_of(&s, i, nested);
+            ex(&mut s, "instance.swap", json!({"ids": [inested], "component": to}));
+            healthy(&s);
+        }
+        let glyph = kids(&s, copy_of(&s, i, nested))[0];
+        assert_eq!(fill(&s, glyph), want, "by property {by_property}, to {to}");
+        assert_eq!(node(&s, glyph).width, 20.0, "the main's size override stays out");
+    }
+    let i = idv(&ex(&mut s, "instance.create", json!({"component": button, "x": 300, "y": 600})));
+    let glyph = kids(&s, copy_of(&s, i, nested))[0];
+    ex(&mut s, "node.set", json!({"id": glyph, "props": {"fill": "#0000ff"}}));
+    swap_icon(&mut s, i, other);
+    assert_eq!(fill(&s, kids(&s, copy_of(&s, i, nested))[0]), "0000FF", "the instance's own override wins");
+}
+
+#[test]
+fn a_main_override_carries_onto_a_swap_one_level_deeper() {
+    // As above for a Button instance inside a Toolbar main, swapped in a Toolbar instance.
+    let mut s = Session::new();
+    let (_icon, _shape, button, nested) = button_with_icon_override(&mut s);
+    let other = icon(&mut s, 200.0, "Other", "Shape");
+    let bar = idv(&ex(&mut s, "frame.create", json!({"x": 0, "y": 600, "width": 300, "height": 60, "name": "Toolbar"})));
+    let inner = idv(&ex(&mut s, "instance.create", json!({"component": button, "x": 10, "y": 10, "parent": bar})));
+    let toolbar = idv(&ex(&mut s, "component.create", json!({"ids": [bar]})));
+    let t = idv(&ex(&mut s, "instance.create", json!({"component": toolbar, "x": 0, "y": 800})));
+    let icon_in_t = copy_of(&s, t, copy_of(&s, inner, nested));
+    ex(&mut s, "instance.swap", json!({"ids": [icon_in_t], "component": other}));
+    healthy(&s);
+    assert_eq!(fill(&s, kids(&s, icon_in_t)[0]), "FF0000");
+}
+
+#[test]
+fn a_swapped_nested_instance_keeps_the_main_override_it_took() {
+    // Documented (staff reply): later edits of the main's icon colour don't reach instances that
+    // swapped, and do reach the rest. Undo and redo follow; resetting the override shows the icon
+    // main's own fill.
+    let mut s = Session::new();
+    let (_icon, shape, button, nested) = button_with_icon_override(&mut s);
+    let other = icon(&mut s, 200.0, "Other", "Shape");
+    let swapped = idv(&ex(&mut s, "instance.create", json!({"component": button, "x": 300, "y": 400})));
+    let kept = idv(&ex(&mut s, "instance.create", json!({"component": button, "x": 300, "y": 500})));
+    swap_icon(&mut s, swapped, other);
+    let glyph = |s: &Session, i: NodeId| fill(s, kids(s, copy_of(s, i, nested))[0]);
+    let main_shape = copy_of(&s, nested, shape);
+    ex(&mut s, "node.set", json!({"id": main_shape, "props": {"fill": "#00ff00"}}));
+    healthy(&s);
+    assert_eq!((glyph(&s, swapped), glyph(&s, kept)), ("FF0000".into(), "00FF00".into()));
+    s.undo().unwrap();
+    assert_eq!((glyph(&s, swapped), glyph(&s, kept)), ("FF0000".into(), "FF0000".into()));
+    s.redo().unwrap();
+    assert_eq!((glyph(&s, swapped), glyph(&s, kept)), ("FF0000".into(), "00FF00".into()));
+    let swapped_glyph = kids(&s, copy_of(&s, swapped, nested))[0];
+    ex(&mut s, "component.resetOverride", json!({"id": swapped_glyph, "group": "fills"}));
+    healthy(&s);
+    assert_eq!(glyph(&s, swapped), "111111");
+}
+
+#[test]
+fn a_swapped_in_icon_keeps_its_own_overrides_to_itself() {
+    // Docs silent; pinned: what an icon main overrides inside itself stays that main's. After a
+    // swap to it, its edits still reach the instance; a second swap doesn't carry them on.
+    let mut s = Session::new();
+    let (_icon, _shape, button, nested) = button_with_icon_override(&mut s);
+    let dot = icon(&mut s, 200.0, "Dot", "Shape");
+    let with_dot = |s: &mut Session, x: f64, name: &str, fill: Option<&str>| {
+        let f = idv(&ex(s, "frame.create", json!({"x": x, "y": 300, "width": 24, "height": 24, "name": name})));
+        let d = idv(&ex(s, "instance.create", json!({"component": dot, "x": 0, "y": 0, "parent": f})));
+        if let Some(c) = fill {
+            let shape = kids(s, d)[0];
+            ex(s, "node.set", json!({"id": shape, "props": {"fill": c}}));
+        }
+        (idv(&ex(s, "component.create", json!({"ids": [f]}))), d)
+    };
+    let (other2, dot2) = with_dot(&mut s, 300.0, "Other2", Some("#0000ff"));
+    let (other3, _) = with_dot(&mut s, 400.0, "Other3", None);
+    let i = idv(&ex(&mut s, "instance.create", json!({"component": button, "x": 300, "y": 400})));
+    swap_icon(&mut s, i, other2);
+    let shape_in = |s: &Session| kids(s, kids(s, copy_of(s, i, nested))[0])[0];
+    assert_eq!(fill(&s, shape_in(&s)), "0000FF");
+    let shape2 = kids(&s, dot2)[0];
+    ex(&mut s, "node.set", json!({"id": shape2, "props": {"fill": "#00ffff"}}));
+    healthy(&s);
+    assert_eq!(fill(&s, shape_in(&s)), "00FFFF", "Other2's own edit reaches it");
+    swap_icon(&mut s, i, other3);
+    assert_eq!(fill(&s, shape_in(&s)), "111111", "Other2's override doesn't carry onto Other3");
+}
+
+#[test]
+fn a_swapped_out_icons_own_overrides_stay_with_it() {
+    // Docs silent; pinned: what the Button's default icon main overrides inside itself isn't the
+    // Button main's to carry. Icon A colours its Base's Shape green; swapping to icon B, also built
+    // on Base, shows Base's own fill.
+    let mut s = Session::new();
+    let base = icon(&mut s, 0.0, "Base", "Shape");
+    let on_base = |s: &mut Session, x: f64, name: &str| {
+        let f = idv(&ex(s, "frame.create", json!({"x": x, "y": 500, "width": 24, "height": 24, "name": name})));
+        let b = idv(&ex(s, "instance.create", json!({"component": base, "x": 0, "y": 0, "parent": f})));
+        (idv(&ex(s, "component.create", json!({"ids": [f]}))), b)
+    };
+    let (a, a_base) = on_base(&mut s, 100.0, "A");
+    let (b, _) = on_base(&mut s, 200.0, "B");
+    let a_shape = kids(&s, a_base)[0];
+    ex(&mut s, "node.set", json!({"id": a_shape, "props": {"fill": "#00ff00"}}));
+    let f = idv(&ex(&mut s, "frame.create", json!({"x": 0, "y": 700, "width": 40, "height": 40, "name": "Button"})));
+    let nested = idv(&ex(&mut s, "instance.create", json!({"component": a, "x": 4, "y": 4, "parent": f})));
+    let button = idv(&ex(&mut s, "component.create", json!({"ids": [f]})));
+    ex(&mut s, "component.addProperty", json!({"id": button, "name": "Icon", "type": "instanceSwap", "default": a, "layer": nested}));
+    let i = idv(&ex(&mut s, "instance.create", json!({"component": button, "x": 0, "y": 800})));
+    swap_icon(&mut s, i, b);
+    let shape = kids(&s, kids(&s, copy_of(&s, i, nested))[0])[0];
+    assert_eq!(fill(&s, shape), "111111");
+    assert!(node(&s, shape).overrides.is_empty());
+}
+
+#[test]
+fn a_slot_the_main_filled_shows_the_swapped_in_mains_content() {
+    // Docs silent on slot content across a swap; pinned: a Chip the Panel main put in its card's
+    // slot doesn't carry onto the swapped-in card, which shows its own default content.
+    let mut s = Session::new();
+    let card = |s: &mut Session, x: f64, name: &str| {
+        let f = idv(&ex(s, "frame.create", json!({"x": x, "y": 0, "width": 100, "height": 60, "name": name})));
+        let content = idv(&ex(s, "frame.create", json!({"x": 0, "y": 0, "width": 100, "height": 60, "parent": f, "name": "Content"})));
+        ex(s, "shape.rectangle", json!({"x": 0, "y": 0, "width": 40, "height": 20, "parent": content, "props": {"name": format!("{name} default")}}));
+        let c = idv(&ex(s, "component.create", json!({"ids": [f]})));
+        ex(s, "component.makeSlot", json!({"id": content}));
+        c
+    };
+    let (a, b) = (card(&mut s, 0.0, "A"), card(&mut s, 200.0, "B"));
+    let chip = icon(&mut s, 400.0, "Chip", "Dot");
+    let f = idv(&ex(&mut s, "frame.create", json!({"x": 0, "y": 400, "width": 200, "height": 100, "name": "Panel"})));
+    let nested = idv(&ex(&mut s, "instance.create", json!({"component": a, "x": 0, "y": 0, "parent": f})));
+    let panel = idv(&ex(&mut s, "component.create", json!({"ids": [f]})));
+    ex(&mut s, "instance.slotInsert", json!({"id": nested, "slot": "Content", "component": chip, "replace": true}));
+    ex(&mut s, "component.addProperty", json!({"id": panel, "name": "Card", "type": "instanceSwap", "default": a, "layer": nested}));
+    let i = idv(&ex(&mut s, "instance.create", json!({"component": panel, "x": 0, "y": 700})));
+    ex(&mut s, "instance.setProperties", json!({"ids": [i], "properties": {"Card": b}}));
+    healthy(&s);
+    let content = kids(&s, copy_of(&s, i, nested))[0];
+    let names: Vec<String> = kids(&s, content).into_iter().map(|k| node(&s, k).name.clone()).collect();
+    assert_eq!(names, ["B default"]);
+    assert!(!node(&s, content).overrides.contains(SLOT));
+}
diff --git a/crates/engine/src/node_set_refusals_tests.rs b/crates/engine/src/node_set_refusals_tests.rs
new file mode 100644
index 000000000..ce316d301
--- /dev/null
+++ b/crates/engine/src/node_set_refusals_tests.rs
@@ -0,0 +1,95 @@
+//! `node.set` doesn't store what can't apply: auto layout keys go only to layers that can have auto
+//! layout (the others are named in `warnings`, and with none of them the call is refused), and a
+//! `fontStyle` the family lacks says which face draws instead.
+
+use serde_json::{Value, json};
+
+use crate::{EngineError, Session};
+
+fn ex(s: &mut Session, cmd: &str, p: Value) -> Value {
+    s.execute(cmd, &p).unwrap_or_else(|e| panic!("{cmd}: {e}"))
+}
+
+fn id(v: &Value) -> crate::NodeId {
+    crate::params::id_of(v).unwrap()
+}
+
+fn bad_msg(r: crate::Result<Value>) -> String {
+    match r {
+        Err(EngineError::BadParams { msg, .. }) => msg,
+        other => panic!("expected BadParams, got {other:?}"),
+    }
+}
+
+#[test]
+fn auto_layout_keys_on_layers_without_auto_layout_are_refused() {
+    let mut s = Session::new();
+    let t = id(&ex(&mut s, "node.create", json!({"type": "text", "text": "Hi"}))["id"]);
+    let r = id(&ex(&mut s, "node.create", json!({"type": "rectangle"}))["id"]);
+    for (target, key, value) in [(t, "gap", json!(8)), (r, "padding", json!(4)), (t, "mainAlign", json!("center")), (r, "wrap", json!(true))] {
+        let msg = bad_msg(s.execute("node.set", &json!({"ids": [target], "props": {key: value}})));
+        assert!(msg.contains(key) && msg.contains("auto layout"), "{msg}");
+        assert!(s.doc().unwrap().node(target).unwrap().layout.is_none(), "no hidden auto layout on {target}");
+    }
+    // Frames still take them, with or without a layout mode first.
+    let f = id(&ex(&mut s, "node.create", json!({"type": "frame"}))["id"]);
+    let out = ex(&mut s, "node.set", json!({"ids": [f], "props": {"gap": 8, "padding": 4}}));
+    assert_eq!(s.doc().unwrap().node(f).unwrap().layout.as_ref().map(|l| l.gap), Some(8.0));
+    assert!(out.get("warnings").is_none(), "{out}");
+}
+
+#[test]
+fn with_several_layers_the_frames_take_auto_layout_keys_and_the_others_are_named() {
+    let mut s = Session::new();
+    let f = id(&ex(&mut s, "node.create", json!({"type": "frame", "name": "Card"}))["id"]);
+    let t = id(&ex(&mut s, "node.create", json!({"type": "text", "text": "Hi", "name": "Title"}))["id"]);
+    let out = ex(&mut s, "node.set", json!({"ids": [f, t], "props": {"gap": 8, "opacity": 0.5}}));
+    let doc = s.doc().unwrap();
+    assert_eq!(doc.node(f).unwrap().layout.as_ref().map(|l| l.gap), Some(8.0));
+    assert!(doc.node(t).unwrap().layout.is_none(), "no hidden auto layout on the text");
+    assert_eq!(doc.node(t).unwrap().opacity, 0.5, "the text still gets the other keys");
+    let w = out["warnings"][0].as_str().unwrap();
+    assert!(w.contains("`gap`") && w.contains(&format!("{t} “Title”")) && w.contains("TEXT"), "{w}");
+    // One undo step for all of it.
+    ex(&mut s, "edit.undo", json!({}));
+    assert!(s.doc().unwrap().node(f).unwrap().layout.as_ref().is_none_or(|l| l.gap != 8.0));
+}
+
+#[test]
+fn a_font_style_draws_in_the_nearest_face_and_says_so_when_it_differs() {
+    figcraft_text::scan_system_fonts();
+    // Any installed family with a regular and a bold face and nothing heavier (CI machines differ).
+    let pick = figcraft_text::family_names().into_iter().find_map(|f| {
+        let st = figcraft_text::family_styles(&f);
+        let has = |w: u16| st.iter().any(|x| figcraft_doc::style_weight(x) == w && !x.to_lowercase().contains("italic"));
+        (has(400) && has(700) && !st.iter().any(|x| figcraft_doc::style_weight(x) > 700)).then_some((f, st))
+    });
+    let Some((family, styles)) = pick else { return };
+    let mut s = Session::new();
+    let t = id(&ex(&mut s, "node.create", json!({"type": "text", "text": "Hi", "props": {"fontFamily": family}}))["id"]);
+    let set = |s: &mut Session, style: &str| ex(s, "node.set", json!({"ids": [t], "props": {"fontStyle": style}}));
+    // Any spelling of a style it has, and names that resolve to the weight they ask for, say nothing.
+    let bold = styles.iter().find(|x| figcraft_doc::style_weight(x) == 700).unwrap().clone();
+    for style in [bold.clone(), bold.to_uppercase(), bold.replace(' ', ""), "Roman".into(), "Normal".into()] {
+        let out = set(&mut s, &style);
+        assert!(out.get("warnings").is_none(), "{style}: {out}");
+    }
+    // A heavier weight than the family has applies (as a text layer resolves it) and says which face draws.
+    let out = set(&mut s, "Black");
+    let w = out["warnings"][0].as_str().unwrap();
+    assert!(w.contains(&family) && w.contains("`Black`") && w.contains("nearest"), "{w}");
+    assert_eq!(s.doc().unwrap().node(t).unwrap().kind.text().unwrap().spans()[0].2.font_style, "Black");
+    // A family that isn't installed keeps any style name without a word (files from elsewhere name theirs).
+    let out = ex(&mut s, "node.set", json!({"ids": [t], "props": {"fontFamily": "No Such Family 7f3a", "fontStyle": "Hairline"}}));
+    assert!(out.get("warnings").is_none(), "{out}");
+}
+
+#[test]
+fn a_refused_call_changes_nothing() {
+    let mut s = Session::new();
+    let t = id(&ex(&mut s, "node.create", json!({"type": "text", "text": "Hi"}))["id"]);
+    let before = s.doc().unwrap().node(t).unwrap().fills.clone();
+    // `fill` comes before `gap` (keys apply in order), so this checks the rollback.
+    assert!(s.execute("node.set", &json!({"ids": [t], "props": {"fill": "#FF0000", "gap": 8}})).is_err());
+    assert_eq!(s.doc().unwrap().node(t).unwrap().fills, before);
+}
diff --git a/crates/engine/src/online.rs b/crates/engine/src/online.rs
index b982580ea..667137322 100644
--- a/crates/engine/src/online.rs
+++ b/crates/engine/src/online.rs
@@ -120,7 +120,12 @@ pub fn same_server(a: &str, b: &str) -> bool {
         let s = plain_server(s).to_ascii_lowercase();
         let s = s.trim_end_matches('/');
         let port = if s.starts_with("wss://") { ":443" } else { ":80" };
-        s.strip_suffix(port).unwrap_or(s).to_string()
+        let start = s.find("://").map_or(0, |i| i + 3);
+        let end = s[start..].find('/').map_or(s.len(), |i| start + i);
+        match s[start..end].strip_suffix(port) {
+            Some(host) => format!("{}{}{}", &s[..start], host, &s[end..]),
+            None => s.to_string(),
+        }
     };
     norm(a) == norm(b)
 }
diff --git a/crates/engine/src/online_tests.rs b/crates/engine/src/online_tests.rs
index 1e341b146..c211c505e 100644
--- a/crates/engine/src/online_tests.rs
+++ b/crates/engine/src/online_tests.rs
@@ -583,3 +583,11 @@ fn debug_output_of_a_record_leaves_the_secrets_out() {
     no_secrets("debug", &text);
     assert!(text.contains("share.example") && text.contains(".."), "{text}");
 }
+
+#[test]
+fn same_server_ignores_the_default_port_before_a_path() {
+    use crate::online::same_server;
+    assert!(same_server("wss://share.example:443/figcraft/", "wss://share.example/figcraft/"));
+    assert!(same_server("ws://host:80/x", "ws://host/x"));
+    assert!(!same_server("wss://share.example:8443/figcraft/", "wss://share.example/figcraft/"));
+}
diff --git a/crates/engine/src/open_issues_tests.rs b/crates/engine/src/open_issues_tests.rs
index d7f23720b..2bee799b0 100644
--- a/crates/engine/src/open_issues_tests.rs
+++ b/crates/engine/src/open_issues_tests.rs
@@ -49,3 +49,16 @@ fn an_intact_file_opens_without_a_message() {
     assert!(s.message.is_none());
     let _ = std::fs::remove_dir_all(path.parent().unwrap());
 }
+
+#[test]
+fn file_close_rejects_a_bad_index_instead_of_closing_another_document() {
+    let mut s = Session::new();
+    s.execute("file.new", &json!({})).unwrap();
+    s.execute("file.new", &json!({})).unwrap();
+    let docs = s.docs.len();
+    for index in [json!(-1), json!(1.5), json!(99)] {
+        let r = s.execute("file.close", &json!({"index": index, "force": true}));
+        assert!(r.is_err(), "index {index} must be rejected, got {r:?}");
+        assert_eq!(s.docs.len(), docs, "index {index} closed a document");
+    }
+}
diff --git a/crates/engine/src/page_clipboard_tests.rs b/crates/engine/src/page_clipboard_tests.rs
new file mode 100644
index 000000000..79ff74199
--- /dev/null
+++ b/crates/engine/src/page_clipboard_tests.rs
@@ -0,0 +1,36 @@
+//! `edit.copy` / `edit.cut` skip pages (they aren't layers and can't be pasted), and refuse a
+//! selection of only pages under their own command id.
+
+use serde_json::json;
+
+use crate::{EngineError, Session};
+
+#[test]
+fn copy_and_cut_ignore_pages_so_paste_keeps_the_document_valid() {
+    for cmd in ["edit.copy", "edit.cut"] {
+        let mut s = Session::new();
+        let page = s.page().unwrap();
+        s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 10, "height": 10})).unwrap();
+        match s.execute(cmd, &json!({"ids": [page.0]})) {
+            Err(EngineError::Disabled(id, _)) => assert_eq!(id, cmd),
+            r => panic!("{cmd} on a page: {r:?}"),
+        }
+        let _ = s.execute("edit.paste", &json!({}));
+        let doc = s.doc().unwrap();
+        assert!(doc.validate().is_empty(), "{cmd}: {:?}", doc.validate());
+        assert!(doc.node(page).is_some(), "{cmd} removed the page");
+    }
+}
+
+#[test]
+fn cut_of_a_page_and_a_layer_moves_only_the_layer() {
+    let mut s = Session::new();
+    let page = s.page().unwrap();
+    let r = s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 10, "height": 10})).unwrap();
+    let rect = crate::params::id_of(&r["id"]).unwrap();
+    s.execute("edit.cut", &json!({"ids": [page.0, rect.0]})).unwrap();
+    assert!(s.doc().unwrap().node(page).is_some());
+    assert!(s.doc().unwrap().node(rect).is_none());
+    s.execute("edit.paste", &json!({})).unwrap();
+    assert!(s.doc().unwrap().validate().is_empty());
+}
diff --git a/crates/engine/src/paint_index_tests.rs b/crates/engine/src/paint_index_tests.rs
new file mode 100644
index 000000000..eddea306d
--- /dev/null
+++ b/crates/engine/src/paint_index_tests.rs
@@ -0,0 +1,39 @@
+//! `fill.set` / `stroke.set` reject a negative, fractional or non-finite `index` instead of
+//! clamping or truncating it onto another paint (like `fill.remove` / `stroke.remove`).
+
+use figcraft_doc::NodeId;
+use serde_json::{Value, json};
+
+use crate::Session;
+
+fn ex(s: &mut Session, cmd: &str, p: Value) -> Value {
+    s.execute(cmd, &p).unwrap_or_else(|e| panic!("{cmd} {p}: {e}"))
+}
+
+fn paints(s: &Session, id: NodeId) -> String {
+    let n = s.doc().unwrap().node(id).unwrap();
+    format!("{:?} {:?}", n.fills, n.strokes)
+}
+
+#[test]
+fn paint_set_rejects_bad_index_and_leaves_the_paints_alone() {
+    let mut s = Session::new();
+    let r = NodeId(ex(&mut s, "shape.rectangle", json!({"x": 0, "y": 0, "width": 10, "height": 10}))["id"].as_u64().unwrap());
+    for add in ["fill.add", "stroke.add"] {
+        for c in ["#0000FF", "#FFFF00"] {
+            ex(&mut s, add, json!({"ids": [r], "color": c}));
+        }
+    }
+    let before = paints(&s, r);
+    for cmd in ["fill.set", "stroke.set"] {
+        for bad in [json!(-1), json!(0.5), json!(1.9), json!("-1"), json!("1.5"), json!("NaN"), json!("inf"), json!("abc")] {
+            let res = s.execute(cmd, &json!({"ids": [r], "index": bad, "color": "#FF0000"}));
+            assert!(res.is_err(), "{cmd} index {bad} was accepted: {res:?}");
+            assert_eq!(paints(&s, r), before, "{cmd} index {bad} changed the document");
+        }
+        ex(&mut s, cmd, json!({"ids": [r], "index": 1, "color": "#FF0000"}));
+        assert_ne!(paints(&s, r), before, "{cmd} with a valid index still edits");
+        ex(&mut s, "edit.undo", json!({}));
+        assert_eq!(paints(&s, r), before);
+    }
+}
diff --git a/crates/engine/src/params.rs b/crates/engine/src/params.rs
index bbaa42a45..35a74e0e5 100644
--- a/crates/engine/src/params.rs
+++ b/crates/engine/src/params.rs
@@ -88,6 +88,36 @@ pub fn req_id(cmd: &str, p: &Value, key: &str) -> Result<NodeId> {
     id(p, key).ok_or_else(|| bad(cmd, format!("`{key}` must be a node id")))
 }
 
+/// The offending value for an error message, cut to a few dozen characters so a huge param
+/// doesn't end up in the error whole.
+fn shown(v: &Value) -> String {
+    const MAX: usize = 40;
+    let text = v.to_string();
+    match text.char_indices().nth(MAX) {
+        Some((cut, _)) => format!("{}…", &text[..cut]),
+        None => text,
+    }
+}
+
+/// `key` when it is there: a layer id, or an error naming it. Missing and `null` mean "none", so a
+/// command can tell "no parent given" (use the page) from "a parent was given that isn't an id" —
+/// which is a mistake, not the default. Without this, `{"$step": 0}` reaching a param that isn't
+/// resolved yet silently becomes "no parent" and the layer lands on the page.
+pub fn opt_id(cmd: &str, p: &Value, key: &str) -> Result<Option<NodeId>> {
+    match get(p, key) {
+        None | Some(Value::Null) => Ok(None),
+        Some(v) => id_of(v).map(Some).ok_or_else(|| bad(cmd, format!("`{key}` must be a node id (got {})", shown(v)))),
+    }
+}
+
+/// `key` when it is there: a whole, non-negative number, or an error. Missing means "none".
+pub fn opt_index(cmd: &str, p: &Value, key: &str) -> Result<Option<usize>> {
+    match get(p, key) {
+        None | Some(Value::Null) => Ok(None),
+        Some(_) => req_index(cmd, p, key).map(Some),
+    }
+}
+
 /// `ids` (array), `id` (single), or the current selection.
 pub fn targets(s: &Session, p: &Value) -> Vec<NodeId> {
     if let Some(Value::Array(a)) = get(p, "ids") {
@@ -99,8 +129,25 @@ pub fn targets(s: &Session, p: &Value) -> Vec<NodeId> {
     s.selection()
 }
 
-/// Like [`targets`] but an empty result is an error.
+/// Like [`targets`] but an unparseable `ids` entry, an unparseable `id`, or an empty result is an
+/// error: naming something that isn't a layer is a mistake, not an empty selection. An explicit
+/// `null` says the same as leaving the key out.
 pub fn req_targets(cmd: &str, s: &Session, p: &Value) -> Result<Vec<NodeId>> {
+    match get(p, "ids") {
+        Some(Value::Array(a)) => {
+            if let Some(v) = a.iter().find(|v| id_of(v).is_none()) {
+                return Err(bad(cmd, format!("`ids`: every entry must be a node id (got {})", shown(v))));
+            }
+        }
+        Some(Value::Null) | None => {
+            if let Some(v) = get(p, "id").filter(|v| !v.is_null())
+                && id_of(v).is_none()
+            {
+                return Err(bad(cmd, format!("`id` must be a node id (got {})", shown(v))));
+            }
+        }
+        Some(v) => return Err(bad(cmd, format!("`ids` must be an array (got {})", shown(v)))),
+    }
     let t = targets(s, p);
     if t.is_empty() {
         return Err(EngineError::Disabled(cmd.to_string(), "nothing is selected (pass `ids`)".into()));
diff --git a/crates/engine/src/pen_end_tests.rs b/crates/engine/src/pen_end_tests.rs
new file mode 100644
index 000000000..a5d24f61c
--- /dev/null
+++ b/crates/engine/src/pen_end_tests.rs
@@ -0,0 +1,72 @@
+//! Ending a pen path with Escape or Enter (#760): the path's vector stays in edit mode with the pen,
+//! so the next path is drawn into the same layer; another Escape leaves edit mode.
+
+use crate::Session;
+use crate::tools::{PointerEvent, PointerKind, ToolId};
+use crate::vectoredit::VTool;
+use figcraft_doc::NodeKind;
+
+fn click(s: &mut Session, x: f64, y: f64) {
+    for kind in [PointerKind::Down, PointerKind::Up] {
+        s.pointer(&PointerEvent::at(kind, x, y, 1.0)).unwrap();
+    }
+}
+
+fn layers(s: &Session) -> usize {
+    s.doc().unwrap().node(s.page().unwrap()).unwrap().children.len()
+}
+
+/// (points, segments) of vector `id`.
+fn shape(s: &Session, id: figcraft_doc::NodeId) -> (usize, usize) {
+    match &s.doc().unwrap().node(id).unwrap().kind {
+        NodeKind::Vector { network } => (network.vertices.len(), network.segments.len()),
+        k => panic!("not a vector: {k:?}"),
+    }
+}
+
+/// A two-point pen path, ended with `end`.
+fn drawn(end: fn(&mut Session)) -> (Session, figcraft_doc::NodeId) {
+    let mut s = Session::new();
+    s.set_tool(ToolId::Pen);
+    click(&mut s, 100.0, 100.0);
+    click(&mut s, 200.0, 100.0);
+    let id = s.tool.pen.as_ref().and_then(|p| p.id).unwrap();
+    let undo = s.undo_depth().0;
+    end(&mut s);
+    assert!(s.tool.pen.is_none(), "the path ended");
+    assert_eq!(s.undo_depth().0, undo + 1, "the path is one undo step");
+    let ve = s.ds().unwrap().vector_edit.clone().expect("still editing the vector");
+    assert_eq!((ve.id, ve.tool, ve.anchor), (id, VTool::Pen, None), "the pen, with no open end");
+    (s, id)
+}
+
+#[test]
+fn escape_and_enter_keep_the_vector_in_edit_mode_with_the_pen() {
+    // Escape, and Enter (its key runs `pen_end`).
+    let ends: [fn(&mut Session); 2] = [|s| s.escape().unwrap(), |s| s.pen_end().unwrap()];
+    for end in ends {
+        let (mut s, id) = drawn(end);
+        // The next path goes into the same layer, unconnected to the first.
+        click(&mut s, 100.0, 300.0);
+        click(&mut s, 200.0, 300.0);
+        assert_eq!(layers(&s), 1, "no new layer");
+        assert_eq!(shape(&s, id), (4, 2), "two separate paths in one vector network");
+        // Escape ends that path, the next one leaves edit mode.
+        s.escape().unwrap();
+        assert!(s.ds().unwrap().vector_edit.is_some());
+        s.escape().unwrap();
+        assert!(s.ds().unwrap().vector_edit.is_none(), "the second Escape leaves edit mode");
+        assert_eq!(s.ds().unwrap().selection, vec![id]);
+    }
+}
+
+#[test]
+fn escape_before_a_segment_leaves_nothing_to_edit() {
+    let mut s = Session::new();
+    s.set_tool(ToolId::Pen);
+    click(&mut s, 100.0, 100.0);
+    s.escape().unwrap();
+    assert!(s.tool.pen.is_none());
+    assert!(s.ds().unwrap().vector_edit.is_none());
+    assert_eq!(layers(&s), 0);
+}
diff --git a/crates/engine/src/pen_overlay_tests.rs b/crates/engine/src/pen_overlay_tests.rs
index 7e0064d2b..7f6dba3c5 100644
--- a/crates/engine/src/pen_overlay_tests.rs
+++ b/crates/engine/src/pen_overlay_tests.rs
@@ -63,3 +63,24 @@ fn finishing_the_path_clears_its_handles_and_band() {
     let ov = &s.tool.overlay;
     assert!(ov.pen.is_empty() && ov.pen_handles.is_empty() && ov.rubber.is_none() && ov.rubber_handle.is_none());
 }
+
+#[test]
+fn shift_keeps_the_band_and_the_next_point_at_45_degree_steps() {
+    // #970: with Shift the band shows where the point will land, at a 45° step from the last
+    // anchor (the same length as the pointer is away), not under the pointer.
+    let mut s = Session::new();
+    s.set_tool(ToolId::Pen);
+    at(&mut s, PointerKind::Down, 100.0, 100.0);
+    at(&mut s, PointerKind::Up, 100.0, 100.0);
+    let shifted = |kind, x, y| PointerEvent { shift: true, ..PointerEvent::at(kind, x, y, 1.0) };
+    s.pointer(&shifted(PointerKind::Hover, 300.0, 120.0)).unwrap();
+    let [x0, y0, x1, y1] = s.tool.overlay.rubber.unwrap();
+    assert_eq!([x0, y0, y1], [100.0, 100.0, 100.0], "level with the last anchor");
+    assert!((x1 - (100.0 + 200f64.hypot(20.0))).abs() < 1e-9, "{x1}");
+    s.pointer(&shifted(PointerKind::Down, 300.0, 120.0)).unwrap();
+    s.pointer(&shifted(PointerKind::Up, 300.0, 120.0)).unwrap();
+    s.pointer(&shifted(PointerKind::Hover, 400.0, 230.0)).unwrap();
+    let [x0, y0, x1, y1] = s.tool.overlay.rubber.unwrap();
+    assert_eq!(y0, 100.0, "the point landed on the band");
+    assert!((x1 - x0 - (y1 - y0)).abs() < 1e-9, "45° down to the right: {:?}", [x0, y0, x1, y1]);
+}
diff --git a/crates/engine/src/playground.rs b/crates/engine/src/playground.rs
index 0023a6c10..64286cef8 100644
--- a/crates/engine/src/playground.rs
+++ b/crates/engine/src/playground.rs
@@ -75,7 +75,7 @@ pub fn specs() -> Vec<CommandSpec> {
             if let Some(path) = string(p, "path") {
                 let scale = num(p, "scale").filter(|k| k.is_finite()).map_or(2.0, |k| k.clamp(0.01, 16.0));
                 let png = crate::cmd::file::export_bytes(&copy, &[inst], ExportFormat::Png, scale)?;
-                std::fs::write(&path, png).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;
+                crate::file_access::write(&path, &png)?;
                 out["path"] = json!(path);
             }
             Ok(out)
diff --git a/crates/engine/src/plugin_data_tests.rs b/crates/engine/src/plugin_data_tests.rs
new file mode 100644
index 000000000..076786b79
--- /dev/null
+++ b/crates/engine/src/plugin_data_tests.rs
@@ -0,0 +1,30 @@
+//! Layer data (`pluginData`) reads back through `node.get` and `document.inspect` (#879): what
+//! `node.set` writes on a layer or a page comes back as `{key: value}`, a removed key goes, and a
+//! layer without any reports none.
+
+use crate::Session;
+use crate::components::tests::{ex, idv};
+use serde_json::json;
+
+#[test]
+fn node_get_reports_the_layer_data_node_set_wrote() {
+    let mut s = Session::new();
+    let f = idv(&ex(&mut s, "frame.create", json!({"x": 0, "y": 0, "width": 100, "height": 100})));
+    let r = idv(&ex(&mut s, "shape.rectangle", json!({"x": 0, "y": 0, "width": 10, "height": 10})));
+    let page = s.ds().unwrap().page;
+    assert!(ex(&mut s, "node.get", json!({"id": f})).get("pluginData").is_none(), "no data, no field");
+    ex(&mut s, "node.set", json!({"ids": [f], "props": {"pluginData": {"com.example.sync": "{\"v\":1}", "n": 2}}}));
+    ex(&mut s, "node.set", json!({"ids": [page], "props": {"pluginData": {"com.example.sync": "page"}}}));
+    let got = ex(&mut s, "node.get", json!({"id": f}))["pluginData"].clone();
+    assert_eq!(got, json!({"com.example.sync": "{\"v\":1}", "n": "2"}), "values read back as the strings stored");
+    assert_eq!(ex(&mut s, "node.get", json!({"id": page}))["pluginData"], json!({"com.example.sync": "page"}), "pages keep data too");
+    assert!(ex(&mut s, "node.get", json!({"id": r})).get("pluginData").is_none(), "other layers report none");
+    // The document tree reports it as well (the page and its children).
+    let tree = crate::inspect::document(&s, 2, false);
+    assert_eq!(tree["pages"][0]["pluginData"], json!({"com.example.sync": "page"}));
+    // A null removes a key; undo brings it back.
+    ex(&mut s, "node.set", json!({"ids": [f], "props": {"pluginData": {"n": null}}}));
+    assert_eq!(ex(&mut s, "node.get", json!({"id": f}))["pluginData"], json!({"com.example.sync": "{\"v\":1}"}));
+    ex(&mut s, "edit.undo", json!({}));
+    assert_eq!(ex(&mut s, "node.get", json!({"id": f}))["pluginData"]["n"], "2");
+}
diff --git a/crates/engine/src/plugin_directory.rs b/crates/engine/src/plugin_directory.rs
index c3bf7dc44..2f721feae 100644
--- a/crates/engine/src/plugin_directory.rs
+++ b/crates/engine/src/plugin_directory.rs
@@ -147,6 +147,9 @@ fn install(s: &mut Session, p: &Value) -> Result<Value> {
 /// Keep an installed plugin's files in its own folder under the install folder (named by the hash
 /// of its id, so no id reaches the file system), its module renamed; the manifest's path. Without
 /// an install folder (the browser, the CLI and tests) the plugin lasts for the session.
+// The install folder is the app's own (set by the desktop app, never by a command), so automation
+// roots don't apply to it.
+#[allow(clippy::disallowed_methods)]
 fn save(s: &Session, m: &mut Manifest, b: &Bundle) -> std::result::Result<Option<String>, String> {
     let Some(root) = s.plugins.install_dir.clone() else { return Ok(None) };
     #[cfg(not(target_arch = "wasm32"))]
@@ -189,6 +192,7 @@ fn save(s: &Session, m: &mut Manifest, b: &Bundle) -> std::result::Result<Option
 }
 
 /// Delete the folder of a plugin installed from a directory (only one inside the install folder).
+#[allow(clippy::disallowed_methods)]
 pub(crate) fn delete_installed(s: &Session, p: &InstalledPlugin) {
     #[cfg(not(target_arch = "wasm32"))]
     if let (Some(_), Some(path), Some(root)) = (&p.source, &p.path, &s.plugins.install_dir)
@@ -208,7 +212,7 @@ pub(crate) fn delete_installed(s: &Session, p: &InstalledPlugin) {
 fn bundle_from_disk(cmd: &str, path: &str) -> Result<Bundle> {
     use crate::plugins::{module_file, read_file};
     let mut file = std::path::PathBuf::from(crate::library::absolute_path(path.trim()));
-    if file.is_dir() {
+    if crate::file_access::is_dir(&file) {
         file.push(MANIFEST_FILE);
     }
     let text =
@@ -217,9 +221,12 @@ fn bundle_from_disk(cmd: &str, path: &str) -> Result<Bundle> {
     let wasm = module_file(&file, &m)?;
     let mut assets = Vec::new();
     let dir = file.parent().map(|d| d.join(ASSETS));
-    if let Some(entries) = dir.as_ref().and_then(|d| std::fs::read_dir(d).ok()) {
-        let mut names: Vec<(String, std::path::PathBuf)> =
-            entries.flatten().filter(|e| e.path().is_file()).map(|e| (e.file_name().to_string_lossy().into_owned(), e.path())).collect();
+    if let Some(entries) = dir.as_ref().and_then(|d| crate::file_access::read_dir(d).ok()) {
+        let mut names: Vec<(String, std::path::PathBuf)> = entries
+            .into_iter()
+            .filter(|p| crate::file_access::metadata(p).is_ok_and(|m| m.is_file()))
+            .map(|p| (p.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default(), p))
+            .collect();
         names.sort();
         if names.len() > MAX_ASSETS {
             return Err(bad(cmd, format!("a plugin's assets folder holds at most {MAX_ASSETS} files")));
diff --git a/crates/engine/src/plugins.rs b/crates/engine/src/plugins.rs
index f1c4075e3..b7c122276 100644
--- a/crates/engine/src/plugins.rs
+++ b/crates/engine/src/plugins.rs
@@ -107,10 +107,16 @@ const DENIED: &[&str] = &[
     "plugins.",
     "libraries.",
     "library.add",
+    // Uploads the open document to a server.
+    "library.publishToServer",
     "edit.undo",
     "edit.redo",
     "edit.repeat",
     "command.batch",
+    // Network sessions, online files and their recovery copies on disk.
+    "collab.",
+    // Opens files in new windows.
+    "window.",
     "view.theme",
 ];
 /// Read-only exceptions to [`DENIED`].
@@ -128,6 +134,20 @@ fn refusal(m: &Manifest, command: &str, params: &Value) -> Option<String> {
     if command == "image.place" && get(params, "path").is_some() {
         return Some("plugins can't read files: pass the image as `data`".into());
     }
+    if command == "text.loadFont" && get(params, "path").is_some() {
+        return Some("plugins can't read files: pass the font as `data`".into());
+    }
+    // `path` here is a file on disk (elsewhere it is a vector path or an action's place).
+    if matches!(command, "variable.export" | "codeConnect.export" | "component.playground") && get(params, "path").is_some() {
+        return Some("plugins can't write files: leave out `path` to get the result back".into());
+    }
+    if command == "codeConnect.import" && get(params, "path").is_some() {
+        return Some("plugins can't read files: pass the connections as `json`".into());
+    }
+    // Variables JSON may be given as a path: only objects and JSON text for plugins.
+    if command == "variable.import" && get(params, "variables").and_then(Value::as_str).is_some_and(|t| !t.trim_start().starts_with('{')) {
+        return Some("plugins can't read files: pass the variables JSON itself".into());
+    }
     if !m.permissions.allows(command) {
         return Some(format!("`{command}` isn't in the commands {} asked permission for", m.name));
     }
@@ -140,7 +160,8 @@ fn refusal(m: &Manifest, command: &str, params: &Value) -> Option<String> {
 /// Whether `params` set layer data (`pluginData`, anywhere in them) under a widget's own keys.
 fn writes_widget_data(params: &Value, depth: usize) -> bool {
     let own = |data: &Value| data.as_object().is_some_and(|m| m.keys().any(|k| k.starts_with(crate::widgets::DATA_PREFIX)));
-    depth < 64
+    // serde_json refuses nesting past 128, so nothing deeper can reach here.
+    depth < 128
         && match params {
             Value::Object(m) => m.iter().any(|(k, v)| (k == "pluginData" && own(v)) || writes_widget_data(v, depth + 1)),
             Value::Array(a) => a.iter().any(|v| writes_widget_data(v, depth + 1)),
@@ -236,12 +257,11 @@ pub(crate) fn installed<'a>(s: &'a Session, cmd: &str, id: &str) -> Result<&'a I
 /// Read a file of at most `max` bytes.
 #[cfg(not(target_arch = "wasm32"))]
 pub(crate) fn read_file(path: &std::path::Path, max: usize) -> Result<Vec<u8>> {
-    let shown = path.display();
-    let meta = std::fs::metadata(path).map_err(|e| EngineError::Other(format!("{shown}: {e}")))?;
+    let meta = crate::file_access::metadata(path)?;
     if !meta.is_file() || meta.len() > max as u64 {
-        return Err(EngineError::Other(format!("{shown}: not a file of at most {} KB", max / 1024)));
+        return Err(EngineError::Other(format!("{}: not a file of at most {} KB", path.display(), max / 1024)));
     }
-    std::fs::read(path).map_err(|e| EngineError::Other(format!("{shown}: {e}")))
+    crate::file_access::read(path)
 }
 
 /// The manifest at `path` (the file, or the folder holding `figcraft-plugin.json`), its absolute
@@ -249,7 +269,7 @@ pub(crate) fn read_file(path: &std::path::Path, max: usize) -> Result<Vec<u8>> {
 #[cfg(not(target_arch = "wasm32"))]
 fn load_from_disk(cmd: &str, path: &str) -> Result<(Manifest, String, Vec<u8>)> {
     let mut file = std::path::PathBuf::from(crate::library::absolute_path(path.trim()));
-    if file.is_dir() {
+    if crate::file_access::is_dir(&file) {
         file.push(MANIFEST_FILE);
     }
     let text = read_file(&file, figcraft_plugin::manifest::MAX_MANIFEST_BYTES)?;
@@ -280,10 +300,22 @@ pub(crate) fn module_of(s: &Session, p: &InstalledPlugin) -> Result<Arc<Vec<u8>>
     let Some(path) = &p.path else {
         return Err(EngineError::Other(format!("{} was imported without a manifest file: import it again", p.manifest.name)));
     };
-    #[cfg(not(target_arch = "wasm32"))]
-    return module_file(std::path::Path::new(path), &p.manifest).map(Arc::new);
-    #[cfg(target_arch = "wasm32")]
-    return Err(EngineError::Other(format!("{path}: there are no files in the browser")));
+    module_from_disk(s, p, path)
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+fn module_from_disk(s: &Session, p: &InstalledPlugin, path: &str) -> Result<Arc<Vec<u8>>> {
+    let file = std::path::Path::new(path);
+    let read = || module_file(file, &p.manifest).map(Arc::new);
+    // A plugin installed from a directory lives in the app's own install folder, not among the
+    // files automation roots confine.
+    let own = p.source.is_some() && s.plugins.install_dir.as_deref().is_some_and(|d| crate::file_access::within_app_folder(file, d));
+    if own { crate::file_access::app_owned(read) } else { read() }
+}
+
+#[cfg(target_arch = "wasm32")]
+fn module_from_disk(_: &Session, _: &InstalledPlugin, path: &str) -> Result<Arc<Vec<u8>>> {
+    Err(EngineError::Other(format!("{path}: there are no files in the browser")))
 }
 
 /// The sandbox limits for a run, with `fuel` lowering the instruction budget.
@@ -566,3 +598,28 @@ pub fn specs() -> Vec<CommandSpec> {
         spec!("plugins.manage", "Manage plugins…", "{}  opens the plugins window; returns the list like `plugin.list`", false, manage),
     ]
 }
+
+#[cfg(test)]
+mod refusal_tests {
+    use super::*;
+
+    #[test]
+    fn read_only_plugin_cannot_publish_to_server() {
+        let m = Manifest::parse(r#"{"id":"x.y","name":"X","main":"plugin.wasm"}"#).unwrap();
+        let r = refusal(&m, "library.publishToServer", &json!({}));
+        assert!(r.is_some(), "library.publishToServer uploads the document and must be refused");
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn widget_data_is_found_at_any_depth_serde_accepts() {
+        let depth = 100;
+        let text = format!("{}{{\"pluginData\":{{\"{}x\":1}}}}{}", "{\"a\":".repeat(depth), crate::widgets::DATA_PREFIX, "}".repeat(depth));
+        let v: Value = serde_json::from_str(&text).unwrap();
+        assert!(writes_widget_data(&v, 0));
+    }
+}
diff --git a/crates/engine/src/plugins_tests.rs b/crates/engine/src/plugins_tests.rs
index 102d675a3..7f6c37403 100644
--- a/crates/engine/src/plugins_tests.rs
+++ b/crates/engine/src/plugins_tests.rs
@@ -164,11 +164,19 @@ fn files_dialogs_history_and_plugins_are_off_limits() {
         ("file.saveAs", json!({"path": target})),
         ("file.open", json!({"path": "C:/Windows/win.ini"})),
         ("image.place", json!({"path": "secret.png"})),
+        ("text.loadFont", json!({"path": "/etc/hosts"})),
         ("library.add", json!({"path": "lib.figcraft"})),
         ("plugin.run", json!({"id": "org.test.deny"})),
         ("plugin.remove", json!({"id": "org.test.deny"})),
         ("edit.undo", json!({})),
         ("command.batch", json!({"commands": [{"command": "file.saveAs", "params": {"path": target}}]})),
+        ("variable.export", json!({"format": "css", "path": target})),
+        ("codeConnect.export", json!({"path": target})),
+        ("codeConnect.import", json!({"path": "/etc/passwd"})),
+        ("component.playground", json!({"id": a, "path": target})),
+        ("variable.import", json!({"variables": "/etc/passwd"})),
+        ("collab.recoverFile", json!({"path": "copy.figcraft", "file": "x", "session": 1, "client": 1, "seq": 0})),
+        ("window.new", json!({"path": "C:/Windows/win.ini"})),
         ("doc.switch", json!({"index": 0})),
         ("pref.keepTool", json!({})),
         // Without a name it would open inline renaming in the layers panel: a UI request.
diff --git a/crates/engine/src/rest_slot_tests.rs b/crates/engine/src/rest_slot_tests.rs
new file mode 100644
index 000000000..e272c3a70
--- /dev/null
+++ b/crates/engine/src/rest_slot_tests.rs
@@ -0,0 +1,91 @@
+//! Slots opened from REST file JSON: instances keep their own slot content through edits and
+//! moves of the mains, and through saving.
+
+use crate::Session;
+use crate::components::tests::{ex, healthy, idv};
+use crate::components::*;
+use base64::Engine as _;
+use figcraft_doc::*;
+use serde_json::{Value, json};
+
+fn at(x: f64, y: f64) -> Value {
+    json!([[1, 0, x], [0, 1, y]])
+}
+
+fn text(id: &str, s: &str) -> Value {
+    json!({"id": id, "name": s, "type": "TEXT", "characters": s, "relativeTransform": at(0.0, 0.0), "size": {"x": 100, "y": 20}})
+}
+
+/// A Chip main, a Container main with an empty "Slot", and an instance of Container whose slot
+/// holds a text and a chip.
+fn file() -> Value {
+    let slot = |id: &str, kids: Value| json!({"id": id, "name": "Slot", "type": "SLOT", "relativeTransform": at(10.0, 40.0), "size": {"x": 280, "y": 100}, "children": kids});
+    let guid = |l: u32| json!({"guid": {"sessionID": 5, "localID": l}});
+    let chip = json!({"id": "2:3", "name": "Chip", "type": "INSTANCE", "componentId": "1:9", "relativeTransform": at(0.0, 30.0), "size": {"x": 40, "y": 20},
+        "children": [{"id": "I2:3;1:10", "name": "Dot", "type": "ELLIPSE", "relativeTransform": at(2.0, 2.0), "size": {"x": 16, "y": 16}}]});
+    json!({"name": "Slots", "document": {"id": "0:0", "type": "DOCUMENT", "children": [{"id": "0:1", "name": "Page", "type": "CANVAS", "children": [
+        {"id": "1:9", "name": "Chip", "type": "COMPONENT", "relativeTransform": at(0.0, 400.0), "size": {"x": 40, "y": 20}, "children": [
+            {"id": "1:10", "name": "Dot", "type": "ELLIPSE", "relativeTransform": at(2.0, 2.0), "size": {"x": 16, "y": 16}}
+        ]},
+        {"id": "1:2", "name": "Container", "type": "COMPONENT", "relativeTransform": at(0.0, 0.0), "size": {"x": 300, "y": 160},
+         "componentPropertyDefinitions": {"Slot#1:3": {"type": "SLOT", "defaultValue": guid(1)}},
+         "children": [text("1:4", "Title"), slot("1:5", json!([]))]},
+        {"id": "2:1", "name": "Container", "type": "INSTANCE", "componentId": "1:2", "relativeTransform": at(400.0, 0.0), "size": {"x": 300, "y": 160},
+         "componentProperties": {"Slot#1:3": {"type": "SLOT", "value": guid(7)}},
+         "children": [text("I2:1;1:4", "Title"), slot("I2:1;1:5", json!([text("2:2", "Reports in progress"), chip]))]}
+    ]}]}})
+}
+
+fn named(doc: &Document, kind: fn(&NodeKind) -> bool, name: &str) -> NodeId {
+    doc.nodes().find(|n| n.name == name && kind(&n.kind)).map(|n| n.id).unwrap_or_else(|| panic!("no {name}"))
+}
+
+/// The instance's slot and the names of what it holds.
+fn slot_content(s: &Session) -> (NodeId, Vec<String>) {
+    let doc = s.doc().unwrap();
+    let inst = named(doc, |k| matches!(k, NodeKind::Instance { .. }), "Container");
+    let (slot, _) = slots_of(doc, inst).into_iter().next().expect("the instance has its slot");
+    let names = doc.node(slot).unwrap().children.iter().map(|c| doc.node(*c).unwrap().name.clone()).collect();
+    (slot, names)
+}
+
+#[test]
+fn rest_slot_content_survives_main_edits_moves_and_saving() {
+    let mut s = Session::new();
+    let data = base64::engine::general_purpose::STANDARD.encode(serde_json::to_vec(&file()).unwrap());
+    ex(&mut s, "file.open", json!({"data": data, "name": "slots.json"}));
+    healthy(&s);
+    let want = vec!["Reports in progress".to_string(), "Chip".to_string()];
+    let (slot, names) = slot_content(&s);
+    assert_eq!(names, want);
+    let doc = s.doc().unwrap();
+    assert_eq!(slot_name(doc, slot).as_deref(), Some("Slot"));
+    assert!(slot_edited(doc, slot), "the instance's own content");
+    let chip = named(doc, |k| matches!(k, NodeKind::Instance { .. }), "Chip");
+    assert!(!inside_instance(doc, chip), "content stands alone");
+
+    // Edit and move both mains (the container's and the one used in the content).
+    let main = named(doc, |k| matches!(k, NodeKind::Component { .. }), "Container");
+    let chip_main = named(doc, |k| matches!(k, NodeKind::Component { .. }), "Chip");
+    let title = doc.node(main).unwrap().children[0];
+    ex(&mut s, "node.set", json!({"id": title, "props": {"fill": "#ff0000"}}));
+    ex(&mut s, "node.set", json!({"id": main, "props": {"width": 320}}));
+    let holder = idv(&ex(&mut s, "frame.create", json!({"x": -1000, "y": 0, "width": 900, "height": 900, "name": "Design system"})));
+    ex(&mut s, "node.reparent", json!({"ids": [main, chip_main], "parent": holder}));
+    healthy(&s);
+    assert_eq!(slot_content(&s).1, want, "kept across syncs");
+
+    // Saving and opening again keeps it.
+    let bytes = figcraft_format::save_bytes(s.doc().unwrap(), None).unwrap();
+    let data = base64::engine::general_purpose::STANDARD.encode(bytes);
+    let mut again = Session::new();
+    ex(&mut again, "file.open", json!({"data": data, "name": "slots.figcraft"}));
+    healthy(&again);
+    let (slot, names) = slot_content(&again);
+    assert_eq!(names, want);
+    assert!(slot_edited(again.doc().unwrap(), slot));
+
+    // Resetting the slot shows the main's (empty) default content.
+    ex(&mut again, "instance.resetSlot", json!({"id": slot}));
+    assert!(slot_content(&again).1.is_empty());
+}
diff --git a/crates/engine/src/save_format_tests.rs b/crates/engine/src/save_format_tests.rs
new file mode 100644
index 000000000..fc4ca7750
--- /dev/null
+++ b/crates/engine/src/save_format_tests.rs
@@ -0,0 +1,410 @@
+//! Save As can write an experimental `.fig` copy without replacing native save state.
+
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use figcraft_format::Version;
+use serde_json::{Value, json};
+
+use crate::{DocState, EngineError, Session};
+
+struct SaveFiles {
+    dir: PathBuf,
+    files: Vec<PathBuf>,
+}
+
+impl SaveFiles {
+    fn new() -> Self {
+        // Tests run in parallel and the clock can read the same for two of them (macOS counts
+        // microseconds), so a counter keeps their folders apart.
+        static NEXT: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
+        let n = NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+        let stamp = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos();
+        let dir = std::env::temp_dir().join(format!("figcraft-save-formats-{}-{stamp}-{n}", std::process::id()));
+        std::fs::create_dir(&dir).unwrap();
+        Self { dir, files: Vec::new() }
+    }
+
+    fn path(&mut self, name: &str) -> PathBuf {
+        let path = self.dir.join(name);
+        self.files.push(path.clone());
+        path
+    }
+}
+
+impl Drop for SaveFiles {
+    fn drop(&mut self) {
+        for path in &self.files {
+            let _ = std::fs::remove_file(path);
+            let _ = std::fs::remove_dir(path);
+        }
+        let _ = std::fs::remove_dir(&self.dir);
+    }
+}
+
+fn rect(s: &mut Session, name: &str) {
+    s.execute("shape.rectangle", &json!({"name": name, "x": 10, "y": 20, "width": 30, "height": 40})).unwrap();
+}
+
+fn assert_versions_unchanged(after: &[Version], before: &[Version]) {
+    assert_eq!(after.len(), before.len());
+    for (after, before) in after.iter().zip(before) {
+        assert_eq!(
+            (&after.id, &after.name, &after.description, after.time, after.auto),
+            (&before.id, &before.name, &before.description, before.time, before.auto)
+        );
+        assert_eq!(*after.document().unwrap(), *before.document().unwrap());
+    }
+}
+
+fn assert_save_state_unchanged(s: &Session, before: &DocState, recent: &[String]) {
+    let after = s.ds().unwrap();
+    assert_eq!(after.path, before.path);
+    assert_eq!(after.is_dirty(), before.is_dirty());
+    assert_eq!(after.versions_changed, before.versions_changed);
+    assert!(Arc::ptr_eq(&after.doc, &before.doc));
+    assert!(Arc::ptr_eq(&after.saved_doc, &before.saved_doc));
+    assert_eq!(
+        after.preview.as_ref().map(|p| (&p.id, &p.name, p.time, &p.selection, p.page)),
+        before.preview.as_ref().map(|p| (&p.id, &p.name, p.time, &p.selection, p.page))
+    );
+    if let (Some(after), Some(before)) = (&after.preview, &before.preview) {
+        assert!(Arc::ptr_eq(&after.doc, &before.doc));
+    }
+    assert_eq!((&after.selection, after.page), (&before.selection, before.page));
+    assert_versions_unchanged(&after.versions, &before.versions);
+    assert_eq!(after.branches.len(), before.branches.len());
+    for (after, before) in after.branches.iter().zip(&before.branches) {
+        assert_eq!(
+            (&after.id, &after.name, after.time, after.client, after.state),
+            (&before.id, &before.name, before.time, before.client, before.state)
+        );
+        assert_eq!(*after.base, *before.base);
+        assert_eq!(*after.head, *before.head);
+        assert_versions_unchanged(&after.versions, &before.versions);
+    }
+    for (after, before) in [(&after.history.undo, &before.history.undo), (&after.history.redo, &before.history.redo)] {
+        assert_eq!(after.len(), before.len());
+        for (after, before) in after.iter().zip(before) {
+            assert_eq!((&after.label, &after.selection, after.page), (&before.label, &before.selection, before.page));
+            assert!(Arc::ptr_eq(&after.doc, &before.doc));
+        }
+    }
+    assert_eq!(s.prefs.recent_files, recent);
+}
+
+#[test]
+fn first_native_save_uses_chosen_filename_for_an_untitled_document() {
+    let mut files = SaveFiles::new();
+    let path = files.path("Redis.figcraft");
+    let copy = files.path("Redis copy.figcraft");
+    let manual_copy = files.path("Other.figcraft");
+    let mut s = Session::new();
+    s.execute("file.saveAs", &json!({"path": path.to_string_lossy()})).unwrap();
+    assert_eq!(s.ds().unwrap().doc.name, "Redis");
+    assert!(!s.ds().unwrap().is_dirty());
+    assert_eq!(figcraft_format::load_bytes(&std::fs::read(&path).unwrap()).unwrap().0.name, "Redis");
+
+    let mut reopened = Session::empty();
+    reopened.execute("file.open", &json!({"path": path.to_string_lossy()})).unwrap();
+    assert_eq!(reopened.ds().unwrap().doc.name, "Redis");
+
+    s.execute("file.saveAs", &json!({"path": copy.to_string_lossy()})).unwrap();
+    assert_eq!(s.ds().unwrap().doc.name, "Redis copy");
+    s.execute("file.rename", &json!({"name": "Chosen title"})).unwrap();
+    s.execute("file.saveAs", &json!({"path": manual_copy.to_string_lossy()})).unwrap();
+    assert_eq!(s.ds().unwrap().doc.name, "Chosen title");
+}
+
+#[test]
+fn opening_an_older_file_uses_its_filename_only_for_the_default_title() {
+    let mut files = SaveFiles::new();
+    let old_path = files.path("Redis.figcraft");
+    let named_path = files.path("Other.figcraft");
+    let mut original = Session::new();
+    std::fs::write(&old_path, crate::cmd::file::file_bytes(original.ds().unwrap()).unwrap()).unwrap();
+    original.execute("file.rename", &json!({"name": "Chosen title"})).unwrap();
+    std::fs::write(&named_path, crate::cmd::file::file_bytes(original.ds().unwrap()).unwrap()).unwrap();
+
+    let mut reopened = Session::empty();
+    reopened.execute("file.open", &json!({"path": old_path.to_string_lossy()})).unwrap();
+    assert_eq!(reopened.ds().unwrap().doc.name, "Redis");
+    reopened.execute("file.open", &json!({"path": named_path.to_string_lossy()})).unwrap();
+    assert_eq!(reopened.ds().unwrap().doc.name, "Chosen title");
+}
+
+fn read_fig(path: &std::path::Path, result: &Value) -> figcraft_doc::Document {
+    let bytes = std::fs::read(path).unwrap();
+    assert_eq!(result["format"], "fig");
+    assert_eq!(result["bytes"], bytes.len());
+    assert!(result["warnings"].is_array());
+    assert!(figcraft_format::load_bytes(&bytes).is_err(), "a .fig copy must not contain native FigCraft data");
+    figcraft_format::fig::import(&bytes, "Copy").unwrap().0
+}
+
+#[test]
+fn fig_save_as_keeps_native_path_dirty_state_and_history() {
+    let mut files = SaveFiles::new();
+    let native = files.path("design.figcraft");
+    let copy = files.path("copy.fig");
+    let mut s = Session::new();
+    rect(&mut s, "Saved rectangle");
+    s.execute("file.saveAs", &json!({"path": native.to_string_lossy()})).unwrap();
+    let saved = std::fs::read(&native).unwrap();
+    rect(&mut s, "New rectangle");
+    s.execute("comment.add", &json!({"x": 0, "y": 0, "text": "Copy warning"})).unwrap();
+    s.execute("file.saveVersion", &json!({"name": "Before copy"})).unwrap();
+    rect(&mut s, "Undone rectangle");
+    s.undo().unwrap();
+    let before = s.ds().unwrap().clone();
+    let recent = s.prefs.recent_files.clone();
+    assert!(before.is_dirty());
+    assert!(!before.history.redo.is_empty());
+
+    let result = s.execute("file.saveAs", &json!({"path": copy.to_string_lossy()})).unwrap();
+    let imported = read_fig(&copy, &result);
+    assert!(imported.nodes().any(|n| n.name == "New rectangle"));
+    assert!(!imported.nodes().any(|n| n.name == "Undone rectangle"));
+    assert!(result["warnings"].as_array().unwrap().iter().any(|w| w == "comments were left out"));
+    assert_save_state_unchanged(&s, &before, &recent);
+    assert_eq!(std::fs::read(&native).unwrap(), saved);
+
+    s.execute("file.save", &json!({})).unwrap();
+    assert!(!s.ds().unwrap().is_dirty());
+    assert_eq!(s.ds().unwrap().path.as_deref(), native.to_str());
+    let persisted = figcraft_format::load_bytes_with_versions(&std::fs::read(&native).unwrap()).unwrap();
+    assert!(persisted.doc.nodes().any(|n| n.name == "New rectangle"));
+    assert_eq!(persisted.versions[0].name, "Before copy");
+    assert_eq!(std::fs::read(&copy).unwrap().len(), result["bytes"].as_u64().unwrap() as usize);
+}
+
+#[test]
+fn unsaved_fig_copy_remains_unsaved() {
+    let mut files = SaveFiles::new();
+    let copy = files.path("unsaved.fig");
+    let mut s = Session::new();
+    rect(&mut s, "Unsaved rectangle");
+    let before = s.ds().unwrap().clone();
+    let recent = s.prefs.recent_files.clone();
+    let result = s.execute("file.saveAs", &json!({"path": copy.to_string_lossy()})).unwrap();
+    assert!(read_fig(&copy, &result).nodes().any(|n| n.name == "Unsaved rectangle"));
+    assert_save_state_unchanged(&s, &before, &recent);
+    assert!(matches!(s.execute("file.save", &json!({})), Err(EngineError::Disabled(..))));
+    assert_eq!(s.ui_requests.last().unwrap().kind, "dialog.saveAs");
+}
+
+#[test]
+fn empty_document_fig_copy_keeps_clean_state() {
+    let mut files = SaveFiles::new();
+    let copy = files.path("empty.fig");
+    let mut s = Session::new();
+    let before = s.ds().unwrap().clone();
+    assert!(!before.is_dirty());
+    let result = s.execute("file.saveAs", &json!({"path": copy.to_string_lossy()})).unwrap();
+    let imported = read_fig(&copy, &result);
+    assert_eq!(imported.pages.len(), 1);
+    assert_eq!(imported.node_count(), 1);
+    assert_save_state_unchanged(&s, &before, &[]);
+}
+
+#[test]
+fn fig_save_commands_accept_uppercase_extension() {
+    let mut files = SaveFiles::new();
+    for (index, command) in ["file.save", "file.saveAs"].into_iter().enumerate() {
+        let copy = files.path(&format!("copy-{index}.FIG"));
+        let mut s = Session::new();
+        rect(&mut s, command);
+        let before = s.ds().unwrap().clone();
+        let result = s.execute(command, &json!({"path": copy.to_string_lossy()})).unwrap();
+        assert!(read_fig(&copy, &result).nodes().any(|n| n.name == command));
+        assert_save_state_unchanged(&s, &before, &[]);
+    }
+}
+
+#[test]
+fn fig_copy_from_branch_exports_active_document_without_saving_main() {
+    let mut files = SaveFiles::new();
+    let native = files.path("main.figcraft");
+    let copy = files.path("branch.fig");
+    let mut s = Session::new();
+    rect(&mut s, "Main rectangle");
+    s.execute("file.save", &json!({"path": native.to_string_lossy()})).unwrap();
+    let saved = std::fs::read(&native).unwrap();
+    s.execute("branch.create", &json!({"name": "Explore"})).unwrap();
+    rect(&mut s, "Branch rectangle");
+    s.execute("file.saveVersion", &json!({"name": "Branch version"})).unwrap();
+    // Branch edits normally sync to main before commands; capture that state before exporting.
+    s.execute("branch.list", &json!({})).unwrap();
+    let branch = s.ds().unwrap().clone();
+    let main = s.docs[0].clone();
+    let recent = s.prefs.recent_files.clone();
+
+    let result = s.execute("file.saveAs", &json!({"path": copy.to_string_lossy()})).unwrap();
+    assert!(read_fig(&copy, &result).nodes().any(|n| n.name == "Branch rectangle"));
+    assert_save_state_unchanged(&s, &branch, &recent);
+    assert_eq!(s.docs[0].path, main.path);
+    assert_eq!(s.docs[0].is_dirty(), main.is_dirty());
+    assert!(Arc::ptr_eq(&s.docs[0].saved_doc, &main.saved_doc));
+    assert!(Arc::ptr_eq(&s.docs[0].doc, &main.doc));
+    assert_eq!(std::fs::read(&native).unwrap(), saved);
+
+    s.execute("file.save", &json!({})).unwrap();
+    let persisted = figcraft_format::load_bytes_with_versions(&std::fs::read(&native).unwrap()).unwrap();
+    assert!(!persisted.doc.nodes().any(|n| n.name == "Branch rectangle"));
+    assert!(persisted.branches[0].head.nodes().any(|n| n.name == "Branch rectangle"));
+    assert_eq!(persisted.branches[0].versions[0].name, "Branch version");
+    assert!(!s.ds().unwrap().is_dirty());
+    assert!(!s.docs[0].is_dirty());
+}
+
+#[test]
+fn fig_copy_write_failure_keeps_save_state() {
+    let mut files = SaveFiles::new();
+    let blocked = files.path("blocked.fig");
+    std::fs::create_dir(&blocked).unwrap();
+    let missing = files.path("missing/copy.fig");
+    let mut s = Session::new();
+    rect(&mut s, "Kept rectangle");
+    s.execute("file.saveVersion", &json!({"name": "Kept version"})).unwrap();
+    rect(&mut s, "Later rectangle");
+    s.execute("version.preview", &json!({"index": 0})).unwrap();
+    let before = s.ds().unwrap().clone();
+    for command in ["file.save", "file.saveAs"] {
+        for path in [&blocked, &missing] {
+            assert!(s.execute(command, &json!({"path": path.to_string_lossy()})).is_err());
+            assert_save_state_unchanged(&s, &before, &[]);
+            assert!(!PathBuf::from(format!("{}.tmp-figcraft", path.display())).exists());
+        }
+    }
+}
+
+#[test]
+fn save_as_without_extension_stays_native() {
+    let mut files = SaveFiles::new();
+    let requested = files.dir.join("native");
+    let native = files.path("native.figcraft");
+    let mut s = Session::new();
+    rect(&mut s, "Native rectangle");
+    let result = s.execute("file.saveAs", &json!({"path": requested.to_string_lossy()})).unwrap();
+    assert_eq!(result["path"], native.to_string_lossy().as_ref());
+    assert_eq!(s.ds().unwrap().path.as_deref(), native.to_str());
+    assert!(!s.ds().unwrap().is_dirty());
+    assert!(!requested.exists());
+    let loaded = figcraft_format::load_bytes(&std::fs::read(native).unwrap()).unwrap();
+    assert!(loaded.0.nodes().any(|n| n.name == "Native rectangle"));
+}
+
+#[test]
+fn fig_copy_of_version_preview_keeps_visible_version_and_save_state() {
+    let mut files = SaveFiles::new();
+    for (index, command) in ["file.save", "file.saveAs"].into_iter().enumerate() {
+        let native = files.path(&format!("current-{index}.figcraft"));
+        let copy = files.path(&format!("version-{index}.FIG"));
+        let mut s = Session::new();
+        rect(&mut s, "A");
+        s.execute("file.saveVersion", &json!({"name": "A only"})).unwrap();
+        s.execute("file.save", &json!({"path": native.to_string_lossy()})).unwrap();
+        let saved = std::fs::read(&native).unwrap();
+        rect(&mut s, "B");
+        s.execute("version.preview", &json!({"index": 0})).unwrap();
+        let before = s.ds().unwrap().clone();
+        let recent = s.prefs.recent_files.clone();
+        assert!(before.preview.is_some());
+        assert!(before.is_dirty());
+
+        let result = s.execute(command, &json!({"path": copy.to_string_lossy()})).unwrap();
+        let imported = read_fig(&copy, &result);
+        assert!(imported.nodes().any(|n| n.name == "A"));
+        assert!(!imported.nodes().any(|n| n.name == "B"), "the copy must export the version shown");
+        assert_save_state_unchanged(&s, &before, &recent);
+        assert_eq!(std::fs::read(&native).unwrap(), saved);
+        s.execute("version.exitPreview", &json!({})).unwrap();
+        assert!(s.doc().unwrap().nodes().any(|n| n.name == "B"));
+    }
+}
+
+#[test]
+fn pending_save_choice_keeps_version_preview() {
+    let mut files = SaveFiles::new();
+    for (index, (command, native_path)) in [("file.saveAs", false), ("file.saveAs", true), ("file.save", false)].into_iter().enumerate() {
+        let mut s = Session::new();
+        rect(&mut s, "A");
+        s.execute("file.saveVersion", &json!({"name": "A only"})).unwrap();
+        if native_path {
+            let native = files.path(&format!("saved-{index}.figcraft"));
+            s.execute("file.save", &json!({"path": native.to_string_lossy()})).unwrap();
+        }
+        rect(&mut s, "B");
+        s.execute("version.preview", &json!({"index": 0})).unwrap();
+        let before = s.ds().unwrap().clone();
+        let recent = s.prefs.recent_files.clone();
+        assert!(matches!(s.execute(command, &json!({})), Err(EngineError::Disabled(..))));
+        assert_eq!(s.ui_requests.last().unwrap().kind, "dialog.saveAs");
+        assert_save_state_unchanged(&s, &before, &recent);
+    }
+}
+
+#[test]
+fn native_save_from_version_preview_writes_current_document() {
+    let mut files = SaveFiles::new();
+    for (index, (command, explicit)) in [("file.save", false), ("file.save", true), ("file.saveAs", true)].into_iter().enumerate() {
+        let native = files.path(&format!("native-version-{index}.figcraft"));
+        let mut s = Session::new();
+        rect(&mut s, "A");
+        s.execute("file.saveVersion", &json!({"name": "A only"})).unwrap();
+        s.execute("file.save", &json!({"path": native.to_string_lossy()})).unwrap();
+        rect(&mut s, "B");
+        s.execute("version.preview", &json!({"index": 0})).unwrap();
+        let undo = s.ds().unwrap().history.undo.len();
+        let params = if explicit { json!({"path": native.to_string_lossy()}) } else { json!({}) };
+        s.execute(command, &params).unwrap();
+        assert!(s.ds().unwrap().preview.is_none());
+        assert!(!s.ds().unwrap().is_dirty());
+        assert_eq!(s.ds().unwrap().history.undo.len(), undo);
+        assert_eq!(s.ds().unwrap().path.as_deref(), native.to_str());
+        let loaded = figcraft_format::load_bytes_with_versions(&std::fs::read(&native).unwrap()).unwrap();
+        assert!(loaded.doc.nodes().any(|n| n.name == "A"));
+        assert!(loaded.doc.nodes().any(|n| n.name == "B"));
+        assert!(!loaded.versions[0].document().unwrap().nodes().any(|n| n.name == "B"));
+    }
+}
+
+#[test]
+fn implicit_save_protects_legacy_fig_destination() {
+    let mut files = SaveFiles::new();
+    for (index, command) in ["file.save", "file.saveAs"].into_iter().enumerate() {
+        let legacy = files.path(&format!("legacy-{index}.FIG"));
+        let native = files.path(&format!("corrected-{index}.figcraft"));
+        let mut s = Session::new();
+        rect(&mut s, "A");
+        s.execute("file.saveVersion", &json!({"name": "A only"})).unwrap();
+        // Earlier builds could write native data under .fig; keep those bytes safe on plain Save.
+        let sentinel = crate::cmd::file::file_bytes(s.ds().unwrap()).unwrap();
+        std::fs::write(&legacy, &sentinel).unwrap();
+        s.ds_mut().unwrap().path = Some(legacy.to_string_lossy().into_owned());
+        s.ds_mut().unwrap().mark_saved();
+        rect(&mut s, "B");
+        s.execute("version.preview", &json!({"index": 0})).unwrap();
+        let before = s.ds().unwrap().clone();
+        let recent = s.prefs.recent_files.clone();
+
+        assert!(matches!(s.execute("file.save", &json!({})), Err(EngineError::Disabled(..))));
+        assert_eq!(s.ui_requests.last().unwrap().kind, "dialog.saveAs");
+        assert_save_state_unchanged(&s, &before, &recent);
+        assert_eq!(std::fs::read(&legacy).unwrap(), sentinel);
+
+        s.execute(command, &json!({"path": native.to_string_lossy()})).unwrap();
+        assert!(s.ds().unwrap().preview.is_none());
+        assert!(!s.ds().unwrap().is_dirty());
+        assert_eq!(s.ds().unwrap().path.as_deref(), native.to_str());
+        let loaded = figcraft_format::load_bytes_with_versions(&std::fs::read(&native).unwrap()).unwrap();
+        assert!(loaded.doc.nodes().any(|n| n.name == "A"));
+        assert!(loaded.doc.nodes().any(|n| n.name == "B"));
+        assert_eq!(loaded.versions[0].name, "A only");
+        rect(&mut s, "C");
+        s.execute("file.save", &json!({})).unwrap();
+        let loaded = figcraft_format::load_bytes(&std::fs::read(&native).unwrap()).unwrap();
+        assert!(loaded.0.nodes().any(|n| n.name == "C"));
+        assert_eq!(std::fs::read(&legacy).unwrap(), sentinel);
+    }
+}
diff --git a/crates/engine/src/selection_behaviour_tests.rs b/crates/engine/src/selection_behaviour_tests.rs
index b65b79363..ef5869b22 100644
--- a/crates/engine/src/selection_behaviour_tests.rs
+++ b/crates/engine/src/selection_behaviour_tests.rs
@@ -275,3 +275,135 @@ fn locked_layers_selected_in_the_layers_panel_stay_put() {
     ex(&mut s, "object.toggleLock", json!({"ids": [k.g], "locked": true}));
     assert_eq!(handle_at(s.doc().unwrap(), &[k.a], Point::new(60.0, 60.0), 1.0), None);
 }
+
+#[test]
+fn shift_drag_moves_the_selection() {
+    let mut s = Session::new();
+    let k = scene(&mut s);
+    let at = |s: &Session, i: NodeId| s.doc().unwrap().world_bounds(i).unwrap().origin();
+    let home = (Point::new(500.0, 0.0), Point::new(600.0, 0.0));
+    // (selection before, Shift-drag to (from r at 520,20), selection after, where r and empty end up, derivation)
+    let rows: Vec<(Vec<NodeId>, (f64, f64), Vec<NodeId>, (Point, Point), &str)> = vec![
+        (
+            vec![k.r],
+            (560.0, 22.0),
+            vec![k.r],
+            (Point::new(540.0, 0.0), Point::new(600.0, 0.0)),
+            "Shift-drag on the selected layer moves it along one axis and keeps it selected",
+        ),
+        (
+            vec![k.r, k.empty],
+            (560.0, 22.0),
+            vec![k.r, k.empty],
+            (Point::new(540.0, 0.0), Point::new(640.0, 0.0)),
+            "Shift-drag on one of several selected layers moves them all",
+        ),
+        (
+            vec![k.empty],
+            (560.0, 22.0),
+            vec![k.r, k.empty],
+            (Point::new(540.0, 0.0), Point::new(640.0, 0.0)),
+            "Shift-drag on an unselected layer adds it and moves the selection",
+        ),
+        (vec![k.r, k.empty], (521.0, 21.0), vec![k.empty], home, "a Shift-press that wobbles under the drag threshold is a click: the layer leaves"),
+    ];
+    for (before, to, after, end, why) in rows {
+        ex(&mut s, "select.set", json!({"ids": before}));
+        drag(&mut s, (520.0, 20.0), to, SHIFT);
+        assert_eq!(sorted(s.selection()), sorted(after), "{why}");
+        assert_eq!((at(&s, k.r), at(&s, k.empty)), end, "{why}");
+        if end != home {
+            assert!(s.undo().unwrap(), "{why}: one undo step");
+            assert_eq!((at(&s, k.r), at(&s, k.empty)), home, "{why}: undone");
+        }
+    }
+    // Shift let go before the button: still a Shift-click.
+    ex(&mut s, "select.set", json!({"ids": [k.r, k.empty]}));
+    s.pointer(&ev(PointerKind::Down, 520.0, 20.0, SHIFT)).unwrap();
+    s.pointer(&ev(PointerKind::Up, 520.0, 20.0, NONE)).unwrap();
+    assert_eq!(s.selection(), vec![k.empty], "Shift let go before the button still takes the layer out");
+}
+
+#[test]
+fn a_drag_inside_the_selection_box_moves_it_where_nothing_is_hit() {
+    let mut s = Session::new();
+    let k = scene(&mut s);
+    for i in [k.r, k.c] {
+        ex(&mut s, "node.set", json!({"ids": [i], "props": {"fills": [], "strokes": ["#000000"], "strokeWeight": 1}}));
+    }
+    let at = |s: &Session, i: NodeId| s.doc().unwrap().world_bounds(i).unwrap().origin();
+    // (selection before, drag from, selection after, the layers that move by (10, 10), derivation)
+    let rows: Vec<(Vec<NodeId>, (f64, f64), Vec<NodeId>, Vec<NodeId>, &str)> = vec![
+        (vec![k.r], (520.0, 20.0), vec![k.r], vec![k.r], "a selected unfilled shape drags from its inside, not only its stroke"),
+        (vec![k.c], (40.0, 140.0), vec![k.c], vec![k.c], "the same in a top-level frame, whose background is under the inside"),
+        (vec![k.r, k.empty], (570.0, 20.0), vec![k.r, k.empty], vec![k.r, k.empty], "a gap inside a multiple selection's box drags them all"),
+        (vec![], (520.0, 20.0), vec![k.r], vec![], "an unselected unfilled shape is hit on its stroke only: the drag is a marquee, which touches it"),
+    ];
+    for (before, from, after, moved, why) in rows {
+        let home: Vec<Point> = [k.r, k.c, k.empty].iter().map(|i| at(&s, *i)).collect();
+        ex(&mut s, "select.set", json!({"ids": before}));
+        drag(&mut s, from, (from.0 + 10.0, from.1 + 10.0), NONE);
+        assert_eq!(sorted(s.selection()), sorted(after), "{why}");
+        for (i, h) in [k.r, k.c, k.empty].iter().zip(&home) {
+            let d = if moved.contains(i) { 10.0 } else { 0.0 };
+            assert_eq!(at(&s, *i), Point::new(h.x + d, h.y + d), "{why}");
+        }
+        if !moved.is_empty() {
+            assert!(s.undo().unwrap(), "{why}: one undo step");
+        }
+    }
+    // A turned layer's box is turned with it: the corners of its page-aligned bounds are outside.
+    ex(&mut s, "node.set", json!({"ids": [k.r], "props": {"rotation": 45}}));
+    let b = s.doc().unwrap().world_bounds(k.r).unwrap();
+    ex(&mut s, "select.set", json!({"ids": [k.r]}));
+    drag(&mut s, (b.x0 + 2.0, b.y0 + 2.0), (b.x0 + 12.0, b.y0 + 12.0), NONE);
+    assert_eq!(at(&s, k.r), b.origin(), "a press outside a turned layer's box is a marquee: it doesn't move the layer");
+    ex(&mut s, "select.set", json!({"ids": [k.r]}));
+    let c = b.center();
+    drag(&mut s, (c.x, c.y), (c.x + 10.0, c.y + 10.0), NONE);
+    assert_eq!(s.selection(), vec![k.r], "inside the turned box it drags");
+    // Pixel snapping rounds the turned box's origin, so the move is about the pointer's.
+    let d = at(&s, k.r) - b.origin();
+    assert!((d.x - 10.0).abs() < 2.0 && (d.y - 10.0).abs() < 2.0, "it moves with the pointer: {d:?}");
+}
+
+#[test]
+fn alt_shift_drag_on_a_selected_layer_duplicates_it() {
+    let mut s = Session::new();
+    let k = scene(&mut s);
+    let layers = |s: &Session| s.doc().unwrap().node(s.page().unwrap()).unwrap().children.len();
+    let n = layers(&s);
+    let alt_shift = |kind, x, y| {
+        let mut e = ev(kind, x, y, SHIFT);
+        e.alt = true;
+        e
+    };
+    ex(&mut s, "select.set", json!({"ids": [k.r]}));
+    s.pointer(&alt_shift(PointerKind::Down, 520.0, 20.0)).unwrap();
+    s.pointer(&alt_shift(PointerKind::Up, 520.0, 20.0)).unwrap();
+    assert_eq!(s.selection(), Vec::<NodeId>::new(), "an Alt+Shift-click is a Shift-click: the layer leaves the selection");
+    assert_eq!(layers(&s), n, "and nothing is copied");
+    ex(&mut s, "select.set", json!({"ids": [k.r]}));
+    s.pointer(&alt_shift(PointerKind::Down, 520.0, 20.0)).unwrap();
+    s.pointer(&alt_shift(PointerKind::Move, 560.0, 22.0)).unwrap();
+    s.pointer(&alt_shift(PointerKind::Up, 560.0, 22.0)).unwrap();
+    let sel = s.selection();
+    assert_eq!(layers(&s), n + 1, "an Alt+Shift-drag copies the layer");
+    assert!(sel.len() == 1 && sel[0] != k.r, "the copy is selected");
+    let doc = s.doc().unwrap();
+    assert_eq!(doc.world_bounds(sel[0]).unwrap().origin(), Point::new(540.0, 0.0), "the copy moves along one axis");
+    assert_eq!(doc.world_bounds(k.r).unwrap().origin(), Point::new(500.0, 0.0), "the original stays");
+}
+
+#[test]
+fn shift_click_takes_a_layer_out_where_nothing_can_move() {
+    let mut s = Session::new();
+    let k = scene(&mut s);
+    // A version being viewed is read-only: the press can't start a move.
+    let v = ex(&mut s, "file.saveVersion", json!({"name": "v"}));
+    ex(&mut s, "version.preview", json!({"id": v["id"]}));
+    ex(&mut s, "select.set", json!({"ids": [k.r, k.empty]}));
+    assert!(s.pointer(&ev(PointerKind::Down, 520.0, 20.0, SHIFT)).is_err(), "a version being viewed can't be edited");
+    s.pointer(&ev(PointerKind::Up, 520.0, 20.0, SHIFT)).unwrap();
+    assert_eq!(s.selection(), vec![k.empty], "Shift-click still takes the layer out");
+}
diff --git a/crates/engine/src/selection_colors.rs b/crates/engine/src/selection_colors.rs
new file mode 100644
index 000000000..875c6416b
--- /dev/null
+++ b/crates/engine/src/selection_colors.rs
@@ -0,0 +1,218 @@
+//! Paints used by the selection, including descendants and effective text-range fills.
+//! Targets name paint slots rather than colors: a live edit must not capture other slots when
+//! its color happens to become equal to another selection color.
+
+use std::collections::{BTreeMap, BTreeSet};
+
+use figcraft_color::{Paint, PaintKind};
+use figcraft_doc::{Document, NodeId, NodeKind, StyleKind};
+use serde::{Deserialize, Serialize};
+use serde_json::{Value, json};
+
+use crate::cmd::lists::{BoundList, list_binding, rebind_edited_paint};
+use crate::params::*;
+use crate::{CommandSpec, Result, Session, bad, spec};
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub struct PaintTarget {
+    pub id: NodeId,
+    pub fills: bool,
+    pub index: usize,
+    /// Character offsets, not byte offsets. None means the node's fill or stroke list.
+    pub range: Option<(usize, usize)>,
+}
+
+impl PaintTarget {
+    pub fn paints(&self, doc: &Document) -> Option<Vec<Paint>> {
+        let n = doc.node(self.id)?;
+        if let Some((start, end)) = self.range {
+            let t = n.kind.text()?;
+            if !self.fills || start > end || end > t.char_count() || (start == end && end != 0) {
+                return None;
+            }
+            Some(t.style_at(start).fills.clone().unwrap_or_else(|| n.fills.clone()))
+        } else {
+            Some(if self.fills { n.fills.clone() } else { n.strokes.clone() })
+        }
+    }
+
+    pub fn paint(&self, doc: &Document) -> Option<Paint> {
+        self.paints(doc)?.get(self.index).cloned()
+    }
+}
+
+#[derive(Clone, Debug, Serialize)]
+pub struct SelectionColor {
+    pub paint: Paint,
+    pub style: Option<String>,
+    pub variable: Option<String>,
+    pub targets: Vec<PaintTarget>,
+}
+
+/// Deterministic order, one target per slot even when a parent and child are both selected.
+/// Images and patterns are assets rather than selection colors. Hidden paints are omitted.
+pub fn collect(doc: &Document, ids: &[NodeId]) -> Vec<SelectionColor> {
+    let mut groups: Vec<SelectionColor> = Vec::new();
+    let mut seen = BTreeSet::new();
+    let mut by_paint: BTreeMap<(Option<String>, Option<String>, String), usize> = BTreeMap::new();
+    let mut pending: Vec<_> = ids.iter().rev().copied().collect();
+    while let Some(id) = pending.pop() {
+        if !seen.insert(id) {
+            continue;
+        }
+        let Some(n) = doc.node(id) else { continue };
+        if n.is_mask {
+            continue;
+        }
+        if !matches!(n.kind, NodeKind::BooleanOp { .. }) {
+            pending.extend(n.children.iter().rev().copied());
+        }
+        let mut add = |paints: &[Paint], fills: bool, range: Option<(usize, usize)>| {
+            for (index, paint) in paints.iter().enumerate() {
+                if !paint.visible || !matches!(paint.kind, PaintKind::Solid { .. } | PaintKind::Gradient(_)) {
+                    continue;
+                }
+                let target = PaintTarget { id, fills, index, range };
+                let inherited = range.is_none_or(|(start, _)| n.kind.text().is_some_and(|t| t.style_at(start).fills.is_none()));
+                let style = inherited.then(|| if fills { n.styles.fill.clone() } else { n.styles.stroke.clone() }).flatten();
+                let list = if fills { BoundList::Fills } else { BoundList::Strokes };
+                let variable = inherited
+                    .then(|| {
+                        n.bound.iter().find_map(|(key, var)| {
+                            list_binding(key).filter(|(l, i, field)| *l == list && *i == index && *field == "color").map(|_| var.clone())
+                        })
+                    })
+                    .flatten();
+                let Ok(value) = serde_json::to_string(paint) else { continue };
+                let key = (style.clone(), variable.clone(), value);
+                if let Some(index) = by_paint.get(&key).copied() {
+                    if let Some(g) = groups.get_mut(index) {
+                        g.targets.push(target);
+                    }
+                } else {
+                    by_paint.insert(key, groups.len());
+                    groups.push(SelectionColor { paint: paint.clone(), style, variable, targets: vec![target] });
+                }
+            }
+        };
+        if let NodeKind::Text(t) = &n.kind {
+            let spans = t.spans();
+            if spans.iter().all(|(_, _, style)| style.fills.is_none()) {
+                add(&n.fills, true, None);
+            } else {
+                for (start, end, style) in spans {
+                    add(style.fills.as_deref().unwrap_or(&n.fills), true, Some((start, end)));
+                }
+            }
+        } else {
+            add(&n.fills, true, None);
+        }
+        add(&n.strokes, false, None);
+    }
+    groups
+}
+
+pub fn specs() -> Vec<CommandSpec> {
+    vec![
+        spec!(
+            "selection.colors",
+            "Selection colors",
+            "{ids?} → {colors: [{paint, targets}]}; includes descendants and text ranges",
+            false,
+            |s, p| { Ok(json!({"colors": collect(s.doc()?, &targets(s, p))})) }
+        ),
+        spec!("selection.setPaint", "Change selection color", "{targets: [{id, fills, index, range: [start,end] | null}], paint}", true, set_paint),
+        spec!(
+            "selection.applyColorStyle",
+            "Apply selection color style",
+            "{targets, style}; applies the color style to matching fill/stroke lists (text ranges keep typography)",
+            true,
+            apply_style
+        ),
+        spec!(
+            "selection.selectColor",
+            "Select layers with color",
+            "{targets} → {ids}; selects the layers owning these paint slots",
+            false,
+            select_color
+        ),
+    ]
+}
+
+fn checked_targets(s: &Session, p: &Value, cmd: &str) -> Result<Vec<PaintTarget>> {
+    let ts: Vec<PaintTarget> = parse(cmd, p, "targets")?.ok_or_else(|| bad(cmd, "`targets` is required"))?;
+    if ts.is_empty() {
+        return Err(bad(cmd, "`targets` must not be empty"));
+    }
+    for t in &ts {
+        if t.paint(s.doc()?).is_none() {
+            return Err(bad(cmd, "a selection color target no longer exists"));
+        }
+    }
+    Ok(ts)
+}
+
+fn set_paint(s: &mut Session, p: &Value) -> Result<Value> {
+    const CMD: &str = "selection.setPaint";
+    let targets = checked_targets(s, p, CMD)?;
+    let paint = get(p, "paint").and_then(paint_of).ok_or_else(|| bad(CMD, "`paint` must be a paint"))?;
+    for target in &targets {
+        let mut paints = target.paints(s.doc()?).ok_or_else(|| bad(CMD, "invalid target"))?;
+        let Some(slot) = paints.get_mut(target.index) else { return Err(bad(CMD, "invalid paint index")) };
+        if *slot == paint {
+            continue;
+        }
+        let old = slot.clone();
+        *slot = paint.clone();
+        let n = s.doc_mut()?.get_mut(target.id)?;
+        // Variables detach only where the edit changed their value; range fills override the node's
+        // paints, whose bindings still belong to the other characters.
+        if let Some((start, end)) = target.range {
+            if let NodeKind::Text(t) = &mut n.kind {
+                t.restyle(start, end, |style| style.fills = Some(paints.clone()));
+            }
+            continue;
+        }
+        if target.fills {
+            n.fills = paints;
+            n.styles.fill = None;
+        } else {
+            n.strokes = paints;
+            n.styles.stroke = None;
+        }
+        rebind_edited_paint(n, target.fills, target.index, &old);
+    }
+    Ok(json!({"ok": true}))
+}
+
+fn apply_style(s: &mut Session, p: &Value) -> Result<Value> {
+    const CMD: &str = "selection.applyColorStyle";
+    let targets = checked_targets(s, p, CMD)?;
+    let name = req_string(CMD, p, "style")?;
+    let style = s.doc()?.style(&name).cloned().ok_or_else(|| bad(CMD, "no such color style"))?;
+    if !matches!(style.kind, StyleKind::Paint { .. }) {
+        return Err(bad(CMD, "a color style is required"));
+    }
+    for target in &targets {
+        if let Some((start, end)) = target.range {
+            // Text ranges have typography-style links, not paint-style links. Copy resolved paint
+            // values just as an explicit range fill does; never replace its font or size.
+            let StyleKind::Paint { paints } = crate::style_vars::kind_for(s.doc()?, &style, target.id).into_owned() else { continue };
+            let n = s.doc_mut()?.get_mut(target.id)?;
+            if let NodeKind::Text(t) = &mut n.kind {
+                t.restyle(start, end, |st| st.fills = Some(paints.clone()));
+            }
+        } else {
+            crate::cmd::styles::apply_style_ref(s.doc_mut()?, target.id, if target.fills { "fillStyle" } else { "strokeStyle" }, Some(&style.id))?;
+        }
+    }
+    Ok(json!({"ok": true}))
+}
+
+fn select_color(s: &mut Session, p: &Value) -> Result<Value> {
+    let ts = checked_targets(s, p, "selection.selectColor")?;
+    let ids: Vec<_> = ts.iter().map(|t| t.id).collect::<BTreeSet<_>>().into_iter().collect();
+    crate::cmd::edit::select_and_page(s, ids.clone())?;
+    Ok(json!({"ids": ids}))
+}
diff --git a/crates/engine/src/selection_reorder.rs b/crates/engine/src/selection_reorder.rs
new file mode 100644
index 000000000..d54109c79
--- /dev/null
+++ b/crates/engine/src/selection_reorder.rs
@@ -0,0 +1,106 @@
+//! Geometry for reordering a smart selection. Only regular, non-overlapping rows, columns
+//! and complete top-left-aligned grids have unambiguous insertion slots.
+//! Marking several items and irregular grids are out of scope.
+use figcraft_doc::{Document, NodeId};
+use figcraft_geom::{Point, Rect};
+
+use crate::selection_spacing::selection_spacing;
+
+#[derive(Clone, Debug)]
+pub struct ReorderLayout {
+    /// Visual order, independent of selection order and layer stacking.
+    pub slots: Vec<(NodeId, Rect)>,
+    columns: usize,
+    rows: usize,
+    gap_x: f64,
+    gap_y: f64,
+}
+
+impl ReorderLayout {
+    pub fn new(doc: &Document, ids: &[NodeId]) -> Option<Self> {
+        let layout = selection_spacing(doc, ids);
+        let h = layout.horizontal.as_ref();
+        let v = layout.vertical.as_ref();
+        let gap = |axis: Option<&crate::selection_spacing::Axis>| match axis {
+            Some(a) => a.value.filter(|v| *v >= 0.0),
+            None => Some(0.0),
+        };
+        let (gap_x, gap_y) = (gap(h)?, gap(v)?);
+        let columns = h.map_or(1, |a| a.tracks.len());
+        let rows = v.map_or(1, |a| a.tracks.len());
+        if ids.len() < 2 || columns.checked_mul(rows)? != ids.len() {
+            return None;
+        }
+        let mut cells = std::collections::BTreeMap::new();
+        for id in ids {
+            let col = match h {
+                Some(a) => a.tracks.iter().position(|t| t.ids.contains(id))?,
+                None => 0,
+            };
+            let row = match v {
+                Some(a) => a.tracks.iter().position(|t| t.ids.contains(id))?,
+                None => 0,
+            };
+            let b = doc.world_bounds(*id)?;
+            if columns > 1 && rows > 1 {
+                let x = h?.tracks.get(col)?.bounds.x0;
+                let y = v?.tracks.get(row)?.bounds.y0;
+                if (b.x0 - x).abs() > 0.01 || (b.y0 - y).abs() > 0.01 {
+                    return None;
+                }
+            }
+            if cells.insert((row, col), (*id, b)).is_some() {
+                return None;
+            }
+        }
+        Some(Self { slots: cells.into_values().collect(), columns, rows, gap_x, gap_y })
+    }
+
+    /// Insertion shifts intervening items; swapping exchanges just two entries. Sizes and
+    /// original gaps are retained, so unequal-sized layers reflow instead of overlapping.
+    pub fn positions(&self, source: NodeId, target: NodeId, swap: bool) -> Option<Vec<(NodeId, Point)>> {
+        let from = self.slots.iter().position(|(id, _)| *id == source)?;
+        let to = self.slots.iter().position(|(id, _)| *id == target)?;
+        if from == to {
+            return Some(self.slots.iter().map(|(id, b)| (*id, Point::new(b.x0, b.y0))).collect());
+        }
+        let mut order = self.slots.clone();
+        if swap {
+            order.swap(from, to);
+        } else {
+            let item = order.remove(from);
+            order.insert(to, item);
+        }
+        let mut widths = vec![0.0_f64; self.columns];
+        let mut heights = vec![0.0_f64; self.rows];
+        for (i, (_, b)) in order.iter().enumerate() {
+            let w = widths.get_mut(i % self.columns)?;
+            *w = w.max(b.width());
+            let h = heights.get_mut(i / self.columns)?;
+            *h = h.max(b.height());
+        }
+        let x0 = self.slots.iter().map(|(_, b)| b.x0).fold(f64::INFINITY, f64::min);
+        let y0 = self.slots.iter().map(|(_, b)| b.y0).fold(f64::INFINITY, f64::min);
+        let starts = |sizes: &[f64], mut at: f64, gap: f64| {
+            sizes
+                .iter()
+                .map(|size| {
+                    let start = at;
+                    at += size + gap;
+                    start
+                })
+                .collect::<Vec<_>>()
+        };
+        let xs = starts(&widths, x0, self.gap_x);
+        let ys = starts(&heights, y0, self.gap_y);
+        order
+            .iter()
+            .enumerate()
+            .map(|(i, (id, b))| {
+                let x = if self.columns == 1 { b.x0 } else { *xs.get(i % self.columns)? };
+                let y = if self.rows == 1 { b.y0 } else { *ys.get(i / self.columns)? };
+                Some((*id, Point::new(x, y)))
+            })
+            .collect()
+    }
+}
diff --git a/crates/engine/src/selection_reorder_tests.rs b/crates/engine/src/selection_reorder_tests.rs
new file mode 100644
index 000000000..83ae5b310
--- /dev/null
+++ b/crates/engine/src/selection_reorder_tests.rs
@@ -0,0 +1,152 @@
+use crate::{Session, selection_reorder::ReorderLayout};
+use figcraft_doc::NodeId;
+use serde_json::json;
+
+fn rect(s: &mut Session, x: f64, y: f64, w: f64, h: f64, parent: Option<NodeId>) -> NodeId {
+    NodeId(s.execute("shape.rectangle", &json!({"x":x,"y":y,"width":w,"height":h,"parent":parent})).unwrap()["id"].as_u64().unwrap())
+}
+fn xy(s: &Session, id: NodeId) -> (f64, f64) {
+    let b = s.doc().unwrap().world_bounds(id).unwrap();
+    (b.x0, b.y0)
+}
+
+#[test]
+fn insertion_reflows_unequal_sizes_with_original_gaps_and_hierarchy() {
+    for vertical in [false, true] {
+        let mut s = Session::new();
+        let mut ids = vec![];
+        for (at, size) in [(0., 40.), (50., 60.), (120., 20.)] {
+            ids.push(rect(
+                &mut s,
+                if vertical { 0. } else { at },
+                if vertical { at } else { 0. },
+                if vertical { 30. } else { size },
+                if vertical { size } else { 30. },
+                None,
+            ));
+        }
+        let before = s.doc().unwrap().clone();
+        // Explicit selection order must not determine visual order.
+        s.execute("arrange.reorder", &json!({"ids":[ids[2],ids[0],ids[1]],"source":ids[0],"target":ids[2]})).unwrap();
+        for (id, at) in [(ids[1], 0.), (ids[2], 70.), (ids[0], 100.)] {
+            assert_eq!(xy(&s, id), if vertical { (0., at) } else { (at, 0.) });
+            let old = before.node(id).unwrap();
+            let new = s.doc().unwrap().node(id).unwrap();
+            assert_eq!((new.width, new.height, new.parent), (old.width, old.height, old.parent));
+        }
+        assert_eq!(s.doc().unwrap().node(s.ds().unwrap().page).unwrap().children, before.node(s.ds().unwrap().page).unwrap().children);
+        s.undo().unwrap();
+        assert_eq!(s.doc().unwrap(), &before);
+        s.redo().unwrap();
+        assert_eq!(xy(&s, ids[0]), if vertical { (0., 100.) } else { (100., 0.) });
+    }
+}
+
+#[test]
+fn grids_insert_across_rows_and_swap_only_the_two_entries() {
+    let mut s = Session::new();
+    let mut ids = vec![];
+    for row in 0..2 {
+        for col in 0..3 {
+            ids.push(rect(&mut s, col as f64 * 70., row as f64 * 60., 50., 40., None));
+        }
+    }
+    let before = s.doc().unwrap().clone();
+    s.execute("arrange.reorder", &json!({"ids":ids,"source":ids[0],"target":ids[4]})).unwrap();
+    assert_eq!(xy(&s, ids[0]), (70., 60.));
+    assert_eq!(xy(&s, ids[3]), (140., 0.));
+    assert_eq!(xy(&s, ids[5]), (140., 60.));
+    s.undo().unwrap();
+    s.execute("arrange.reorder", &json!({"ids":ids,"source":ids[0],"target":ids[4],"swap":true})).unwrap();
+    assert_eq!(xy(&s, ids[0]), (70., 60.));
+    assert_eq!(xy(&s, ids[4]), (0., 0.));
+    for id in [ids[1], ids[2], ids[3], ids[5]] {
+        assert_eq!(s.doc().unwrap().node(id), before.node(id));
+    }
+}
+
+#[test]
+fn grid_reflow_keeps_gaps_with_different_sizes() {
+    let mut s = Session::new();
+    let a = rect(&mut s, 0., 0., 40., 30., None);
+    let b = rect(&mut s, 50., 0., 60., 30., None);
+    let c = rect(&mut s, 0., 50., 40., 50., None);
+    let d = rect(&mut s, 50., 50., 60., 50., None);
+    s.execute("arrange.reorder", &json!({"ids":[a,b,c,d],"source":a,"target":d})).unwrap();
+    assert_eq!(xy(&s, b), (0., 0.));
+    assert_eq!(xy(&s, c), (70., 0.));
+    assert_eq!(xy(&s, d), (0., 70.));
+    assert_eq!(xy(&s, a), (70., 70.));
+}
+
+#[test]
+fn previews_are_absolute_and_returning_to_start_is_a_noop() {
+    let mut s = Session::new();
+    let ids: Vec<_> = (0..3).map(|i| rect(&mut s, i as f64 * 70., 0., 50., 40., None)).collect();
+    s.execute("select.set", &json!({"ids":ids})).unwrap();
+    let before = s.doc().unwrap().clone();
+    let history = s.undo_depth().0;
+    s.begin_interaction("Reorder selection").unwrap();
+    for target in [ids[2], ids[1], ids[0]] {
+        s.execute("arrange.reorder", &json!({"ids":ids,"source":ids[0],"target":target,"fromGesture":true})).unwrap();
+    }
+    s.commit_interaction().unwrap();
+    assert_eq!(s.doc().unwrap(), &before);
+    assert_eq!(s.undo_depth().0, history);
+    s.begin_interaction("Reorder selection").unwrap();
+    for target in [ids[1], ids[2]] {
+        s.execute("arrange.reorder", &json!({"ids":ids,"source":ids[0],"target":target,"fromGesture":true})).unwrap();
+    }
+    s.commit_interaction().unwrap();
+    assert_eq!(s.undo_depth().0, history + 1);
+    assert_eq!(s.selection(), ids);
+    s.undo().unwrap();
+    assert_eq!(s.doc().unwrap(), &before);
+}
+
+#[test]
+fn invalid_selections_and_targets_do_not_edit_the_document() {
+    let mut s = Session::new();
+    let a = rect(&mut s, 0., 0., 50., 40., None);
+    let b = rect(&mut s, 70., 0., 50., 40., None);
+    let c = rect(&mut s, 160., 0., 50., 40., None);
+    for args in [
+        json!({"ids":[a,b,c],"source":a,"target":b}), // Mixed gaps.
+        json!({"ids":[a,b],"source":c,"target":b}),
+        json!({"ids":[a,b],"source":a,"target":999999}),
+        json!({"ids":[a,a,b],"source":a,"target":b}),
+        json!({"ids":[a,b],"source":[],"target":b}),
+    ] {
+        let before = s.doc().unwrap().clone();
+        assert!(s.execute("arrange.reorder", &args).is_err());
+        assert_eq!(s.doc().unwrap(), &before);
+    }
+    for props in [json!({"locked":true}), json!({"visible":false})] {
+        s.execute("node.set", &json!({"id":b,"props":props})).unwrap();
+        assert!(ReorderLayout::new(s.doc().unwrap(), &[a, b]).is_none());
+        s.execute("node.set", &json!({"id":b,"props":{"locked":false,"visible":true}})).unwrap();
+    }
+    let d = rect(&mut s, 0., 70., 50., 40., None);
+    assert!(ReorderLayout::new(s.doc().unwrap(), &[a, b, d]).is_none(), "an incomplete grid has no slots");
+    let frame =
+        NodeId(s.execute("frame.create", &json!({"width":300,"height":100,"props":{"layout":"horizontal"}})).unwrap()["id"].as_u64().unwrap());
+    let x = rect(&mut s, 0., 0., 50., 40., Some(frame));
+    let y = rect(&mut s, 70., 0., 50., 40., Some(frame));
+    assert!(ReorderLayout::new(s.doc().unwrap(), &[x, y]).is_none());
+    assert!(ReorderLayout::new(s.doc().unwrap(), &[a, x]).is_none());
+}
+
+#[test]
+fn reordering_children_of_a_rotated_parent_uses_page_coordinates() {
+    let mut s = Session::new();
+    let frame = NodeId(
+        s.execute("frame.create", &json!({"x":200,"y":200,"width":300,"height":100,"props":{"rotation":90}})).unwrap()["id"].as_u64().unwrap(),
+    );
+    let a = rect(&mut s, 0., 0., 50., 40., Some(frame));
+    let b = rect(&mut s, 70., 0., 50., 40., Some(frame));
+    let (pa, pb) = (xy(&s, a), xy(&s, b));
+    s.execute("arrange.reorder", &json!({"ids":[a,b],"source":a,"target":b})).unwrap();
+    let (qa, qb) = (xy(&s, a), xy(&s, b));
+    assert!((qa.0 - pb.0).abs() < 1e-7 && (qa.1 - pb.1).abs() < 1e-7);
+    assert!((qb.0 - pa.0).abs() < 1e-7 && (qb.1 - pa.1).abs() < 1e-7);
+}
diff --git a/crates/engine/src/selection_spacing.rs b/crates/engine/src/selection_spacing.rs
new file mode 100644
index 000000000..8592a4532
--- /dev/null
+++ b/crates/engine/src/selection_spacing.rs
@@ -0,0 +1,132 @@
+//! Smart-selection spacing in page coordinates. Tracks contain aligned siblings (columns for
+//! horizontal spacing, rows for vertical spacing); moving a track preserves its internal layout.
+use figcraft_doc::{Document, NodeId, NodeKind};
+use figcraft_geom::Rect;
+
+const EPS: f64 = 0.01;
+
+#[derive(Clone, Debug)]
+pub struct Track {
+    pub ids: Vec<NodeId>,
+    pub bounds: Rect,
+    anchor: Rect,
+}
+
+#[derive(Clone, Debug)]
+pub struct Axis {
+    pub tracks: Vec<Track>,
+    pub vertical: bool,
+    /// None means the existing distances are mixed; setting a value makes them uniform.
+    pub value: Option<f64>,
+}
+
+impl Axis {
+    pub fn start(&self, b: Rect) -> f64 {
+        if self.vertical { b.y0 } else { b.x0 }
+    }
+    pub fn end(&self, b: Rect) -> f64 {
+        if self.vertical { b.y1 } else { b.x1 }
+    }
+    pub fn gap(&self, a: &Track, b: &Track) -> f64 {
+        self.start(b.bounds) - self.end(a.bounds)
+    }
+    /// Desired page-space translations, keeping the first track fixed.
+    pub fn offsets(&self, value: f64) -> Vec<(NodeId, f64)> {
+        let mut pos = self.tracks.first().map_or(0.0, |t| self.start(t.bounds));
+        let mut out = Vec::new();
+        for t in &self.tracks {
+            let delta = pos - self.start(t.bounds);
+            out.extend(t.ids.iter().map(|id| (*id, delta)));
+            pos += self.end(t.bounds) - self.start(t.bounds) + value;
+        }
+        out
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct SelectionSpacing {
+    pub horizontal: Option<Axis>,
+    pub vertical: Option<Axis>,
+}
+
+/// Available only for movable, visible siblings outside normal auto-layout flow. Parent/child
+/// selections, instance internals and locked layers must not be moved indirectly by a gap edit.
+pub fn selection_spacing(doc: &Document, ids: &[NodeId]) -> SelectionSpacing {
+    let Some(first) = ids.first().and_then(|id| doc.node(*id)) else { return SelectionSpacing::default() };
+    if ids.len() < 2 || ids.len() > 2000 {
+        return SelectionSpacing::default();
+    }
+    let mut items = Vec::new();
+    for id in ids {
+        let Some(n) = doc.node(*id) else { return SelectionSpacing::default() };
+        if n.parent != first.parent
+            || !n.visible
+            || doc.ancestors(*id).into_iter().any(|a| doc.node(a).is_some_and(|n| !n.visible))
+            || crate::tools::locked_in(doc, *id)
+            || crate::components::inside_instance(doc, *id)
+            || matches!(n.kind, NodeKind::Page { .. })
+            || n.parent.and_then(|p| doc.node(p)).is_some_and(|p| p.layout.is_some() && !n.child_layout.absolute)
+        {
+            return SelectionSpacing::default();
+        }
+        let determinant = n.parent.map(|p| doc.world_transform(p).determinant()).unwrap_or(1.0);
+        if !determinant.is_finite() || determinant.abs() < 1e-12 {
+            return SelectionSpacing::default();
+        }
+        let Some(b) = doc.world_bounds(*id) else { return SelectionSpacing::default() };
+        if ![b.x0, b.y0, b.x1, b.y1].into_iter().all(f64::is_finite) || b.width() <= EPS || b.height() <= EPS {
+            return SelectionSpacing::default();
+        }
+        if !items.iter().any(|(i, _)| i == id) {
+            items.push((*id, b));
+        }
+    }
+    SelectionSpacing { horizontal: axis(&items, false), vertical: axis(&items, true) }
+}
+
+fn axis(items: &[(NodeId, Rect)], vertical: bool) -> Option<Axis> {
+    let edges = |b: Rect| if vertical { (b.y0, b.y1) } else { (b.x0, b.x1) };
+    let mut items = items.to_vec();
+    items.sort_by(|a, b| edges(a.1).0.total_cmp(&edges(b.1).0).then(a.0.cmp(&b.0)));
+    let mut tracks: Vec<Track> = Vec::new();
+    for (id, b) in items {
+        let (lo, hi) = edges(b);
+        let aligned = tracks.iter_mut().find(|t| {
+            let (a, z) = edges(t.anchor);
+            (lo - a).abs() <= EPS || (hi - z).abs() <= EPS || ((lo + hi - a - z) * 0.5).abs() <= EPS
+        });
+        if let Some(t) = aligned {
+            t.ids.push(id);
+            t.bounds = t.bounds.union(b);
+        } else {
+            tracks.push(Track { ids: vec![id], bounds: b, anchor: b });
+        }
+    }
+    if tracks.len() < 2 {
+        return None;
+    }
+    tracks.sort_by(|a, b| edges(a.bounds).0.total_cmp(&edges(b.bounds).0));
+    // Diagonally scattered layers aren't a row/column/grid selection.
+    let cross = |b: Rect| if vertical { (b.x0, b.x1) } else { (b.y0, b.y1) };
+    let low = tracks.iter().map(|t| cross(t.bounds).0).fold(f64::NEG_INFINITY, f64::max);
+    let high = tracks.iter().map(|t| cross(t.bounds).1).fold(f64::INFINITY, f64::min);
+    if high - low <= EPS {
+        return None;
+    }
+    let mut result = Axis { tracks, vertical, value: None };
+    let gaps: Vec<f64> = result.tracks.windows(2).filter_map(|p| p.first().zip(p.get(1)).map(|(a, b)| result.gap(a, b))).collect();
+    result.value = gaps.first().copied().filter(|v| gaps.iter().all(|g| (g - v).abs() <= EPS));
+    Some(result)
+}
+
+/// A spacing gesture never changes selection. Roll it back in its owning document, preserving
+/// a subsequent tab/page/selection change and leaving another document's gesture alone.
+pub fn cancel_gesture(session: &mut crate::Session, uid: u64) {
+    if let Some(ds) = session.docs.iter_mut().find(|d| d.uid == uid)
+        && let Some(it) = ds.interaction.take()
+    {
+        ds.doc = it.doc;
+        ds.revision += 1;
+        ds.clean_selection();
+    }
+}
diff --git a/crates/engine/src/selection_spacing_tests.rs b/crates/engine/src/selection_spacing_tests.rs
new file mode 100644
index 000000000..ac36f3c3f
--- /dev/null
+++ b/crates/engine/src/selection_spacing_tests.rs
@@ -0,0 +1,123 @@
+use crate::{Session, selection_spacing::selection_spacing};
+use figcraft_doc::NodeId;
+use serde_json::json;
+
+fn rect(s: &mut Session, x: f64, y: f64, w: f64, h: f64, parent: Option<NodeId>) -> NodeId {
+    NodeId(s.execute("shape.rectangle", &json!({"x":x,"y":y,"width":w,"height":h,"parent":parent})).unwrap()["id"].as_u64().unwrap())
+}
+fn xy(s: &Session, id: NodeId) -> (f64, f64) {
+    let b = s.doc().unwrap().world_bounds(id).unwrap();
+    (b.x0, b.y0)
+}
+
+#[test]
+fn rows_columns_and_grids_keep_track_contents_and_sizes() {
+    let mut s = Session::new();
+    // Unequal widths, left-aligned columns. The column widths are 50 and 80; gaps 30 and 20.
+    let a = rect(&mut s, 100., 100., 50., 40., None);
+    let b = rect(&mut s, 180., 100., 80., 40., None);
+    let c = rect(&mut s, 100., 160., 30., 60., None);
+    let d = rect(&mut s, 180., 160., 40., 60., None);
+    let ids = [a, b, c, d];
+    let layout = selection_spacing(s.doc().unwrap(), &ids);
+    assert_eq!(layout.horizontal.unwrap().value, Some(30.));
+    assert_eq!(layout.vertical.unwrap().value, Some(20.));
+    s.execute("arrange.spacing", &json!({"ids":ids,"horizontal":12,"vertical":25})).unwrap();
+    assert_eq!(xy(&s, a), (100., 100.));
+    assert_eq!(xy(&s, b), (162., 100.));
+    assert_eq!(xy(&s, c), (100., 165.));
+    assert_eq!(xy(&s, d), (162., 165.));
+
+    assert_eq!(s.doc().unwrap().node(d).unwrap().width, 40.);
+    s.undo().unwrap();
+    assert_eq!(xy(&s, d), (180., 160.));
+    s.redo().unwrap();
+    assert_eq!(xy(&s, d), (162., 165.));
+    s.begin_interaction("Spacing").unwrap();
+    s.execute("arrange.spacing", &json!({"ids":ids,"horizontal":22,"fromGesture":true})).unwrap();
+    s.execute("arrange.spacing", &json!({"ids":ids,"vertical":35,"fromGesture":true})).unwrap();
+    assert_eq!(xy(&s, d), (172., 175.), "the unrequested axis keeps the earlier edit");
+    s.commit_interaction().unwrap();
+}
+
+#[test]
+fn mixed_gaps_normalize_and_fractional_negative_gaps_are_supported() {
+    let mut s = Session::new();
+    let a = rect(&mut s, 0., 0., 50., 40., None);
+    let b = rect(&mut s, 70., 0., 50., 40., None);
+    let c = rect(&mut s, 160., 0., 50., 40., None);
+    assert_eq!(selection_spacing(s.doc().unwrap(), &[a, b, c]).horizontal.unwrap().value, None);
+    s.execute("arrange.spacing", &json!({"ids":[a,b,c],"horizontal":-5.5})).unwrap();
+    assert_eq!(xy(&s, b), (44.5, 0.));
+    assert_eq!(xy(&s, c), (89., 0.));
+    assert_eq!(selection_spacing(s.doc().unwrap(), &[a, b, c]).horizontal.unwrap().value, Some(-5.5));
+}
+
+#[test]
+fn a_scrub_uses_the_original_tracks_after_crossing_and_makes_one_undo_step() {
+    let mut s = Session::new();
+    let a = rect(&mut s, 0., 0., 50., 40., None);
+    let b = rect(&mut s, 70., 0., 50., 40., None);
+    let c = rect(&mut s, 140., 0., 50., 40., None);
+    let before = s.undo_depth().0;
+    s.begin_interaction("Spacing").unwrap();
+    for v in [-100., 0., 30.] {
+        s.execute("arrange.spacing", &json!({"ids":[a,b,c],"horizontal":v,"fromGesture":true})).unwrap();
+    }
+    assert_eq!(xy(&s, b), (80., 0.));
+    assert_eq!(xy(&s, c), (160., 0.));
+    s.commit_interaction().unwrap();
+    assert_eq!(s.undo_depth().0, before + 1);
+    s.undo().unwrap();
+    assert_eq!(xy(&s, c), (140., 0.));
+}
+
+#[test]
+fn unsafe_selections_and_invalid_axes_are_rejected_without_changes() {
+    let mut s = Session::new();
+    let a = rect(&mut s, 0., 0., 50., 40., None);
+    let b = rect(&mut s, 70., 0., 50., 40., None);
+    for props in [json!({"locked":true}), json!({"visible":false})] {
+        s.execute("node.set", &json!({"id":b,"props":props})).unwrap();
+        assert!(s.execute("arrange.spacing", &json!({"ids":[a,b],"horizontal":5})).is_err());
+        s.execute("node.set", &json!({"id":b,"props":{"locked":false,"visible":true}})).unwrap();
+    }
+    for args in [
+        json!({"ids":[a,b],"vertical":5}),
+        json!({"ids":[a,b],"horizontal":5,"vertical":5}),
+        json!({"ids":[a,b],"horizontal":"bad"}),
+        json!({"ids":[a,b],"horizontal":1e300}),
+    ] {
+        assert!(s.execute("arrange.spacing", &args).is_err());
+        assert_eq!(xy(&s, b), (70., 0.));
+    }
+    let f = NodeId(
+        s.execute("frame.create", &json!({"x":0,"y":0,"width":300,"height":100,"props":{"layout":"horizontal"}})).unwrap()["id"].as_u64().unwrap(),
+    );
+    let x = rect(&mut s, 0., 0., 50., 40., Some(f));
+    let y = rect(&mut s, 70., 0., 50., 40., Some(f));
+    assert!(selection_spacing(s.doc().unwrap(), &[x, y]).horizontal.is_none());
+    assert!(selection_spacing(s.doc().unwrap(), &[a, x]).horizontal.is_none());
+}
+
+#[test]
+fn rotated_parents_use_page_space_and_cancellation_stays_with_its_document() {
+    let mut s = Session::new();
+    let f = NodeId(
+        s.execute("frame.create", &json!({"x":100,"y":100,"width":300,"height":200,"props":{"rotation":90}})).unwrap()["id"].as_u64().unwrap(),
+    );
+    let a = rect(&mut s, 0., 0., 50., 40., Some(f));
+    let b = rect(&mut s, 70., 0., 50., 40., Some(f));
+    let before = xy(&s, b);
+    let uid = s.ds().unwrap().uid;
+    s.begin_interaction("Spacing").unwrap();
+    s.execute("arrange.spacing", &json!({"ids":[a,b],"vertical":40,"fromGesture":true})).unwrap();
+    assert!(((xy(&s, b).1 - xy(&s, a).1).abs() - 90.0).abs() < 1e-7, "50-high rotated rectangles must have a 40-point gap");
+    s.execute("file.new", &json!({})).unwrap();
+    s.begin_interaction("Unrelated").unwrap();
+    crate::selection_spacing::cancel_gesture(&mut s, uid);
+    assert!(s.ds().unwrap().interaction.is_some());
+    s.active = 0;
+    assert_eq!(xy(&s, b), before);
+    assert!(s.ds().unwrap().interaction.is_none());
+}
diff --git a/crates/engine/src/shapes_behaviour_tests.rs b/crates/engine/src/shapes_behaviour_tests.rs
index 154c5ae19..62069da32 100644
--- a/crates/engine/src/shapes_behaviour_tests.rs
+++ b/crates/engine/src/shapes_behaviour_tests.rs
@@ -396,6 +396,30 @@ fn boolean_results_and_the_look_they_take() {
     assert!(path.area().abs() < 1e-6, "no overlap, nothing to show");
 }
 
+#[test]
+fn flatten_keeps_open_paths() {
+    // #377: open paths have no fill outline, so two pen paths flattened to "nothing to flatten"
+    // and next to a closed shape they disappeared.
+    let mut s = Session::new();
+    let a = create(&mut s, "vector.create", json!({"points": [[0, 0], [100, 50], [200, 0]]}));
+    let b = create(&mut s, "vector.create", json!({"points": [[0, 100], [100, 150], [200, 100]]}));
+    let tri = create(&mut s, "vector.create", json!({"points": [[300, 0], [400, 0], [400, 100]], "closed": true}));
+    let v = create(&mut s, "vector.flatten", json!({"ids": [a, b, tri]}));
+    let NodeKind::Vector { network } = node(&s, v).kind else { panic!("flatten makes one vector") };
+    assert_eq!((network.vertices.len(), network.segments.len()), (9, 7), "both open paths and the triangle");
+    assert_eq!(network.regions.len(), 1, "only the triangle is filled");
+    let bb = s.doc().unwrap().world_bounds(v).unwrap();
+    assert_eq!((bb.x0, bb.y0, bb.x1, bb.y1), (0.0, 0.0, 400.0, 150.0), "nothing moves");
+
+    // Joining two open paths goes the same way.
+    let mut s = Session::new();
+    let a = create(&mut s, "vector.create", json!({"points": [[0, 0], [100, 0]]}));
+    let b = create(&mut s, "vector.create", json!({"points": [[0, 50], [100, 50]]}));
+    let v = create(&mut s, "vector.join", json!({"ids": [a, b]}));
+    let NodeKind::Vector { network } = node(&s, v).kind else { panic!("join makes one vector") };
+    assert_eq!(network.segments.len(), 2);
+}
+
 #[test]
 fn flatten_and_outline_stroke() {
     // Flatten: one vector layer from the selection, in one step; Alt+Shift+F does it.
diff --git a/crates/engine/src/shortcut_parity_tests.rs b/crates/engine/src/shortcut_parity_tests.rs
index cf7d5d47b..cb2faf13c 100644
--- a/crates/engine/src/shortcut_parity_tests.rs
+++ b/crates/engine/src/shortcut_parity_tests.rs
@@ -120,6 +120,15 @@ static ROWS: &[Row] = &[
     pin(Tools, "tool.slice", &["S"], &[]),
     pin(Tools, "file.placeImage", &["Shift+Cmd+K"], &[]),
     pin(Tools, "tool.shapeBuilder", &["Shift+M"], &[]),
+    // Board tools (boards only), on keys no design-file shortcut uses.
+    pin(Tools, "tool.sticky", &["Q"], &[]),
+    pin(Tools, "tool.shape", &["B"], &[]),
+    pin(Tools, "tool.connector", &["X"], &[]),
+    pin(Tools, "tool.marker", &["M"], &[]),
+    pin(Tools, "tool.highlighter", &["U"], &[]),
+    pin(Tools, "tool.eraser", &["E"], &[]),
+    pin(Tools, "tool.stamp", &["W"], &[]),
+    pin(Tools, "board.nextSticky", &["Shift+Cmd+Enter"], &[]),
     // Vector edit mode
     doc(Selection, "Edit the selected shape's points", &["Enter"], &[], Bound("select.children"), "Enter on a shape edits it; on a frame or group it selects the children"),
     doc(Shape, "Vector edit: move", &["V"], &[], VectorTool(VTool::Move), ""),
@@ -162,8 +171,8 @@ static ROWS: &[Row] = &[
     doc(Zoom, "Zoom out", &["Cmd+-", "-"], &[], Bound("view.zoomOut"), ""),
     doc(Zoom, "Zoom to fit", &["Shift+1"], &[], Bound("view.zoomFit"), ""),
     doc(Zoom, "Zoom to the selection", &["Shift+2"], &[], Bound("view.zoomSelection"), ""),
-    pin(Zoom, "view.zoomIn", &["Shift+Cmd+="], &[]),
-    pin(Zoom, "view.zoomOut", &["Shift+-"], &[]),
+    pin(Zoom, "view.zoomIn", &["Shift+Cmd+=", "="], &[]),
+    pin(Zoom, "view.zoomOut", &["Shift+-", "Shift+Cmd+-"], &[]),
     pin(Zoom, "view.zoom100", &["Shift+0", "Cmd+0"], &[]),
     pin(Zoom, "view.prevFrame", &["Shift+N", "Home"], &[]),
     pin(Zoom, "view.nextFrame", &["N", "End"], &[]),
@@ -398,7 +407,7 @@ fn counts_match_the_docs() {
     let reserved = documented.iter().filter(|r| !r.reserved.is_empty()).count();
     let pinned = ROWS.len() - documented.len();
     // docs/ui-parity.md quotes these.
-    assert_eq!((documented.len(), bound, moved, missing, reserved, pinned), (129, 128, 1, 0, 2, 49));
+    assert_eq!((documented.len(), bound, moved, missing, reserved, pinned), (129, 128, 1, 0, 2, 57));
 }
 
 #[test]
diff --git a/crates/engine/src/slot_tests.rs b/crates/engine/src/slot_tests.rs
index 516cb9d6c..cbf824d9f 100644
--- a/crates/engine/src/slot_tests.rs
+++ b/crates/engine/src/slot_tests.rs
@@ -41,6 +41,17 @@ fn props_of(s: &mut Session, id: NodeId) -> Vec<Value> {
     ex(s, "component.properties", json!({"id": id}))["properties"].as_array().cloned().unwrap_or_default()
 }
 
+/// A refused slot is reported by `component.makeSlot`, the command that was run, not by the
+/// property command it adds its slot property through.
+#[test]
+fn a_refused_slot_names_make_slot() {
+    let mut s = Session::new();
+    let (c, ..) = slot_card(&mut s);
+    let other = idv(&ex(&mut s, "frame.create", json!({"x": 150, "y": 10, "width": 40, "height": 30, "parent": c, "name": "Other"})));
+    let err = s.execute("component.makeSlot", &json!({"id": other, "name": "Content"})).unwrap_err().to_string();
+    assert!(err.contains("`component.makeSlot`") && err.contains("a property named `Content` already exists"), "{err}");
+}
+
 #[test]
 fn slots_are_frames_of_a_main_with_a_slot_property() {
     let mut s = Session::new();
diff --git a/crates/engine/src/styles_behaviour_tests.rs b/crates/engine/src/styles_behaviour_tests.rs
index ff7af50b9..de9da5a5d 100644
--- a/crates/engine/src/styles_behaviour_tests.rs
+++ b/crates/engine/src/styles_behaviour_tests.rs
@@ -80,6 +80,20 @@ fn link(s: &Session, n: NodeId, kind: &str) -> Option<String> {
     }
 }
 
+/// The key linking a style of `kind` (a paint style links fills).
+fn style_key(kind: &str) -> String {
+    if kind == "paint" { "fillStyle".into() } else { format!("{kind}Style") }
+}
+
+/// `node.create` params for an unselected layer that takes `kind` styles, with `props`.
+fn new_layer(kind: &str, props: Value) -> Value {
+    if kind == "text" {
+        json!({"type": "text", "text": "Hej", "select": false, "props": props})
+    } else {
+        json!({"type": "frame", "select": false, "props": props})
+    }
+}
+
 #[test]
 fn a_style_holds_the_whole_property_and_links_its_source() {
     // Documented: colour styles can hold several fills (gradients, images); effect styles combine
@@ -234,6 +248,59 @@ fn editing_a_styled_property_detaches_that_style_only() {
     let _ = st;
 }
 
+#[test]
+fn a_style_link_wins_over_values_in_the_same_call() {
+    // Docs silent on one call setting both (a linked layer shows its style's values; editing one
+    // detaches it); pinned: the link wins whatever the keys are called, on node.create and
+    // node.set, and a deviation set in a later call unlinks as before.
+    let mut s = Session::new();
+    let rows = styled(&mut s);
+    let pairs: [(&str, &str, Value); 12] = [
+        ("paint", "fill", json!("#123456")),
+        ("paint", "fills", json!(["#123456"])),
+        ("stroke", "stroke", json!("#123456")),
+        ("stroke", "strokes", json!(["#123456"])),
+        ("effect", "effects", json!([])),
+        ("grid", "grids", json!([])),
+        ("grid", "layoutGrids", json!([])),
+        ("text", "fontStyle", json!("Bold")),
+        ("text", "lineHeight", json!(40)),
+        ("text", "textDecoration", json!("underline")),
+        ("text", "letterSpacing", json!(5)),
+        ("text", "variationSettings", json!({"wght": 700})),
+    ];
+    for (kind, key, value) in pairs {
+        let (source, st, _) = rows.iter().find(|r| r.2 == kind).unwrap().clone();
+        let link_key = style_key(kind);
+        let props = json!({key: value.clone(), link_key.as_str(): st.clone()});
+        let made = id(run(&mut s, "node.create", new_layer(kind, props.clone())));
+        let set = if kind == "text" { text(&mut s, 400.0) } else { rect(&mut s, 400.0) };
+        run(&mut s, "node.set", json!({"id": set, "props": props}));
+        for (how, layer) in [("node.create", made), ("node.set", set)] {
+            assert_eq!(link(&s, layer, kind).as_deref(), Some(st.as_str()), "{how} `{key}` + `{link_key}`: linked");
+            assert_eq!(shown(&s, layer, kind), shown(&s, source, kind), "{how} `{key}` + `{link_key}`: the style's values");
+        }
+        run(&mut s, "node.set", json!({"id": set, "props": {key: value}}));
+        assert_eq!(link(&s, set, kind), None, "`{key}` in a later call unlinks");
+        assert_ne!(shown(&s, set, kind), shown(&s, source, kind), "`{key}` in a later call applies");
+    }
+}
+
+#[test]
+fn a_style_link_leaves_values_its_style_does_not_set() {
+    // Docs silent; pinned: alignment given beside a text style applies, on node.create and node.set.
+    let mut s = Session::new();
+    let st = styled(&mut s).into_iter().find(|r| r.2 == "text").unwrap().1;
+    let props = json!({"textStyle": st, "textAlign": "center"});
+    let made = id(run(&mut s, "node.create", new_layer("text", props.clone())));
+    let set = text(&mut s, 400.0);
+    run(&mut s, "node.set", json!({"id": set, "props": props}));
+    for (how, layer) in [("node.create", made), ("node.set", set)] {
+        assert_eq!(link(&s, layer, "text").as_deref(), Some(st.as_str()), "{how}: linked");
+        assert_eq!(node(&s, layer).kind.text().unwrap().align_h, figcraft_doc::TextAlignH::Center, "{how}: `textAlign` applies");
+    }
+}
+
 #[test]
 fn applying_a_style_replaces_variables_bound_to_that_property() {
     // Documented: applying a style sets the property to the style's values. Docs silent on bound
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index dbf432d41..646c7c4b0 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -376,6 +376,7 @@ fn pointer_draw_move_resize() {
     assert_eq!(s.selection(), vec![r]);
 }
 
+/// No command panics on junk parameters.
 #[test]
 fn every_command_survives_junk_params() {
     // A junk-parameter sweep: no command may panic (guard turns panics into Internal errors,
@@ -415,6 +416,12 @@ fn every_command_survives_junk_params() {
         // Online files: ids, servers, refreshes, actions and names as junk.
         json!({"file": [1], "server": 7, "refresh": "maybe", "action": "share", "name": {"x": 1}}),
         json!({"file": "../x", "server": "wss://\u{0}", "refresh": true, "action": "unshare", "name": 5}),
+        // Selection color slots: malformed indexes, ranges and paints.
+        json!({"targets": [{"id": 2, "fills": true, "index": -1, "range": [0, 1e308]}], "paint": {"type": "solid", "color": "invalid"}}),
+        json!({"targets": [{"id": 2, "fills": "yes", "index": 0, "range": [4, 1]}], "style": 5}),
+        // Smart-selection reorder targets and modes as junk.
+        json!({"ids": [2, 3], "source": -1, "target": {"id": 3}, "swap": [], "fromGesture": true}),
+        json!({"source": 1e308, "target": "NaN", "swap": "yes", "fromGesture": []}),
         // Rotation origins and placing with a tool as junk.
         json!({"tool": [1], "x": 1e308, "y": "NaN", "reset": "maybe", "on": {"x": 1}}),
         json!({"tool": "frame", "x": -1e308, "y": 1e308, "reset": true, "on": "yes"}),
@@ -431,6 +438,8 @@ fn every_command_survives_junk_params() {
                 | "file.placeImage"
                 | "image.place"
                 | "file.revert"
+                // Takes no params and walks the font folders: one walk per junk is slow.
+                | "text.rescanFonts"
         ) {
             continue;
         }
diff --git a/crates/engine/src/text_behaviour_tests.rs b/crates/engine/src/text_behaviour_tests.rs
index 84315f1fb..b9a76fbc7 100644
--- a/crates/engine/src/text_behaviour_tests.rs
+++ b/crates/engine/src/text_behaviour_tests.rs
@@ -177,20 +177,19 @@ fn vertical_trim_through_node_set() {
 
 #[test]
 fn paragraph_indent_only_moves_left_aligned_text() {
+    figcraft_text::scan_system_fonts();
     let mut s = Session::new();
     let t = text(&mut s, "Indented paragraph", json!({"fontSize": 20, "paragraphIndent": 30}));
     let first_x = |s: &Session| {
         let (l, _) = figcraft_text::layout_node(s.doc().unwrap().node(t).unwrap()).unwrap();
-        (l.glyphs.first().map_or(0.0, |g| g.x), l.width)
+        (l.glyphs.first().map(|g| g.x), l.width)
     };
-    let (x, w) = first_x(&s);
-    if w <= 0.0 {
-        return;
-    }
+    // Without any font there are no glyphs, but the indent alone still gives the box a width.
+    let (Some(x), w) = first_x(&s) else { return };
     assert!((x - 30.0).abs() < 1e-6, "left: indented");
     s.execute("node.set", &json!({"id": t, "props": {"textAlign": "center"}})).unwrap();
     let (x, w2) = first_x(&s);
-    assert!((w2 - (w - 30.0)).abs() < 1e-6 && x.abs() < 1e-6, "centered auto-width text: no indent, the box shrinks by it");
+    assert!((w2 - (w - 30.0)).abs() < 1e-6 && x.is_some_and(|x| x.abs() < 1e-6), "centered auto-width text: no indent, the box shrinks by it");
 }
 
 /// A new text made with the Text tool by a press at `from`, a drag to `to` and a release, holding
diff --git a/crates/engine/src/text_style_picker_tests.rs b/crates/engine/src/text_style_picker_tests.rs
index 37c7dc5c2..6ee8cc2c3 100644
--- a/crates/engine/src/text_style_picker_tests.rs
+++ b/crates/engine/src/text_style_picker_tests.rs
@@ -212,6 +212,31 @@ fn previews_while_editing_keep_the_edit() {
     assert!(links(&s, t).iter().all(Option::is_none));
 }
 
+#[test]
+fn previews_show_a_hovered_font_family() {
+    let mut s = new_session();
+    let t = text(&mut s, "Preview me");
+    s.ds_mut().unwrap().mark_saved();
+    let before = s.doc().unwrap().clone();
+    let undo = s.ds().unwrap().history.undo.len();
+    // Hovering a font family shows it on the canvas: no undo step, not dirty.
+    s.execute("text.preview", &json!({"command": "text.style", "params": {"ids": [t], "fontFamily": "Arial"}})).unwrap();
+    assert_eq!(data(&s, t).style_at(0).font_family, "Arial");
+    assert_eq!(s.ds().unwrap().history.undo.len(), undo);
+    assert!(!s.ds().unwrap().is_dirty());
+    // Moving to another family replaces the preview, from the document itself.
+    s.execute("text.preview", &json!({"command": "text.style", "params": {"ids": [t], "fontFamily": "Georgia"}})).unwrap();
+    assert_eq!(data(&s, t).style_at(0).font_family, "Georgia");
+    // Closing without picking puts the document back as it was.
+    assert_eq!(s.execute("text.endPreview", &json!({})).unwrap()["ended"], json!(true));
+    assert_eq!(*s.doc().unwrap(), before);
+    // Clicking commits it as one undo step.
+    s.execute("text.style", &json!({"ids": [t], "fontFamily": "Georgia"})).unwrap();
+    assert_eq!(data(&s, t).style_at(0).font_family, "Georgia");
+    assert_eq!(s.ds().unwrap().history.undo.len(), undo + 1);
+    assert!(s.ds().unwrap().text_preview.is_none());
+}
+
 #[test]
 fn previews_refuse_what_they_cant_show() {
     let mut s = new_session();
diff --git a/crates/engine/src/text_tail_tests.rs b/crates/engine/src/text_tail_tests.rs
index b951bfc75..81d05ed23 100644
--- a/crates/engine/src/text_tail_tests.rs
+++ b/crates/engine/src/text_tail_tests.rs
@@ -57,6 +57,24 @@ fn list_buttons_act_on_the_selected_paragraphs() {
     assert_eq!(data(&s, t).list, P, "toggled off");
 }
 
+#[test]
+fn a_list_with_a_start_number_toggles_off() {
+    // An imported list that starts at 2 has the start on its first item only; it is still one
+    // numbered list, so the button turns it back to plain (#686).
+    let mut s = Session::new();
+    let t = text(&mut s, "two\nthree\nfour");
+    if let figcraft_doc::NodeKind::Text(td) = &mut s.doc_mut().unwrap().get_mut(t).unwrap().kind {
+        let n = |start_offset| ParaList { list: N, indent: 0, start_offset };
+        td.paragraphs = vec![n(1), n(0), n(0)];
+    }
+    let j = crate::inspect::node_json(s.doc().unwrap(), t, 0);
+    assert_eq!(j["listStartOffsets"], json!([1, 0, 0]), "inspect reports the start");
+    s.execute("text.numberList", &json!({"ids": [t]})).unwrap();
+    assert_eq!(lists(&s, t), [(P, 0); 3]);
+    assert_eq!(data(&s, t).para_list(0).start_offset, 0, "a plain paragraph has no start");
+    assert!(crate::inspect::node_json(s.doc().unwrap(), t, 0).get("listStartOffsets").is_none());
+}
+
 #[test]
 fn typed_list_starts() {
     // Typing "- " or "* " at the start of a paragraph starts a bulleted list, "1. " a numbered one
@@ -117,7 +135,7 @@ fn list_keys_at_list_items() {
     for (chars, before, caret, k, shift, after, want, why) in cases {
         let mut s = Session::new();
         let t = text(&mut s, chars);
-        let ps: Vec<ParaList> = before.iter().map(|(list, indent)| ParaList { list: *list, indent: *indent }).collect();
+        let ps: Vec<ParaList> = before.iter().map(|(list, indent)| ParaList { list: *list, indent: *indent, start_offset: 0 }).collect();
         if let figcraft_doc::NodeKind::Text(td) = &mut s.doc_mut().unwrap().get_mut(t).unwrap().kind {
             td.paragraphs = ps;
         }
@@ -141,7 +159,7 @@ fn paragraph_lists_follow_edits() {
     // A paragraph's list stays with it as text is typed, pasted and deleted: new paragraphs copy
     // the one they split from; joined paragraphs keep the first one's.
     let mut t = TextData::new("ab\ncd\nef");
-    t.paragraphs = vec![ParaList { list: B, indent: 1 }, ParaList::default(), ParaList { list: N, indent: 0 }];
+    t.paragraphs = vec![ParaList { list: B, indent: 1, start_offset: 0 }, ParaList::default(), ParaList { list: N, indent: 0, start_offset: 0 }];
     let get = |t: &TextData| (0..t.paragraph_count()).map(|p| (t.para_list(p).list, t.para_list(p).indent)).collect::<Vec<_>>();
     t.replace_range(1, 1, "x\ny");
     assert_eq!(get(&t), [(B, 1), (B, 1), (P, 0), (N, 0)], "a pasted newline: a new item like it");
@@ -156,7 +174,7 @@ fn paragraph_lists_follow_edits() {
         (seed >> 33) as usize % n.max(1)
     };
     let mut t = TextData::new("a\nb\nc\nd");
-    t.paragraphs = vec![ParaList { list: B, indent: 2 }; 4];
+    t.paragraphs = vec![ParaList { list: B, indent: 2, start_offset: 0 }; 4];
     for _ in 0..500 {
         let n = t.char_count();
         let (a, b) = (rnd(n + 2), rnd(n + 2));
diff --git a/crates/engine/src/textedit.rs b/crates/engine/src/textedit.rs
index 76b353a00..85ea535b7 100644
--- a/crates/engine/src/textedit.rs
+++ b/crates/engine/src/textedit.rs
@@ -32,7 +32,9 @@ pub fn begin(s: &mut Session, id: NodeId, caret: Option<usize>, created: bool) -
 pub fn end(s: &mut Session) -> Result<()> {
     let Some(te) = s.ds()?.text_edit.clone() else { return Ok(()) };
     s.ds_mut()?.text_edit = None;
-    let empty = text_of(s, te.id).map(|t| t.characters.trim().is_empty()).unwrap_or(false);
+    // A board object's text (a sticky's note) stays when emptied; the object is selected again.
+    let owner = s.doc().ok().and_then(|d| crate::board::owner_of_text(d, te.id));
+    let empty = owner.is_none() && text_of(s, te.id).map(|t| t.characters.trim().is_empty()).unwrap_or(false);
     if empty {
         let doc = s.doc_mut()?;
         let _ = doc.remove(te.id);
@@ -50,6 +52,9 @@ pub fn end(s: &mut Session) -> Result<()> {
     }
     s.commit_interaction()?;
     let ds = s.ds_mut()?;
+    if let Some(o) = owner {
+        ds.selection = vec![o];
+    }
     ds.revision += 1;
     Ok(())
 }
@@ -782,6 +787,7 @@ mod tests {
         assert!(r.is_null() || r["axes"].is_array());
     }
 
+    /// No text command panics on junk parameters while a text is being edited.
     #[test]
     fn text_commands_survive_junk_while_editing() {
         let junk = [
@@ -793,7 +799,8 @@ mod tests {
             json!({"variations": {"wght": "heavy", "toolong": 1}, "text": "\u{0}\u{7}", "cursor": 1e300}),
             json!({"variations": {"wght": 1e300, "opsz": -1e300}, "replace": "yes", "text": "日本語", "cursor": -1}),
         ];
-        for spec in crate::cmd::all_commands().iter().filter(|c| c.id.starts_with("text.")) {
+        // `text.rescanFonts` takes no params and walks the font folders: one walk per junk is slow.
+        for spec in crate::cmd::all_commands().iter().filter(|c| c.id.starts_with("text.") && c.id != "text.rescanFonts") {
             for j in &junk {
                 let (mut s, id) = setup("Hi there\nyou");
                 begin(&mut s, id, Some(2), false).unwrap();
diff --git a/crates/engine/src/textpreview.rs b/crates/engine/src/textpreview.rs
index 507eccc3d..da101d5ea 100644
--- a/crates/engine/src/textpreview.rs
+++ b/crates/engine/src/textpreview.rs
@@ -1,6 +1,6 @@
 //! Live text previews: what a text command would do, shown on the canvas without an undo step —
-//! while the pointer is over a text style in the style browser or a font's named instance, or
-//! while a variable font axis slider is dragged. The document under the preview is kept and comes
+//! while the pointer is over a font family or style, a text style in the style browser or a
+//! font's named instance, or while a variable font axis slider is dragged. The document under the preview is kept and comes
 //! back when the preview ends ([`end`], `text.endPreview`). Every other command ends it first, so
 //! committing (running the command for real) applies to the document itself as one undo step, and
 //! Escape just ends the preview.
diff --git a/crates/engine/src/tools.rs b/crates/engine/src/tools.rs
index 3d3b9acb8..86feed4f1 100644
--- a/crates/engine/src/tools.rs
+++ b/crates/engine/src/tools.rs
@@ -39,10 +39,18 @@ pub enum ToolId {
     Comment,
     Eyedropper,
     ShapeBuilder,
+    // Board tools.
+    Sticky,
+    BoardShape,
+    Connector,
+    Marker,
+    Highlighter,
+    Eraser,
+    Stamp,
 }
 
 impl ToolId {
-    pub const ALL: [ToolId; 18] = [
+    pub const ALL: [ToolId; 25] = [
         ToolId::Move,
         ToolId::Scale,
         ToolId::Hand,
@@ -61,6 +69,13 @@ impl ToolId {
         ToolId::Comment,
         ToolId::Eyedropper,
         ToolId::ShapeBuilder,
+        ToolId::Sticky,
+        ToolId::BoardShape,
+        ToolId::Connector,
+        ToolId::Marker,
+        ToolId::Highlighter,
+        ToolId::Eraser,
+        ToolId::Stamp,
     ];
     pub fn id(self) -> &'static str {
         match self {
@@ -82,6 +97,13 @@ impl ToolId {
             ToolId::Comment => "comment",
             ToolId::Eyedropper => "eyedropper",
             ToolId::ShapeBuilder => "shapeBuilder",
+            ToolId::Sticky => "sticky",
+            ToolId::BoardShape => "shape",
+            ToolId::Connector => "connector",
+            ToolId::Marker => "marker",
+            ToolId::Highlighter => "highlighter",
+            ToolId::Eraser => "eraser",
+            ToolId::Stamp => "stamp",
         }
     }
     pub fn from_id(s: &str) -> Option<ToolId> {
@@ -107,8 +129,23 @@ impl ToolId {
             ToolId::Comment => "Comment",
             ToolId::Eyedropper => "Pick color",
             ToolId::ShapeBuilder => "Shape builder",
+            ToolId::Sticky => "Sticky note",
+            ToolId::BoardShape => "Shapes",
+            ToolId::Connector => "Connector",
+            ToolId::Marker => "Marker",
+            ToolId::Highlighter => "Highlighter",
+            ToolId::Eraser => "Eraser",
+            ToolId::Stamp => "Stamp",
         }
     }
+
+    /// The tools of a board's toolbar (a design file's toolbar has the others).
+    pub fn on_boards(self) -> bool {
+        matches!(
+            self,
+            ToolId::Sticky | ToolId::BoardShape | ToolId::Connector | ToolId::Marker | ToolId::Highlighter | ToolId::Eraser | ToolId::Stamp
+        )
+    }
     /// The tool's key (from [`crate::keymap`]; empty when it has none).
     pub fn shortcut(self) -> &'static str {
         let id = self.id();
@@ -344,6 +381,9 @@ pub(crate) enum Gesture {
         targets: Targets,
         duplicate: bool,
         moved: bool,
+        /// A Shift-press on this selected layer: it leaves the selection on release, unless the
+        /// press became a drag.
+        deselect: Option<NodeId>,
     },
     Resize {
         start: Point,
@@ -401,6 +441,15 @@ pub(crate) enum Gesture {
     },
     /// Dragging the rotation origin handle (see [`crate::rotation_origin`]).
     Origin,
+    /// The connector tool: dragging from `from` (pressed at `start`).
+    Connect {
+        from: figcraft_doc::End,
+        start: Point,
+    },
+    /// The eraser: the strokes it took so far.
+    Erase {
+        gone: Vec<NodeId>,
+    },
     /// Shape builder: regions collected so far (handled in `shapebuilder`).
     ShapeBuild {
         picked: Vec<usize>,
@@ -410,6 +459,13 @@ pub(crate) enum Gesture {
     },
 }
 
+/// Where Shift puts the Pen's next point: as far from `last` as `p` is, at the nearest 45° step.
+fn at_45_degrees(last: Point, p: Point) -> Point {
+    let v = p - last;
+    let ang = (v.atan2() / (std::f64::consts::PI / 4.0)).round() * std::f64::consts::PI / 4.0;
+    last + Vec2::from_angle(ang) * v.hypot()
+}
+
 /// The handles a pen path shows while it is drawn ([`Overlay::pen_handles`]): the last anchor's in
 /// and out handles and the one before's out handle, those that aren't zero.
 fn pen_handles(points: &[(Point, Vec2, Vec2)]) -> Vec<[f64; 4]> {
@@ -444,8 +500,10 @@ pub struct ToolState {
     /// removes; Alt merges).
     pub shape_builder: Option<std::sync::Arc<crate::shapebuilder::Arrangement>>,
     pub builder_remove: bool,
-    /// Show distances from the selection on hover without holding Alt (Dev mode inspection).
-    pub redlines: bool,
+    /// Dev Mode: the canvas inspects. Hovering shows distances from the selection without Alt, and
+    /// presses select, pan and comment but never edit the design (no moving, resizing, drawing,
+    /// or editing text or vectors).
+    pub dev_mode: bool,
     /// Pen snap targets, kept while hovering (see `vectoredit::point_snap`).
     pub(crate) pen_targets: Option<crate::vectoredit::point_snap::PenTargets>,
     /// The Scale tool's anchor: column and row (0 start, 1 middle, 2 end) of the point of the
@@ -459,6 +517,13 @@ pub struct ToolState {
     pub labels: Vec<(NodeId, [Point; 4])>,
     /// The brush the Pencil draws with (`tool.pencilBrush`; `None`: a plain stroke).
     pub pencil_brush: Option<figcraft_doc::Brush>,
+    /// The board tools' colours and choices.
+    pub board: crate::board::BoardTool,
+    /// The eyedropper samples for a colour picker (`edit.pickColor` with `apply: false`): the
+    /// colour goes to `picked`, for the picker to write to the paint it edits, not to the fill.
+    pub pick_only: bool,
+    /// The colour the eyedropper sampled for a colour picker, until the picker takes it.
+    pub picked: Option<figcraft_color::Color>,
 }
 
 /// Pen pressure along drawn samples as width profile points `[t, scale]`: `t` by length, at most
@@ -658,6 +723,9 @@ fn on_corner_square(doc: &Document, sel: &[NodeId], p: Point, zoom: f64) -> bool
 /// handles: the canvas draws just its outline (the handles still answer just outside it).
 pub const SMALL_BOX_PX: f64 = 16.0;
 
+/// The stroke the Pencil draws: its colour and weight (the canvas previews it the same).
+pub const PENCIL_STROKE: (figcraft_color::Color, f64) = (figcraft_color::Color::BLACK, 2.0);
+
 /// The shorter and longer sides, in screen pixels, of the box with `corners` (tl, tr, br, bl).
 pub fn box_sides_px(corners: &[Point; 4], zoom: f64) -> (f64, f64) {
     let [a, b, _, d] = corners;
@@ -917,6 +985,7 @@ impl Session {
         }
         self.tool.tool = t;
         self.tool.gesture = Gesture::None;
+        self.tool.pick_only = false;
         // The tool's cursor shows before the pointer moves.
         self.tool.overlay =
             Overlay { builder_remove: self.tool.builder_remove && t == ToolId::ShapeBuilder, cursor: t.cursor(), ..Overlay::default() };
@@ -934,6 +1003,21 @@ impl Session {
         }
     }
 
+    /// The tool pointer events go to: in Dev Mode every tool but the hand and comments selects.
+    fn acting_tool(&self) -> ToolId {
+        match self.tool.tool {
+            t if self.tool.dev_mode && !matches!(t, ToolId::Hand | ToolId::Comment) => ToolId::Move,
+            t => t,
+        }
+    }
+
+    /// Drop the gesture under way (a drag, a resize, a shape being drawn), restoring the document
+    /// as Escape does; the UI calls it when Dev Mode starts, where nothing may move.
+    pub fn drop_gesture(&mut self) -> Result<()> {
+        self.tool.gesture = Gesture::None;
+        self.cancel_interaction()
+    }
+
     /// Feed one pointer event to the current tool.
     pub fn pointer(&mut self, ev: &PointerEvent) -> Result<()> {
         // A held button sends the same move every frame: running the gesture again would only
@@ -946,11 +1030,12 @@ impl Session {
             }
             self.tool.last_move = Some(ev.clone());
         }
-        let tool = self.tool.tool;
-        if matches!(tool, ToolId::Move | ToolId::Scale) && self.origin_pointer(ev)? {
+        let tool = self.acting_tool();
+        let edits = matches!(tool, ToolId::Move | ToolId::Scale) && !self.tool.dev_mode;
+        if edits && self.origin_pointer(ev)? {
             return Ok(());
         }
-        if matches!(tool, ToolId::Move | ToolId::Scale) && self.ds().is_ok_and(|d| d.vector_edit.is_some()) && self.vector_pointer(ev)? {
+        if edits && self.ds().is_ok_and(|d| d.vector_edit.is_some()) && self.vector_pointer(ev)? {
             return Ok(());
         }
         if tool == ToolId::ShapeBuilder {
@@ -981,6 +1066,7 @@ impl Session {
                     Ok(())
                 }
                 ToolId::Eyedropper => self.eyedrop(ev),
+                t if t.on_boards() => self.board_down(ev),
                 t if t.draws_shape() => self.draw_down(ev),
                 _ => Ok(()),
             },
@@ -1010,7 +1096,7 @@ impl Session {
     }
 
     fn hover(&mut self, ev: &PointerEvent) -> Result<()> {
-        let tool = self.tool.tool;
+        let tool = self.acting_tool();
         let ds = self.ds()?;
         let (doc, sel, page) = (ds.doc.clone(), ds.selection.clone(), ds.page);
         let mut cursor = tool.cursor();
@@ -1039,7 +1125,7 @@ impl Session {
         if matches!(tool, ToolId::Move | ToolId::Scale) && on_edited {
             cursor = Cursor::Text;
         } else if matches!(tool, ToolId::Move | ToolId::Scale) && arc_hover.is_none() && shape_hover.is_none() {
-            if let Some(h) = handle_at(&doc, &sel, ev.p(), ev.zoom) {
+            if let Some(h) = handle_at(&doc, &sel, ev.p(), ev.zoom).filter(|_| !self.tool.dev_mode) {
                 cursor = resize_cursor(&doc, &sel, h);
             } else {
                 let leaf = self.hit(&doc, page, ev.p(), ev.tol() * 2.0);
@@ -1048,10 +1134,10 @@ impl Session {
                 }
                 hover = label_at(&doc, page, &self.tool.labels, ev.p()).or_else(|| leaf.map(|leaf| select_target(&doc, leaf, &sel, ev.cmd)));
                 // Alt over a selected layer: a drag from here duplicates it.
-                if ev.alt && tool == ToolId::Move && hover.is_some_and(|h| sel.contains(&h) && !locked_in(&doc, h)) {
+                if ev.alt && !self.tool.dev_mode && tool == ToolId::Move && hover.is_some_and(|h| sel.contains(&h) && !locked_in(&doc, h)) {
                     cursor = Cursor::Copy;
                 }
-                if ev.alt || self.tool.redlines {
+                if ev.alt || self.tool.dev_mode {
                     use crate::distance::{Hover, guide_at, hover_lines, padding_frame, parent_of};
                     // Shift+Alt over an auto layout frame: its padding and gaps. Otherwise from the
                     // selection to a ruler guide, the hovered layer or (over empty canvas) the parent.
@@ -1079,6 +1165,8 @@ impl Session {
             guides = g;
             self.tool.overlay.cursor = Cursor::Pen(self.pen_cursor(&doc, &sel, to, ev.zoom));
             if let Some((last, _, out)) = self.tool.pen.as_ref().and_then(|pen| pen.points.last()) {
+                // With Shift the band ends where a click puts the point (#970).
+                let to = if ev.shift { at_45_degrees(*last, to) } else { to };
                 self.tool.overlay.rubber = Some([last.x, last.y, to.x, to.y]);
                 self.tool.overlay.rubber_handle = (out.hypot() > 0.0).then_some([last.x + out.x, last.y + out.y]);
             }
@@ -1132,6 +1220,7 @@ impl Session {
             textedit::end(self)?;
         }
         // Handles first: a selected ellipse's arc handles (drawn over the box), then the box's.
+        let edits = !self.tool.dev_mode;
         if self.arc_handles_shown()
             && let Some((id, handle)) = crate::arc_handles::hit(&doc, &sel, ev.p(), ev.zoom)
             && let Some(arc) = crate::arc_handles::arc_of(&doc, id)
@@ -1151,7 +1240,7 @@ impl Session {
             self.tool.overlay.shape = shape_hint(&doc, id, handle, ev.zoom);
             return Ok(());
         }
-        if let Some(h) = handle_at(&doc, &sel, ev.p(), ev.zoom) {
+        if let Some(h) = handle_at(&doc, &sel, ev.p(), ev.zoom).filter(|_| edits) {
             let ids = roots(&doc, &sel);
             if let Handle::Rotate(_) = h {
                 let Some(b) = selection_box(&doc, &ids) else { return Ok(()) };
@@ -1178,31 +1267,42 @@ impl Session {
         }
         // A frame's name label picks the frame itself. The background of a top-level frame with
         // layers in it is like the canvas (a press starts a marquee inside it) unless the frame is
-        // selected; an empty frame (or a widget) is picked and dragged.
+        // selected; an empty frame (or a widget, or a board object such as a sticky) is picked and
+        // dragged.
         let board_background = |leaf: NodeId| {
             !sel.contains(&leaf)
-                && doc
-                    .node(leaf)
-                    .is_some_and(|n| n.parent == Some(page) && n.kind.is_frame_like() && !n.children.is_empty() && !crate::widgets::is_widget(n))
+                && doc.node(leaf).is_some_and(|n| {
+                    n.parent == Some(page) && n.kind.is_frame_like() && !n.children.is_empty() && !crate::widgets::is_widget(n) && !n.is_board_atom()
+                })
         };
-        let target = label_at(&doc, page, &self.tool.labels, ev.p()).or_else(|| {
+        let label = label_at(&doc, page, &self.tool.labels, ev.p());
+        let target = label.or_else(|| {
             self.hit(&doc, page, ev.p(), ev.tol() * 2.0)
                 .filter(|leaf| ev.cmd || !board_background(*leaf))
                 .map(|leaf| select_target(&doc, leaf, &sel, ev.cmd))
         });
+        // A press inside the selection's box that reaches nothing above it (an unfilled shape's
+        // inside, or the frame or canvas behind it) drags the selection.
+        let behind_sel = |t: Option<NodeId>| t.is_none_or(|t| sel.iter().any(|s| *s != t && doc.is_ancestor(t, *s)));
+        let target = match sel.iter().copied().find(|s| !locked_in(&doc, *s)) {
+            Some(first) if label.is_none() && !ev.shift && behind_sel(target) && selection_box(&doc, &sel).is_some_and(|q| in_quad(&q, ev.p())) => {
+                Some(first)
+            }
+            _ => target,
+        };
         match target {
             Some(target) => {
                 // Clicking inside the current selection's box keeps it (drag them all).
                 let in_sel_box = sel.len() > 1 && doc.bounds_of(&sel).is_some_and(|b| b.contains(ev.p())) && !ev.shift;
+                // Shift on a selected layer takes it out on release if the press doesn't become a
+                // drag; a drag moves the selection with it. Where no drag can start, it goes now.
+                let deselect = (ev.shift && sel.contains(&target)).then_some(target);
+                let without_target = || sel.iter().copied().filter(|x| *x != target).collect::<Vec<_>>();
                 let new_sel = if in_sel_box && (sel.contains(&target) || sel.iter().any(|s| doc.is_ancestor(*s, target))) {
                     sel.clone()
-                } else if ev.shift {
+                } else if ev.shift && deselect.is_none() {
                     let mut s2 = sel.clone();
-                    if let Some(pos) = s2.iter().position(|x| *x == target) {
-                        s2.remove(pos);
-                    } else {
-                        s2.push(target);
-                    }
+                    s2.push(target);
                     s2
                 } else if sel.contains(&target) {
                     sel.clone()
@@ -1210,12 +1310,19 @@ impl Session {
                     vec![target]
                 };
                 self.set_selection(new_sel.clone());
-                if new_sel.is_empty() || doc.node(target).is_some_and(|n| n.locked) {
+                // Dev Mode only selects (Shift-click still deselects): nothing moves.
+                if !edits {
+                    if deselect.is_some() {
+                        self.set_selection(without_target());
+                    }
                     return Ok(());
                 }
                 // Locked layers selected in the layers panel stay put.
                 let ids: Vec<NodeId> = roots(&doc, &new_sel).into_iter().filter(|i| !locked_in(&doc, *i)).collect();
-                if ids.is_empty() {
+                if new_sel.is_empty() || doc.node(target).is_some_and(|n| n.locked) || ids.is_empty() {
+                    if deselect.is_some() {
+                        self.set_selection(without_target());
+                    }
                     return Ok(());
                 }
                 let mut targets = Targets::gather(&doc, page, &ids);
@@ -1225,8 +1332,13 @@ impl Session {
                 {
                     targets.add_box(b);
                 }
-                self.begin_interaction(if ev.alt { "Duplicate" } else { "Move" })?;
-                self.tool.gesture = Gesture::Move { start: ev.p(), ids, targets, duplicate: ev.alt, moved: false };
+                if let Err(e) = self.begin_interaction(if ev.alt { "Duplicate" } else { "Move" }) {
+                    if deselect.is_some() {
+                        self.set_selection(without_target());
+                    }
+                    return Err(e);
+                }
+                self.tool.gesture = Gesture::Move { start: ev.p(), ids, targets, duplicate: ev.alt, moved: false, deselect };
                 self.tool.overlay.cursor = if ev.alt { Cursor::Copy } else { Cursor::Default };
             }
             None => {
@@ -1289,8 +1401,11 @@ impl Session {
                         for i in &ids {
                             let parent = doc.get(*i)?.parent.unwrap_or(page);
                             let idx = doc.index_in_parent(*i).map(|x| x + 1);
-                            copies.push(doc.duplicate_into(*i, parent, idx)?);
+                            copies.push(crate::components::copy_in_file(doc, *i, parent, idx)?);
                         }
+                        // Connectors copied with what they join join the copies.
+                        let map = crate::board::copy_map(doc, &ids, &copies);
+                        crate::board::rejoin(doc, &crate::board::copied_items(doc, &map), &map, false);
                         moving = copies;
                         *sel = moving.clone();
                     }
@@ -1455,6 +1570,15 @@ impl Session {
                 Ok(())
             }
             Gesture::Vector(_) | Gesture::ShapeBuild { .. } | Gesture::Origin => Ok(()),
+            Gesture::Connect { from, start } => {
+                let (from, start) = (*from, *start);
+                self.connect_drag(ev, from, start);
+                return Ok(());
+            }
+            Gesture::Erase { gone } => {
+                self.tool.gesture = Gesture::Erase { gone: gone.clone() };
+                return self.erase_at(ev);
+            }
             Gesture::PenDrag { anchor } => {
                 // A click's wobble pulls out no handle.
                 let out = if within_slop(ev, *anchor) { Vec2::ZERO } else { ev.p() - *anchor };
@@ -1735,7 +1859,7 @@ impl Session {
         self.tool.overlay.drop_cell = None;
         let drop_target = self.tool.overlay.drop_target.take();
         match g {
-            Gesture::Move { ids, moved, duplicate, start, .. } => {
+            Gesture::Move { ids, moved, duplicate, start, deselect, .. } => {
                 if moved {
                     // A free move lands in the frame under the pointer (or the page) where it was
                     // dropped; layers in an auto layout frame already sit in their slot.
@@ -1777,7 +1901,11 @@ impl Session {
                     }
                 } else {
                     self.cancel_interaction()?;
-                    if !(ev.shift || ev.cmd || duplicate) {
+                    if let Some(d) = deselect {
+                        let sel = self.selection().into_iter().filter(|x| *x != d).collect();
+                        self.set_selection(sel);
+                    }
+                    if deselect.is_none() && !(ev.shift || ev.cmd || duplicate) {
                         self.widget_click(start, ev.tol() * 2.0)?;
                     }
                 }
@@ -1827,10 +1955,17 @@ impl Session {
                     self.tool.tool = t;
                 }
             }
-            Gesture::Pencil { points, pressure } => {
+            Gesture::Pencil { mut points, mut pressure } => {
                 self.tool.overlay.pen.clear();
+                // The stroke ends where the button came up, even without a move to get there.
+                if points.last().is_none_or(|l| (*l - ev.p()).hypot() > 0.5 / ev.zoom.max(1e-6)) {
+                    points.push(ev.p());
+                    pressure.push(ev.pressure);
+                }
                 self.pencil_finish(&points, &pressure)?;
             }
+            Gesture::Connect { from, start } => self.connect_up(ev, from, start)?,
+            Gesture::Erase { .. } => self.erase_up()?,
             Gesture::TextSelect { .. } | Gesture::TextBox { .. } | Gesture::Marquee { .. } | Gesture::None => {}
             Gesture::PenDrag { .. } | Gesture::ShapeBuild { .. } | Gesture::Origin => {}
             Gesture::Vector(_) => self.commit_interaction()?,
@@ -1847,8 +1982,25 @@ impl Session {
         if self.tool.tool == ToolId::Pen {
             return self.pen_finish();
         }
+        let edits = !self.tool.dev_mode;
+        // A frame's or section's name label: rename it there (the canvas puts a field over it).
+        // Labels come before widgets, as on a press; the second press began a move: undo it.
+        if edits
+            && matches!(self.tool.tool, ToolId::Move | ToolId::Scale)
+            && !(ev.shift || ev.cmd || ev.alt)
+            && let Some(id) = label_at(&doc, page, &self.tool.labels, ev.p())
+        {
+            self.tool.gesture = Gesture::None;
+            self.cancel_interaction()?;
+            if sel != [id] {
+                self.set_selection(vec![id]);
+            }
+            self.request_ui("canvas.renameLabel", serde_json::json!({"id": id}));
+            return Ok(());
+        }
         // Quick clicks on a widget's clickable part are clicks, one by one.
-        if matches!(self.tool.tool, ToolId::Move | ToolId::Scale)
+        if edits
+            && matches!(self.tool.tool, ToolId::Move | ToolId::Scale)
             && !(ev.shift || ev.cmd || ev.alt)
             && self.hit(&doc, page, ev.p(), ev.tol() * 2.0).and_then(|hit| crate::widgets::target_at(&doc, hit, ev.p())).is_some()
         {
@@ -1864,9 +2016,13 @@ impl Session {
             self.cancel_interaction()?;
         }
         let Some(leaf) = self.hit(&doc, page, ev.p(), ev.tol() * 2.0) else { return Ok(()) };
+        if matches!(self.tool.tool, ToolId::Move | ToolId::Scale) && self.board_double_click(&doc, leaf, &sel)? {
+            return Ok(());
+        }
         let target = select_target(&doc, leaf, &sel, true);
         // Text: edit at the click.
-        if doc.node(target).is_some_and(|n| matches!(n.kind, NodeKind::Text(_)))
+        if edits
+            && doc.node(target).is_some_and(|n| matches!(n.kind, NodeKind::Text(_)))
             && (sel.contains(&target) || select_target(&doc, leaf, &sel, false) == target)
         {
             // Entering a text selects all of it; in the text being edited, the word.
@@ -1881,7 +2037,7 @@ impl Session {
             return Ok(());
         }
         // Shapes and vectors: enter vector edit mode (every selected shape, the clicked one active).
-        if doc.node(target).is_some_and(|n| n.kind.is_shape()) && sel.contains(&target) {
+        if edits && doc.node(target).is_some_and(|n| n.kind.is_shape()) && sel.contains(&target) {
             let mut ids = crate::vectoredit::enter_targets(&doc, &sel).unwrap_or_default();
             ids.retain(|i| *i != target);
             ids.insert(0, target);
@@ -2003,7 +2159,9 @@ impl Session {
             255,
         );
         let sel = ds.selection.clone();
-        if !sel.is_empty() {
+        if self.tool.pick_only {
+            self.tool.picked = Some(c);
+        } else if !sel.is_empty() {
             self.execute("node.set", &json!({"ids": sel, "props": {"fill": c.to_css_hex()}}))?;
         }
         self.recent_colors.retain(|x| *x != c);
@@ -2039,13 +2197,7 @@ impl Session {
         if self.tool.pen.is_none()
             && let Some((id, v)) = selected_end_at(&doc, &self.selection(), ev.p(), 8.0 / ev.zoom.max(1e-6))
         {
-            self.set_tool(ToolId::Move);
-            crate::vectoredit::begin(self, id)?;
-            crate::vectoredit::set_tool(self, crate::vectoredit::VTool::Pen)?;
-            return crate::vectoredit::set_state(self, |e| {
-                e.anchor = Some(v);
-                e.vertices = vec![v];
-            });
+            return self.pen_edit(id, Some(v));
         }
         let pen = self.tool.pen.get_or_insert_with(PenPath::default);
         // Clicking the first anchor closes the path.
@@ -2071,9 +2223,7 @@ impl Session {
         if ev.shift
             && let Some((last, _, _)) = pen.points.last()
         {
-            let v = p - *last;
-            let ang = (v.atan2() / (std::f64::consts::PI / 4.0)).round() * std::f64::consts::PI / 4.0;
-            p = *last + Vec2::from_angle(ang) * v.hypot();
+            p = at_45_degrees(*last, p);
         }
         pen.points.push((p, Vec2::ZERO, Vec2::ZERO));
         self.tool.gesture = Gesture::PenDrag { anchor: p };
@@ -2163,7 +2313,30 @@ impl Session {
         Ok(())
     }
 
-    /// Finish the pen path (Enter/Escape/double-click).
+    /// Edit `id` as a vector with the pen, going on from point `anchor` (or, without one, starting
+    /// a new path in the same layer at the next click).
+    fn pen_edit(&mut self, id: NodeId, anchor: Option<usize>) -> Result<()> {
+        self.set_tool(ToolId::Move);
+        crate::vectoredit::begin(self, id)?;
+        crate::vectoredit::set_tool(self, crate::vectoredit::VTool::Pen)?;
+        crate::vectoredit::set_state(self, |e| {
+            e.anchor = anchor;
+            e.vertices = anchor.into_iter().collect();
+        })
+    }
+
+    /// Enter/Escape while the pen draws: the path ends but its layer stays in edit mode with the
+    /// pen, so the next path joins the same vector (another Escape leaves edit mode).
+    pub fn pen_end(&mut self) -> Result<()> {
+        let id = self.tool.pen.as_ref().and_then(|p| p.id);
+        self.pen_finish()?;
+        match id {
+            Some(id) if self.doc()?.contains(id) => self.pen_edit(id, None),
+            _ => Ok(()),
+        }
+    }
+
+    /// Finish the pen path (and keep the pen tool: double-click, Delete, a tool switch).
     pub fn pen_finish(&mut self) -> Result<()> {
         let pen = self.tool.pen.take();
         self.tool.overlay.pen.clear();
@@ -2192,14 +2365,17 @@ impl Session {
         }
         let fitted = figcraft_geom::kurbo::simplify::simplify_bezpath(poly.iter(), 0.75, &Default::default());
         let d = fitted.to_svg();
+        if matches!(self.tool.tool, ToolId::Marker | ToolId::Highlighter) {
+            return self.ink_finish(&d);
+        }
         let page = self.page()?;
         let parent = frame_at(self.doc()?, page, points.first().copied().unwrap_or_default(), &[]).unwrap_or(page);
         let pw = self.doc()?.world_transform(parent);
         let mut local = fitted.clone();
         local.apply_affine(pw.inverse());
         let _ = d;
-        let mut props =
-            json!({"fills": [], "strokes": ["#000000"], "strokeWeight": 2, "strokeCap": "round", "strokeJoin": "round", "strokeAlign": "center"});
+        let (color, weight) = PENCIL_STROKE;
+        let mut props = json!({"fills": [], "strokes": [color.to_css_hex()], "strokeWeight": weight, "strokeCap": "round", "strokeJoin": "round", "strokeAlign": "center"});
         // Pen pressure becomes the stroke's width profile (brushes follow it too).
         if let Some(points) = pressure_profile(points, pressure) {
             props["widthProfile"] = json!(points);
@@ -2217,6 +2393,10 @@ impl Session {
     /// Keys the current mode handles before menu shortcuts (vector edit mode's tools and point
     /// keys, Enter to finish the shape builder). Returns whether the key was used.
     pub fn tool_key(&mut self, name: &str, shift: bool, alt: bool, cmd: bool) -> Result<bool> {
+        // Dev Mode edits nothing: keys go to the commands (which it refuses in the app).
+        if self.tool.dev_mode {
+            return Ok(false);
+        }
         if self.ds().is_ok_and(|d| d.vector_edit.is_some()) {
             return crate::vectoredit::key(self, name, shift, alt, cmd);
         }
@@ -2308,7 +2488,7 @@ impl Session {
             return Ok(());
         }
         if self.tool.pen.is_some() {
-            return self.pen_finish();
+            return self.pen_end();
         }
         if self.tool.busy() {
             self.tool.gesture = Gesture::None;
@@ -2358,6 +2538,7 @@ impl Session {
     fn arc_handles_shown(&self) -> bool {
         let arc_drag = matches!(self.tool.gesture, Gesture::Arc { .. } | Gesture::Shape { .. });
         self.tool.tool == ToolId::Move
+            && !self.tool.dev_mode
             && (arc_drag || !self.tool.busy())
             && self.ds().is_ok_and(|ds| ds.vector_edit.is_none() && ds.text_edit.is_none())
     }
diff --git a/crates/engine/src/variable_tests.rs b/crates/engine/src/variable_tests.rs
index 536b26995..dcdd04e32 100644
--- a/crates/engine/src/variable_tests.rs
+++ b/crates/engine/src/variable_tests.rs
@@ -5,6 +5,79 @@ use serde_json::json;
 use crate::Session;
 use crate::params::id_of;
 
+fn stale_bound_color_document() -> (figcraft_doc::Document, figcraft_doc::NodeId) {
+    let mut s = Session::new();
+    let id = id_of(&s.execute("shape.rectangle", &json!({"x": 4000, "y": 4000, "width": 23, "height": 17})).unwrap()["id"]).unwrap();
+    let page = s.doc().unwrap().first_page().unwrap();
+    s.execute("variable.createCollection", &json!({"name": "Theme", "modes": ["Light", "Dark"]})).unwrap();
+    s.execute("variable.create", &json!({"collection": "Theme", "name": "surface", "type": "color", "value": "#FFFFFF"})).unwrap();
+    s.execute("variable.create", &json!({"collection": "Theme", "name": "size", "type": "number", "value": 23})).unwrap();
+    s.execute("variable.set", &json!({"variable": "surface", "mode": "Dark", "value": "#202124"})).unwrap();
+    s.execute("variable.set", &json!({"variable": "size", "mode": "Dark", "value": 99})).unwrap();
+    s.execute("variable.bind", &json!({"ids": [id], "field": "fill", "variable": "surface"})).unwrap();
+    s.execute("variable.bind", &json!({"ids": [id], "field": "width", "variable": "size"})).unwrap();
+    s.execute("variable.setMode", &json!({"collection": "Theme", "mode": "Dark"})).unwrap();
+    let mut doc = s.doc().unwrap().clone();
+    let node = doc.get_mut(id).unwrap();
+    node.name = "load-binding-sentinel".into();
+    node.fills = vec![figcraft_color::Paint::solid(figcraft_color::Color::WHITE)];
+    node.width = 5.0;
+    node.source = Some(page);
+    node.overrides.insert("sentinel".into());
+    doc.take_dirty();
+    (doc, id)
+}
+
+fn assert_dark_bound_color(doc: &figcraft_doc::Document, transform: figcraft_doc::geom::Affine) -> figcraft_doc::NodeId {
+    let node = doc.nodes().find(|n| n.name == "load-binding-sentinel").unwrap();
+    assert_eq!(node.fills.first().and_then(|p| p.solid_color()).map(|c| c.to_hex()), Some("202124".into()));
+    assert_eq!((node.transform, node.width, node.height), (transform, 5.0, 17.0));
+    assert!(node.bound.contains_key("fills/0/color") || node.bound.contains_key("fill"));
+    node.id
+}
+
+#[test]
+fn initial_color_bindings_settle_in_constructor_and_loaders() {
+    let (stale, _id) = stale_bound_color_document();
+    let name_transform = stale.nodes().find(|n| n.name == "load-binding-sentinel").unwrap().transform;
+
+    let mut state = Session::with_document(stale.clone());
+    let id = assert_dark_bound_color(state.doc().unwrap(), name_transform);
+    assert_eq!(state.doc().unwrap().node(id).unwrap().source, stale.first_page());
+    assert!(state.doc().unwrap().node(id).unwrap().overrides.contains("sentinel"));
+    assert!(!state.ds().unwrap().is_dirty());
+    assert!(state.doc().unwrap().dirty().is_empty());
+    assert_eq!(state.undo_depth(), (0, 0));
+    state.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 2, "height": 2})).unwrap();
+    assert_dark_bound_color(state.doc().unwrap(), name_transform);
+
+    let native = figcraft_format::save_bytes(&stale, None).unwrap();
+    let (loaded, _) = crate::cmd::file::load_bytes(&native, "bindings.figcraft").unwrap();
+    // A native file settles when it opens as a document, not in the loader.
+    let opened = Session::with_document(loaded);
+    let loaded = opened.doc().unwrap();
+    let loaded_id = assert_dark_bound_color(loaded, name_transform);
+    assert_eq!(loaded_id, id);
+    assert_eq!(loaded.node(id).unwrap().source, stale.first_page());
+    assert!(loaded.node(id).unwrap().overrides.contains("sentinel"));
+    assert!(loaded.dirty().is_empty());
+
+    let (fig, _) = figcraft_format::fig::export(&stale, None).unwrap();
+    let (loaded, _) = crate::cmd::file::load_bytes(&fig, "bindings.fig").unwrap();
+    assert_dark_bound_color(&loaded, name_transform);
+}
+
+#[test]
+fn initial_paint_settlement_preserves_existing_dirty_nodes() {
+    let (mut doc, _) = stale_bound_color_document();
+    let page = doc.first_page().unwrap();
+    doc.mark_dirty([page]);
+
+    crate::cmd::styles::apply_paint_bindings_on_load(&mut doc);
+
+    assert_eq!(doc.dirty().iter().copied().collect::<Vec<_>>(), [page]);
+}
+
 #[test]
 fn bound_layers_follow_variable_values_and_unbind() {
     let mut s = Session::new();
diff --git a/crates/engine/src/variables_behaviour_tests.rs b/crates/engine/src/variables_behaviour_tests.rs
index 5a868a637..3fe156f81 100644
--- a/crates/engine/src/variables_behaviour_tests.rs
+++ b/crates/engine/src/variables_behaviour_tests.rs
@@ -279,6 +279,34 @@ fn bindings_by_field_and_type() {
     }
 }
 
+#[test]
+fn auto_layout_bindings_go_with_the_auto_layout() {
+    // Docs silent; pinned (#810): removing a frame's auto layout drops its gap and padding bindings,
+    // and a binding never brings an auto layout back. One made without auto layout waits for it.
+    let mut s = Session::new();
+    run(&mut s, "variable.createCollection", json!({"name": "C"}));
+    run(&mut s, "variable.create", json!({"collection": "C", "name": "g", "type": "number", "value": 12}));
+    let removals =
+        [("layout.remove", json!({})), ("node.set", json!({"props": {"layout": null}})), ("node.set", json!({"props": {"layout": "none"}}))];
+    for (cmd, mut p) in removals {
+        let f = frame(&mut s, None);
+        run(&mut s, "layout.add", json!({"ids": [f]}));
+        for field in ["gap", "crossGap", "paddingTop"] {
+            run(&mut s, "variable.bind", json!({"ids": [f], "field": field, "variable": "g"}));
+        }
+        p["ids"] = json!([f]);
+        run(&mut s, cmd, p.clone());
+        let n = node(&s, f);
+        assert!(n.layout.is_none(), "{cmd} {p}: auto layout stays removed");
+        assert!(n.bound.is_empty(), "{cmd} {p}: layout bindings dropped");
+    }
+    let f = frame(&mut s, None);
+    run(&mut s, "variable.bind", json!({"ids": [f], "field": "gap", "variable": "g"}));
+    assert!(node(&s, f).layout.is_none(), "binding gap adds no auto layout");
+    run(&mut s, "layout.add", json!({"ids": [f]}));
+    assert_eq!(node(&s, f).layout.map(|l| l.gap), Some(12.0), "the waiting binding applies to the new auto layout");
+}
+
 #[test]
 fn deleting_a_bound_variable_keeps_the_last_value() {
     // Documented: deleting a variable unbinds what used it, which keeps showing its last value.
@@ -365,3 +393,90 @@ fn number_variables_are_pixels_and_edits_are_one_undo_step() {
     s.undo().unwrap();
     assert_eq!(lh(&s), LineHeight::Pixels(20.0), "the value and the bound layer go back together");
 }
+
+#[test]
+fn create_collection_keeps_at_least_one_named_mode() {
+    // A collection keeps at least one mode (removeMode) and mode names can't be empty (renameMode),
+    // so createCollection refuses an empty mode list, blank mode names and a blank collection name.
+    let mut s = Session::new();
+    for p in [
+        json!({"name": "C", "modes": []}),
+        json!({"name": "C", "modes": [1]}),
+        json!({"name": "C", "modes": ["", "  "]}),
+        json!({"name": "C", "modes": ["A", " "]}),
+        json!({"name": "  "}),
+        json!({"name": ""}),
+    ] {
+        assert!(s.execute("variable.createCollection", &p).is_err(), "{p} should be refused");
+    }
+    assert!(s.doc().unwrap().variables.collections.is_empty(), "a refused call creates nothing");
+    run(&mut s, "variable.createCollection", json!({"name": "C", "modes": [" Light ", "Dark"]}));
+    let names: Vec<String> = s.doc().unwrap().variables.collections[0].modes.iter().map(|m| m.name.clone()).collect();
+    assert_eq!(names, ["Light", "Dark"]);
+}
+
+#[test]
+fn explicit_edits_of_bound_fields_stick_and_detach_that_binding() {
+    // #809: an edit of a bound field detaches its binding (as a paint edit does) instead of
+    // the variable's value coming back; bindings whose value the edit kept stay.
+    let mut s = Session::new();
+    run(&mut s, "variable.createCollection", json!({"name": "C"}));
+    let w = vid(run(&mut s, "variable.create", json!({"collection": "C", "name": "w", "type": "number", "value": 48})));
+    let o = vid(run(&mut s, "variable.create", json!({"collection": "C", "name": "o", "type": "number", "value": 40})));
+    let r = rect(&mut s, None);
+    for (field, v) in [("width", &w), ("height", &w), ("opacity", &o)] {
+        run(&mut s, "variable.bind", json!({"ids": [r], "field": field, "variable": v}));
+    }
+    assert_eq!((node(&s, r).width, node(&s, r).opacity), (48.0, 0.4));
+
+    run(&mut s, "node.set", json!({"ids": [r], "width": 100, "opacity": 0.4}));
+    let n = node(&s, r);
+    assert_eq!(n.width, 100.0);
+    assert!(!n.bound.contains_key("width"));
+    assert!(n.bound.contains_key("height") && n.bound.contains_key("opacity"), "unchanged values keep their bindings");
+
+    run(&mut s, "transform.resize", json!({"ids": [r], "height": 30}));
+    assert_eq!(node(&s, r).height, 30.0);
+    assert!(!node(&s, r).bound.contains_key("height"));
+
+    run(&mut s, "object.opacityKeys", json!({"ids": [r], "digits": "9"}));
+    assert_eq!(node(&s, r).opacity, 0.9);
+    assert!(node(&s, r).bound.is_empty());
+
+    // A value set with its binding in the same call keeps the new binding.
+    run(&mut s, "node.set", json!({"ids": [r], "width": 5, "boundVariables": {"width": w}}));
+    assert_eq!((node(&s, r).width, node(&s, r).bound.get("width")), (48.0, Some(&w)));
+}
+
+#[test]
+fn a_gesture_or_a_text_style_on_a_bound_field_detaches_it() {
+    let mut s = Session::new();
+    run(&mut s, "variable.createCollection", json!({"name": "C"}));
+    let v = vid(run(&mut s, "variable.create", json!({"collection": "C", "name": "r", "type": "number", "value": 8})));
+    let r = rect(&mut s, None);
+    run(&mut s, "variable.bind", json!({"ids": [r], "field": "cornerRadius", "variable": v}));
+    s.begin_interaction("Edit").unwrap();
+    let props = serde_json::Map::from_iter([("cornerRadius".to_string(), json!(2))]);
+    s.preview(|d, _| crate::cmd::props::apply("node.set", d, r, &props)).unwrap();
+    s.commit_interaction().unwrap();
+    assert_eq!(node(&s, r).corners.radii, [2.0; 4]);
+    assert!(node(&s, r).bound.is_empty());
+
+    let t = id(run(&mut s, "text.create", json!({"x": 0, "y": 0, "text": "Hi"})));
+    run(&mut s, "variable.bind", json!({"ids": [t], "field": "fontSize", "variable": v}));
+    run(&mut s, "text.style", json!({"id": t, "fontSize": 20}));
+    assert!(node(&s, t).bound.is_empty());
+    assert_eq!(node(&s, t).kind.text().unwrap().style.font_size, 20.0);
+
+    // The font size/weight/tracking shortcuts and text content edits detach too.
+    run(&mut s, "variable.bind", json!({"ids": [t], "field": "fontSize", "variable": v}));
+    assert_eq!(node(&s, t).kind.text().unwrap().style.font_size, 8.0);
+    run(&mut s, "text.sizeUp", json!({"ids": [t]}));
+    assert_eq!(node(&s, t).kind.text().unwrap().style.font_size, 9.0);
+    assert!(node(&s, t).bound.is_empty());
+    let c = vid(run(&mut s, "variable.create", json!({"collection": "C", "name": "c", "type": "string", "value": "Hello"})));
+    run(&mut s, "variable.bind", json!({"ids": [t], "field": "characters", "variable": c}));
+    run(&mut s, "text.set", json!({"id": t, "characters": "Bye"}));
+    assert_eq!(node(&s, t).kind.text().unwrap().characters, "Bye");
+    assert!(node(&s, t).bound.is_empty());
+}
diff --git a/crates/engine/src/variables_import_shapes_tests.rs b/crates/engine/src/variables_import_shapes_tests.rs
new file mode 100644
index 000000000..067ccab23
--- /dev/null
+++ b/crates/engine/src/variables_import_shapes_tests.rs
@@ -0,0 +1,60 @@
+//! `variable.import` reads `variables` next to `variableCollections`, under `meta` or at the top
+//! level, and never imports nothing without saying so (#790).
+
+use serde_json::{Value, json};
+
+use crate::Session;
+
+fn collections() -> Value {
+    json!({"VC:1": {"id": "VC:1", "name": "Theme", "modes": [{"modeId": "1:0", "name": "Light"}], "defaultModeId": "1:0",
+                    "variableIds": ["VariableID:1"]}})
+}
+
+fn variables() -> Value {
+    json!({"VariableID:1": {"id": "VariableID:1", "name": "bg", "variableCollectionId": "VC:1", "resolvedType": "COLOR",
+                            "valuesByMode": {"1:0": {"r": 1.0, "g": 1.0, "b": 1.0, "a": 1.0}}}})
+}
+
+fn import(json: Value) -> Value {
+    let mut s = Session::new();
+    match s.execute("variable.import", &json!({"variables": json})) {
+        Ok(r) => r,
+        Err(e) => panic!("{e}"),
+    }
+}
+
+#[test]
+fn variables_import_reads_every_shape() {
+    for shape in [
+        json!({"meta": {"variableCollections": collections(), "variables": variables()}}),
+        json!({"variableCollections": collections(), "variables": variables()}),
+        json!({"meta": {"variableCollections": collections()}, "variables": variables()}),
+        json!({"variableCollections": collections(), "meta": {"variables": variables()}}),
+    ] {
+        let r = import(shape.clone());
+        assert_eq!((r["collections"].as_u64(), r["variables"].as_u64()), (Some(1), Some(1)), "{shape}: {r}");
+        assert_eq!(r["warnings"], json!([]), "{shape}: {r}");
+    }
+}
+
+#[test]
+fn variables_import_never_imports_nothing_silently() {
+    // Collections without variables: they are added, with a warning saying where variables go.
+    let r = import(json!({"meta": {"variableCollections": collections()}}));
+    assert_eq!((r["collections"].as_u64(), r["variables"].as_u64()), (Some(1), Some(0)), "{r}");
+    assert!(r["warnings"].to_string().contains("no variables found: expected `meta.variables`"), "{r}");
+    // An empty file's export reads back with the same warning, not an error.
+    let mut s = Session::new();
+    let text = s.execute("variable.export", &json!({})).unwrap()["text"].as_str().unwrap().to_string();
+    let r = s.execute("variable.import", &json!({"variables": text})).unwrap();
+    assert!(r["warnings"].to_string().contains("no variables found"), "{r}");
+    // Collections listing variables that aren't there.
+    let mut colls = collections();
+    colls["VC:1"]["variableIds"] = json!(["VariableID:1", "VariableID:2"]);
+    let r = import(json!({"meta": {"variableCollections": colls, "variables": variables()}}));
+    assert_eq!(r["variables"].as_u64(), Some(1), "{r}");
+    assert!(r["warnings"].to_string().contains("1 of the 2 variables the collections list in `variableIds` weren't imported"), "{r}");
+    // No collections anywhere: an error naming the expected shape.
+    let e = Session::new().execute("variable.import", &json!({"variables": {"variables": variables()}})).unwrap_err().to_string();
+    assert!(e.contains("(`meta.variableCollections` and `meta.variables`)"), "{e}");
+}
diff --git a/crates/engine/src/variables_io_tests.rs b/crates/engine/src/variables_io_tests.rs
index 5c7305bb5..3a57d9eac 100644
--- a/crates/engine/src/variables_io_tests.rs
+++ b/crates/engine/src/variables_io_tests.rs
@@ -371,3 +371,29 @@ fn variant_properties_follow_string_variables() {
     assert_eq!(main(&s), variants[1]);
     healthy(&s);
 }
+
+#[test]
+fn paints_replaced_through_node_set_keep_unchanged_stop_bindings() {
+    let mut s = Session::new();
+    let r = gradient_rect(&mut s);
+    ex(&mut s, "variable.bind", json!({"ids": [r], "field": "fills/0/stops/2/color", "variable": "brand"}));
+    ex(&mut s, "variable.bind", json!({"ids": [r], "field": "fills/0/stops/1/color", "variable": "ink"}));
+    let cur = |s: &Session| s.doc().unwrap().node(r).unwrap().fills[0].clone();
+    // Removing the first stop moves both bindings down with their stops.
+    let mut p = cur(&s);
+    if let PaintKind::Gradient(g) = &mut p.kind {
+        g.stops.remove(0);
+    }
+    ex(&mut s, "node.set", json!({"ids": [r], "props": {"fills": [p]}}));
+    assert_eq!(bound_keys(&s, r), ["fills/0/stops/0/color", "fills/0/stops/1/color"]);
+    // Recolouring one bound stop detaches that stop only.
+    let mut p = cur(&s);
+    if let PaintKind::Gradient(g) = &mut p.kind {
+        g.stops[0].color = Color::WHITE;
+    }
+    ex(&mut s, "node.set", json!({"ids": [r], "props": {"fills": [p]}}));
+    assert_eq!(bound_keys(&s, r), ["fills/0/stops/1/color"]);
+    ex(&mut s, "variable.set", json!({"variable": "brand", "value": "#0000ff"}));
+    assert_eq!(stops(&s, r), ["FFFFFF", "0000FF"]);
+    healthy(&s);
+}
diff --git a/crates/engine/src/variants_discovery_tests.rs b/crates/engine/src/variants_discovery_tests.rs
new file mode 100644
index 000000000..b792e727c
--- /dev/null
+++ b/crates/engine/src/variants_discovery_tests.rs
@@ -0,0 +1,179 @@
+//! Combine as variants and Add variant where people look for them (#903): the predicates the
+//! context menu and the Design panel offer them by, combining refusing components that are
+//! variants already (it used to put a set inside a set), and Add variant on a main component that
+//! isn't in a set yet making it one.
+
+use serde_json::json;
+
+use crate::Session;
+use crate::cmd::component::{can_add_variant, can_combine_variants};
+use crate::components::tests::{ex, healthy, idv, kids, node};
+use figcraft_doc::*;
+
+/// A main component named `name` at `x`, made from a 120×40 frame with a "Bg" rectangle.
+fn component(s: &mut Session, name: &str, x: f64) -> NodeId {
+    let f = idv(&ex(s, "frame.create", json!({"x": x, "y": 0, "width": 120, "height": 40, "name": name})));
+    ex(s, "shape.rectangle", json!({"x": 0, "y": 0, "width": 120, "height": 40, "parent": f, "props": {"name": "Bg"}}));
+    idv(&ex(s, "component.create", json!({"ids": [f]})))
+}
+
+fn undo_len(s: &Session) -> usize {
+    s.ds().unwrap().history.undo.len()
+}
+
+fn sets(s: &Session) -> usize {
+    s.doc().unwrap().nodes().filter(|n| matches!(n.kind, NodeKind::ComponentSet { .. })).count()
+}
+
+#[test]
+fn combine_is_offered_for_two_or_more_main_components_only() {
+    let mut s = Session::new();
+    let a = component(&mut s, "A", 0.0);
+    let b = component(&mut s, "B", 200.0);
+    let frame = idv(&ex(&mut s, "frame.create", json!({"x": 0, "y": 300, "width": 50, "height": 50})));
+    let inst = idv(&ex(&mut s, "instance.create", json!({"component": a, "x": 0, "y": 400})));
+    let doc = s.doc().unwrap();
+    assert!(can_combine_variants(doc, &[a, b]));
+    assert!(!can_combine_variants(doc, &[]), "nothing selected");
+    assert!(!can_combine_variants(doc, &[a]), "one component (the command still takes it)");
+    assert!(!can_combine_variants(doc, &[a, a]), "the same component twice");
+    assert!(!can_combine_variants(doc, &[a, frame]), "a frame isn't a component");
+    assert!(!can_combine_variants(doc, &[a, inst]), "an instance isn't a main component");
+
+    let c = component(&mut s, "C", 400.0);
+    let d = component(&mut s, "D", 600.0);
+    let set = idv(&ex(&mut s, "component.combineVariants", json!({"ids": [c, d]})));
+    let doc = s.doc().unwrap();
+    assert!(!can_combine_variants(doc, &[c, d]), "variants of one set");
+    assert!(!can_combine_variants(doc, &[c, a]), "a variant and a lone component");
+    assert!(!can_combine_variants(doc, &[set, a]), "a set isn't a component");
+
+    // Components in different frames still combine.
+    let holder = idv(&ex(&mut s, "frame.create", json!({"x": 0, "y": 600, "width": 300, "height": 100})));
+    let e = component(&mut s, "E", 0.0);
+    ex(&mut s, "node.reparent", json!({"ids": [e], "parent": holder}));
+    assert!(can_combine_variants(s.doc().unwrap(), &[a, e]));
+}
+
+#[test]
+fn add_variant_is_offered_for_sets_variants_and_lone_components() {
+    let mut s = Session::new();
+    let a = component(&mut s, "A", 0.0);
+    let b = component(&mut s, "B", 200.0);
+    let lone = component(&mut s, "Lone", 400.0);
+    let set = idv(&ex(&mut s, "component.combineVariants", json!({"ids": [a, b]})));
+    let frame = idv(&ex(&mut s, "frame.create", json!({"x": 0, "y": 300, "width": 50, "height": 50})));
+    let inst = idv(&ex(&mut s, "instance.create", json!({"component": lone, "x": 0, "y": 400})));
+    let doc = s.doc().unwrap();
+    assert!(can_add_variant(doc, set));
+    assert!(can_add_variant(doc, a));
+    assert!(can_add_variant(doc, lone));
+    assert!(!can_add_variant(doc, frame));
+    assert!(!can_add_variant(doc, inst));
+    assert!(!can_add_variant(doc, kids(&s, inst)[0]), "a layer inside an instance");
+    assert!(!can_add_variant(doc, NodeId(999_999)));
+}
+
+#[test]
+fn combining_variants_again_is_refused_instead_of_nesting_sets() {
+    let mut s = Session::new();
+    let a = component(&mut s, "State=Default", 0.0);
+    let b = component(&mut s, "State=Hover", 200.0);
+    let lone = component(&mut s, "State=Pressed", 400.0);
+    let set = idv(&ex(&mut s, "component.combineVariants", json!({"ids": [a, b]})));
+    let before = s.doc().unwrap().clone();
+    let steps = undo_len(&s);
+    for ids in [vec![a, b], vec![a, lone]] {
+        let err = s.execute("component.combineVariants", &json!({"ids": ids})).unwrap_err();
+        assert!(err.to_string().contains("variants already"), "{err}");
+    }
+    assert_eq!(*s.doc().unwrap(), before, "a refused combine changes nothing");
+    assert_eq!(undo_len(&s), steps);
+    assert_eq!(sets(&s), 1);
+    assert_eq!(kids(&s, set), vec![a, b]);
+    // One lone component still makes a set of one (other commands rely on it).
+    ex(&mut s, "component.combineVariants", json!({"ids": [lone]}));
+    assert_eq!(sets(&s), 2);
+    healthy(&s);
+}
+
+#[test]
+fn combining_refuses_nested_components_and_components_inside_instances() {
+    let mut s = Session::new();
+    // A "Card" component holding an "Icon" component.
+    let card = idv(&ex(&mut s, "frame.create", json!({"x": 0, "y": 0, "width": 200, "height": 100, "name": "Card"})));
+    let icon = idv(&ex(&mut s, "frame.create", json!({"x": 10, "y": 10, "width": 20, "height": 20, "name": "Icon", "parent": card})));
+    let icon = idv(&ex(&mut s, "component.create", json!({"ids": [icon]})));
+    let card = idv(&ex(&mut s, "component.create", json!({"ids": [card]})));
+    let other = component(&mut s, "Other", 300.0);
+    let inst = idv(&ex(&mut s, "instance.create", json!({"component": card, "x": 0, "y": 300})));
+    let inner = kids(&s, inst).into_iter().find(|c| matches!(node(&s, *c).kind, NodeKind::Component { .. })).expect("the instance's copy of Icon");
+
+    let doc = s.doc().unwrap();
+    assert!(!can_combine_variants(doc, &[card, icon]), "a component and one inside it");
+    assert!(can_combine_variants(doc, &[icon, other]), "a nested component with another one is fine");
+    assert!(!can_combine_variants(doc, &[inner, other]), "a component inside an instance");
+    let before = s.doc().unwrap().clone();
+    let err = s.execute("component.combineVariants", &json!({"ids": [card, icon]})).unwrap_err();
+    assert!(err.to_string().contains("inside it"), "{err}");
+    assert_eq!(*s.doc().unwrap(), before);
+}
+
+#[test]
+fn add_variant_on_a_lone_component_makes_it_a_set_in_one_step() {
+    let mut s = Session::new();
+    let c = component(&mut s, "Button", 0.0);
+    let inst = idv(&ex(&mut s, "instance.create", json!({"component": c, "x": 0, "y": 300})));
+    let before = s.doc().unwrap().clone();
+    let steps = undo_len(&s);
+
+    let v = idv(&ex(&mut s, "component.addVariant", json!({"id": c})));
+    let set = node(&s, c).parent.unwrap();
+    let set_node = node(&s, set);
+    assert!(matches!(set_node.kind, NodeKind::ComponentSet { .. }));
+    assert_eq!(set_node.name, "Button", "the set takes the component's name");
+    assert_eq!(kids(&s, set), vec![c, v]);
+    assert_eq!(node(&s, c).name, "Property 1=Default");
+    assert_eq!(node(&s, v).name, "Property 1=Variant2");
+    assert_eq!(s.selection(), vec![v]);
+    assert!(set_node.height >= 40.0 * 2.0 + 20.0, "the set wraps both variants: {}", set_node.height);
+    assert!(matches!(node(&s, inst).kind, NodeKind::Instance { component, .. } if component == c), "instances keep their main");
+    assert_eq!(undo_len(&s), steps + 1, "wrapping and adding are one undo step");
+    healthy(&s);
+
+    s.undo().unwrap();
+    assert_eq!(*s.doc().unwrap(), before, "undo puts the lone component back");
+}
+
+#[test]
+fn add_variant_on_a_lone_component_keeps_prop_value_names_and_rolls_back_on_errors() {
+    let mut s = Session::new();
+    let c = component(&mut s, "Size=Small", 0.0);
+    let before = s.doc().unwrap().clone();
+    let steps = undo_len(&s);
+    assert!(s.execute("component.addVariant", &json!({"id": c, "property": "Nope", "value": "x"})).is_err());
+    assert_eq!(*s.doc().unwrap(), before, "a refused Add variant leaves no set behind");
+    assert_eq!(undo_len(&s), steps);
+
+    let v = idv(&ex(&mut s, "component.addVariant", json!({"id": c, "property": "Size", "value": "Large"})));
+    assert_eq!(node(&s, c).name, "Size=Small");
+    assert_eq!(node(&s, v).name, "Size=Large");
+    healthy(&s);
+}
+
+#[test]
+fn add_variant_on_a_lone_component_in_auto_layout_keeps_its_place() {
+    let mut s = Session::new();
+    let row = idv(&ex(&mut s, "frame.create", json!({"x": 0, "y": 0, "width": 400, "height": 100, "name": "Row"})));
+    ex(&mut s, "layout.add", json!({"ids": [row]}));
+    let first = idv(&ex(&mut s, "shape.rectangle", json!({"x": 0, "y": 0, "width": 40, "height": 40, "parent": row})));
+    let c = component(&mut s, "Chip", 0.0);
+    ex(&mut s, "node.reparent", json!({"ids": [c], "parent": row}));
+    let last = idv(&ex(&mut s, "shape.rectangle", json!({"x": 0, "y": 0, "width": 40, "height": 40, "parent": row})));
+
+    ex(&mut s, "component.addVariant", json!({"id": c}));
+    let set = node(&s, c).parent.unwrap();
+    assert_eq!(kids(&s, row), vec![first, set, last], "the set takes the component's place in the row");
+    assert_eq!(kids(&s, set).len(), 2);
+    healthy(&s);
+}
diff --git a/crates/engine/src/vector_behaviour_tests.rs b/crates/engine/src/vector_behaviour_tests.rs
index 0c472eccd..fb734085b 100644
--- a/crates/engine/src/vector_behaviour_tests.rs
+++ b/crates/engine/src/vector_behaviour_tests.rs
@@ -133,6 +133,50 @@ fn entering_and_leaving_vector_edit_mode() {
     assert!(matches!(s.doc().unwrap().node(id).unwrap().kind, NodeKind::Rectangle), "converting is one undo step");
 }
 
+#[test]
+fn thin_strokes_are_easy_to_enter_and_bend() {
+    use crate::tools::ToolId;
+    // A diagonal line from (100, 100) to (200, 50); `off` steps away from its middle, square to it.
+    let at = |off: f64| (150.0 + off * 50.0 / 125f64.sqrt() / 10.0, 75.0 + off * 100.0 / 125f64.sqrt() / 10.0);
+    // (layer, screen px off the stroke, in edit mode after a double-click, derivation)
+    let rows: Vec<(&str, f64, bool, &str)> = vec![
+        ("line", 0.0, true, "double-clicking a selected line edits it as a vector"),
+        ("line", 4.0, true, "a 1 px line reaches a few pixels, so a double-click near it still lands (#646)"),
+        ("line", 8.0, false, "a double-click well away from it does not"),
+        ("path", 4.0, true, "a stroke-only path reaches as far as a line does"),
+        ("path", 8.0, false, "and no further"),
+    ];
+    for (layer, off, after, why) in rows {
+        let mut s = Session::new();
+        let id = if layer == "line" {
+            s.set_tool(ToolId::Line);
+            drag(&mut s, (100.0, 100.0), (200.0, 50.0), NONE);
+            *s.selection().first().unwrap()
+        } else {
+            let id = id_of(&ex(&mut s, "vector.create", json!({"points": [[100, 100], [200, 50]], "closed": false}))["id"]).unwrap();
+            // Styled like a pen stroke: 1 px, no fill.
+            ex(&mut s, "node.set", json!({"ids": [id], "props": {"fills": [], "strokes": ["#000000"], "strokeWeight": 1}}));
+            s.set_selection(vec![id]);
+            id
+        };
+        assert!(!s.doc().unwrap().node(id).unwrap().fills.iter().any(|f| f.visible), "{why}: the {layer} only has a stroke");
+        let p = at(off);
+        click(&mut s, p, NONE);
+        s.pointer(&ev(PointerKind::Down, p, NONE)).unwrap();
+        s.pointer(&ev(PointerKind::DoubleClick, p, NONE)).unwrap();
+        s.pointer(&ev(PointerKind::Up, p, NONE)).unwrap();
+        assert_eq!(editing(&s).is_some(), after, "{why}");
+        if after {
+            // Cmd/Ctrl then bends it through the pointer.
+            drag(&mut s, at(0.0), (170.0, 115.0), Mods { cmd: true, ..NONE });
+            let w = s.doc().unwrap().world_transform(id);
+            let n = net(&s, id);
+            assert!(!n.segments[0].is_straight(), "{why}: Cmd/Ctrl bends it");
+            assert!((w * n.cubic(0).unwrap().eval(0.5) - Point::new(170.0, 115.0)).hypot() < 1.0, "{why}: through the pointer");
+        }
+    }
+}
+
 #[test]
 fn the_pen_follows_the_documented_rules() {
     let mut s = Session::new();
@@ -395,3 +439,61 @@ fn bend_paint_bucket_cut_join_and_eraser_tools() {
     assert_eq!(net(&s, id).segments.len(), 2, "the eraser removes what it passes over");
     assert_eq!(s.doc().unwrap().node(page).unwrap().children, vec![id], "and the pieces stay one layer");
 }
+
+#[test]
+fn vector_paths_take_the_requested_size_and_refuse_empty_geometry() {
+    let mut s = Session::new();
+    let path = "M0 0 L24 0 L24 24 L0 24 Z";
+    let intrinsic = id_of(&ex(&mut s, "vector.create", json!({"path": path}))["id"]).unwrap();
+    let n = s.doc().unwrap().node(intrinsic).unwrap();
+    assert_eq!((n.width, n.height), (24.0, 24.0), "a path without a size keeps its intrinsic box");
+    // Both sides: each scales independently, like resizing a vector.
+    let both = id_of(&ex(&mut s, "vector.create", json!({"path": path, "width": 16, "height": 8}))["id"]).unwrap();
+    let n = s.doc().unwrap().node(both).unwrap();
+    assert_eq!((n.width, n.height), (16.0, 8.0));
+    let n = net(&s, both);
+    let max = n.vertices.iter().fold((0.0f64, 0.0f64), |(x, y), v| (x.max(v.x), y.max(v.y)));
+    assert!((max.0 - 16.0).abs() < 1e-9 && (max.1 - 8.0).abs() < 1e-9, "{max:?}: the geometry itself is scaled");
+    // One side: the other keeps its proportion.
+    let width = id_of(&ex(&mut s, "vector.create", json!({"path": path, "width": 16}))["id"]).unwrap();
+    let n = s.doc().unwrap().node(width).unwrap();
+    assert_eq!((n.width, n.height), (16.0, 16.0));
+    // A path or point set that draws nothing is an error, not an invisible zero-size layer.
+    let e = s.execute("vector.create", &json!({"path": "M5 5"})).unwrap_err().to_string();
+    assert!(e.contains("draws nothing"), "{e}");
+    let e = s.execute("vector.create", &json!({"points": [[5, 5], [5, 5]]})).unwrap_err().to_string();
+    assert!(e.contains("draws nothing"), "{e}");
+    // A size on an axis the geometry has none of is refused, not silently ignored.
+    let e = s.execute("vector.create", &json!({"path": "M0 0 L0 24", "width": 16})).unwrap_err().to_string();
+    assert!(e.contains("horizontal extent"), "{e}");
+    let e = s.execute("vector.create", &json!({"path": "M0 0 L24 0", "height": 16})).unwrap_err().to_string();
+    assert!(e.contains("vertical extent"), "{e}");
+    // But 0 on an axis it has none of is what it already is: a horizontal line with height 0.
+    let line = id_of(&ex(&mut s, "vector.create", json!({"path": "M0 0 L24 0", "width": 16, "height": 0}))["id"]).unwrap();
+    let n = s.doc().unwrap().node(line).unwrap();
+    assert_eq!((n.width, n.height), (16.0, 0.0));
+    // A size of 0 or less on an axis it has would flatten it, so it is refused, alone or with the other.
+    for p in [json!({"path": path, "width": 0}), json!({"path": path, "width": 16, "height": 0}), json!({"path": path, "width": -4, "height": 8})] {
+        let e = s.execute("vector.create", &p).unwrap_err().to_string();
+        assert!(e.contains("positive"), "{p}: {e}");
+    }
+}
+
+#[test]
+fn vector_points_take_the_requested_size() {
+    let mut s = Session::new();
+    let points = json!([[10, 20], [34, 20], [34, 32]]);
+    let corners = |s: &Session, id: NodeId| net(s, id).vertices.iter().map(|v| (v.x, v.y)).collect::<Vec<_>>();
+    // Both sides: each axis scales on its own; the vertices move with the box.
+    let both = id_of(&ex(&mut s, "vector.create", json!({"points": points, "x": 10, "y": 20, "width": 48, "height": 6}))["id"]).unwrap();
+    let n = s.doc().unwrap().node(both).unwrap();
+    assert_eq!((n.width, n.height), (48.0, 6.0));
+    assert_eq!(corners(&s, both), vec![(0.0, 0.0), (48.0, 0.0), (48.0, 6.0)]);
+    // One side: the other keeps its proportion.
+    let one = id_of(&ex(&mut s, "vector.create", json!({"points": points, "height": 24}))["id"]).unwrap();
+    let n = s.doc().unwrap().node(one).unwrap();
+    assert_eq!((n.width, n.height), (48.0, 24.0));
+    assert_eq!(corners(&s, one), vec![(0.0, 0.0), (48.0, 0.0), (48.0, 24.0)]);
+    let e = s.execute("vector.create", &json!({"points": points, "width": 16, "height": -1})).unwrap_err().to_string();
+    assert!(e.contains("positive"), "{e}");
+}
diff --git a/crates/engine/src/vector_fill_rule_tests.rs b/crates/engine/src/vector_fill_rule_tests.rs
new file mode 100644
index 000000000..8a8fe850d
--- /dev/null
+++ b/crates/engine/src/vector_fill_rule_tests.rs
@@ -0,0 +1,306 @@
+//! Fill rules on vectors: `vector.fillRule` sets the rule a filled area fills by and
+//! `vector.reverseLoop` turns one of its loops round — which is how a hole is made and unmade.
+//! The numbers come from the two rules' definitions: non-zero fills where the winding count is not
+//! zero (so a hole is a loop running against its outer loop), even-odd where it is odd (so the
+//! direction of a loop doesn't matter).
+
+use figcraft_doc::{NodeId, NodeKind, Region, Segment, VectorNetwork, Vertex, WindingRule};
+use figcraft_geom::{BezPath, Point};
+use serde_json::{Value, json};
+
+use crate::Session;
+
+fn ex(s: &mut Session, cmd: &str, p: Value) -> Value {
+    s.execute(cmd, &p).unwrap_or_else(|e| panic!("{cmd}: {e}"))
+}
+
+fn net(s: &Session, id: NodeId) -> VectorNetwork {
+    match &s.doc().unwrap().node(id).unwrap().kind {
+        NodeKind::Vector { network } => network.clone(),
+        other => panic!("not a vector: {other:?}"),
+    }
+}
+
+/// A 100 × 100 square with a 25…75 hole, both loops in one area: the outer one clockwise, the inner
+/// one the same way round (so non-zero fills the hole too until it is turned round).
+fn ring() -> VectorNetwork {
+    let mut path = BezPath::new();
+    for (x0, y0, x1, y1) in [(0.0, 0.0, 100.0, 100.0), (25.0, 25.0, 75.0, 75.0)] {
+        path.move_to((x0, y0));
+        path.line_to((x1, y0));
+        path.line_to((x1, y1));
+        path.line_to((x0, y1));
+        path.close_path();
+    }
+    let mut net = VectorNetwork::from_path(&path);
+    net.regions[0].winding = WindingRule::NonZero;
+    net
+}
+
+/// A selected vector layer holding `network`.
+fn vector_layer(s: &mut Session, network: VectorNetwork) -> NodeId {
+    let id = s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 100, "height": 100})).unwrap()["id"].as_u64().unwrap();
+    let id = NodeId(id);
+    ex(s, "vector.edit.begin", json!({"id": id}));
+    ex(s, "vector.edit.end", json!({}));
+    {
+        let doc = s.doc_mut().unwrap();
+        match &mut doc.get_mut(id).unwrap().kind {
+            NodeKind::Vector { network: net } => *net = network,
+            other => panic!("not a vector: {other:?}"),
+        }
+    }
+    ex(s, "select.set", json!({"ids": [id]}));
+    id
+}
+
+/// A selected vector layer holding `ring()`.
+fn ringed(s: &mut Session) -> NodeId {
+    vector_layer(s, ring())
+}
+
+/// Two 50 × 100 squares side by side share the vertical edge between them: one segment listed by
+/// both areas' single loops. A segment shared between areas is the case `vector.reverseLoop` must
+/// not flip, or a neighbour's fill or stroke would turn round with it.
+fn two_squares() -> VectorNetwork {
+    // 0:A(0,0) 1:B(50,0) 2:C(100,0) 3:D(100,100) 4:E(50,100) 5:F(0,100)
+    // s0 A→B (left bottom), s1 B→E (the shared vertical edge), s2 E→F (left top),
+    // s3 F→A (left left), s4 B→C (right bottom), s5 C→D (right right), s6 D→E (right top);
+    // the right area's left edge is s1 walked the other way, so the squares share one segment.
+    // region 0: left square A→B→E→F→A = [s0, s1, s2, s3].
+    // region 1: right square B→C→D→E→B = [s4, s5, s6, s1] (s1 walked backwards).
+    VectorNetwork {
+        vertices: vec![
+            Vertex::new(0.0, 0.0),
+            Vertex::new(50.0, 0.0),
+            Vertex::new(100.0, 0.0),
+            Vertex::new(100.0, 100.0),
+            Vertex::new(50.0, 100.0),
+            Vertex::new(0.0, 100.0),
+        ],
+        segments: vec![
+            Segment::line(0, 1),
+            Segment::line(1, 4),
+            Segment::line(4, 5),
+            Segment::line(5, 0),
+            Segment::line(1, 2),
+            Segment::line(2, 3),
+            Segment::line(3, 4),
+        ],
+        regions: vec![
+            Region { loops: vec![vec![0, 1, 2, 3]], winding: WindingRule::NonZero },
+            Region { loops: vec![vec![4, 5, 6, 1]], winding: WindingRule::NonZero },
+        ],
+    }
+}
+
+/// A selected vector layer holding [`two_squares`].
+fn squared(s: &mut Session) -> NodeId {
+    vector_layer(s, two_squares())
+}
+
+/// Two areas of two segments each over the same line: one curve above it and one below. Both areas
+/// list the line's segment — the first area first (`[line, above]`), the second area last
+/// (`[below, line]`) — and a two-segment ring reads the same whichever way its list is turned, so
+/// these only turn round when a segment is stored the other way.
+fn two_lenses() -> VectorNetwork {
+    // 0:A(0,0) 1:B(100,0)
+    // s0 A→B the straight line both areas use; s1 B→A curving above it; s2 A→B curving below it.
+    VectorNetwork {
+        vertices: vec![Vertex::new(0.0, 0.0), Vertex::new(100.0, 0.0)],
+        segments: vec![
+            Segment::line(0, 1),
+            Segment { a: 1, b: 0, ta: (0.0, -50.0), tb: (0.0, -50.0) },
+            Segment { a: 0, b: 1, ta: (0.0, 50.0), tb: (0.0, 50.0) },
+        ],
+        regions: vec![
+            Region { loops: vec![vec![0, 1]], winding: WindingRule::NonZero },
+            Region { loops: vec![vec![2, 0]], winding: WindingRule::NonZero },
+        ],
+    }
+}
+
+/// A selected vector layer holding [`two_lenses`].
+fn lensed(s: &mut Session) -> NodeId {
+    vector_layer(s, two_lenses())
+}
+
+/// Two areas whose only loop is the same closed segment (a curve the path closes with a straight
+/// line): a one-segment loop's direction is its segment's stored ends, and both areas read them.
+fn one_shared_segment() -> VectorNetwork {
+    VectorNetwork {
+        vertices: vec![Vertex::new(0.0, 0.0), Vertex::new(100.0, 0.0)],
+        segments: vec![Segment { a: 0, b: 1, ta: (0.0, -60.0), tb: (0.0, -60.0) }],
+        regions: vec![Region { loops: vec![vec![0]], winding: WindingRule::NonZero }, Region { loops: vec![vec![0]], winding: WindingRule::NonZero }],
+    }
+}
+
+/// The point in the middle of the hole, and one on the square's left band.
+const HOLE: Point = Point::new(50.0, 50.0);
+const BAND: Point = Point::new(10.0, 50.0);
+
+#[test]
+fn a_loop_running_with_its_outer_loop_fills_the_hole_until_it_is_turned_round() {
+    let mut s = Session::new();
+    let id = ringed(&mut s);
+    let n = net(&s, id);
+    assert_eq!(n.regions.len(), 1);
+    assert_eq!(n.regions[0].loops.len(), 2, "an outer loop and the hole's");
+    assert!(n.region_contains(0, BAND), "the band fills");
+    assert!(n.region_contains(0, HOLE), "the hole fills while its loop runs the same way");
+    // Turning the inner loop round makes it a hole under non-zero.
+    let r = ex(&mut s, "vector.reverseLoop", json!({"id": id, "region": 0, "loop": 1}));
+    assert_eq!(r["reversed"], json!(true));
+    let n = net(&s, id);
+    assert!(n.region_contains(0, BAND), "the band still fills");
+    assert!(!n.region_contains(0, HOLE), "the hole is empty");
+    assert_eq!(n.region_winding(0, HOLE), Some(0), "its loops cancel out there");
+    // Undo turns it back.
+    s.undo().unwrap();
+    assert!(net(&s, id).region_contains(0, HOLE), "one undo step restores the loop");
+}
+
+#[test]
+fn the_rule_switches_every_area_or_only_the_one_asked_for() {
+    let mut s = Session::new();
+    let id = ringed(&mut s);
+    // Even-odd leaves the hole empty whatever way its loop runs.
+    let r = ex(&mut s, "vector.fillRule", json!({"id": id, "rule": "evenOdd"}));
+    assert_eq!((r["regions"].clone(), r["rule"].clone()), (json!(1), json!("evenOdd")));
+    let n = net(&s, id);
+    assert_eq!(n.regions[0].winding, WindingRule::EvenOdd);
+    assert!(!n.region_contains(0, HOLE), "even-odd counts the hole's loop as a second crossing");
+    // And back.
+    ex(&mut s, "vector.fillRule", json!({"id": id, "rule": "nonZero"}));
+    assert!(net(&s, id).region_contains(0, HOLE), "non-zero fills it again");
+    // One area of several, by index.
+    let n = net(&s, id);
+    let mut two = n.clone();
+    two.regions.push(n.regions[0].clone());
+    {
+        let doc = s.doc_mut().unwrap();
+        match &mut doc.get_mut(id).unwrap().kind {
+            NodeKind::Vector { network } => *network = two,
+            other => panic!("not a vector: {other:?}"),
+        }
+    }
+    ex(&mut s, "vector.fillRule", json!({"id": id, "region": 1, "rule": "evenOdd"}));
+    let n = net(&s, id);
+    assert_eq!(n.regions[0].winding, WindingRule::NonZero, "the other area keeps its rule");
+    assert_eq!(n.regions[1].winding, WindingRule::EvenOdd);
+    // Every area at once.
+    ex(&mut s, "vector.fillRule", json!({"id": id, "rule": "evenOdd"}));
+    assert!(net(&s, id).regions.iter().all(|r| r.winding == WindingRule::EvenOdd));
+}
+
+#[test]
+fn junk_parameters_are_refused_and_change_nothing() {
+    let mut s = Session::new();
+    let id = ringed(&mut s);
+    let before = net(&s, id);
+    for p in [
+        json!({"id": id, "rule": "nope"}),
+        json!({"id": id}),
+        json!({"id": id, "rule": 7}),
+        json!({"id": id, "rule": "evenOdd", "region": -1}),
+        json!({"id": id, "rule": "evenOdd", "region": 1.5}),
+        json!({"id": id, "rule": "evenOdd", "region": "x"}),
+        json!({"id": id, "rule": "evenOdd", "region": 99}),
+    ] {
+        assert!(s.execute("vector.fillRule", &p).is_err(), "{p} is refused");
+    }
+    for p in [
+        json!({"id": id}),
+        json!({"id": id, "region": 0}),
+        json!({"id": id, "region": 0, "loop": 99}),
+        json!({"id": id, "region": 99, "loop": 0}),
+        json!({"id": id, "region": -2, "loop": 0}),
+    ] {
+        assert!(s.execute("vector.reverseLoop", &p).is_err(), "{p} is refused");
+    }
+    assert_eq!(net(&s, id), before, "nothing changed");
+    // A rectangle that was never a vector is refused too.
+    let rect = s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 10, "height": 10})).unwrap()["id"].as_u64().unwrap();
+    assert!(s.execute("vector.fillRule", &json!({"id": rect, "rule": "evenOdd"})).is_err());
+    assert!(s.execute("vector.reverseLoop", &json!({"id": rect, "region": 0, "loop": 0})).is_err());
+}
+
+#[test]
+fn reversing_a_loop_shared_with_a_neighbour_leaves_its_segment_and_fill_alone() {
+    let mut s = Session::new();
+    let id = squared(&mut s);
+    let n = net(&s, id);
+    assert_eq!(n.regions.len(), 2, "two areas, side by side");
+    // Both areas fill under non-zero: a point in each.
+    assert!(n.region_contains(0, Point::new(25.0, 50.0)), "the left area fills");
+    assert!(n.region_contains(1, Point::new(75.0, 50.0)), "the right area fills");
+    // The vertical edge between them is one segment listed by both areas' loops.
+    const SHARED: usize = 1;
+    assert!(n.regions[0].loops[0].contains(&SHARED) && n.regions[1].loops[0].contains(&SHARED), "one segment is shared");
+    let before = n.segments[SHARED];
+    let left_winding = n.region_winding(0, Point::new(25.0, 50.0)).unwrap();
+    assert_ne!(left_winding, 0, "the left area winds once");
+    // Reverse the left area's only loop.
+    let r = ex(&mut s, "vector.reverseLoop", json!({"id": id, "region": 0, "loop": 0}));
+    assert_eq!(r["reversed"], json!(true));
+    let n = net(&s, id);
+    // The shared segment's stored ends are untouched: reversing the loop must not flip a neighbour's
+    // segment (reversing the list already turns this loop's traversal of it the other way).
+    assert_eq!(n.segments[SHARED], before, "the shared segment is left as it was");
+    // The neighbour's fill is unchanged: it still fills its interior.
+    assert!(n.region_contains(1, Point::new(75.0, 50.0)), "the neighbour still fills");
+    // The reversed loop really turned round: its winding at a left-area point flipped sign.
+    assert_eq!(n.region_winding(0, Point::new(25.0, 50.0)), Some(-left_winding), "the left loop reversed");
+    // Undo restores the shared segment and the loop.
+    s.undo().unwrap();
+    assert_eq!(net(&s, id).segments[SHARED], before, "undo restores the shared segment too");
+}
+
+#[test]
+fn a_two_segment_loop_turns_round_with_its_shared_segment_listed_first_or_last() {
+    let mut s = Session::new();
+    let id = lensed(&mut s);
+    const SHARED: usize = 0;
+    const ABOVE: Point = Point::new(50.0, -25.0);
+    const BELOW: Point = Point::new(50.0, 25.0);
+    let n = net(&s, id);
+    assert_eq!(n.regions.len(), 2, "two areas over the same line");
+    assert_eq!((n.regions[0].loops[0][0], n.regions[0].loops[0].len()), (SHARED, 2), "the shared segment is listed first");
+    assert_eq!((n.regions[1].loops[0][1], n.regions[1].loops[0].len()), (SHARED, 2), "and last");
+    assert!(n.region_contains(0, ABOVE), "the area above the line fills");
+    assert!(n.region_contains(1, BELOW), "the area below it fills");
+    let (above, below) = (n.region_winding(0, ABOVE).unwrap(), n.region_winding(1, BELOW).unwrap());
+    assert_ne!(above, 0, "the area above winds once");
+    assert_ne!(below, 0, "the area below winds once");
+    let shared = n.segments[SHARED];
+    // Turn the area that lists the shared segment first round: a two-segment ring reads the same
+    // either way, so this only works by storing one of its segments the other way.
+    assert_eq!(ex(&mut s, "vector.reverseLoop", json!({"id": id, "region": 0, "loop": 0}))["reversed"], json!(true));
+    let n = net(&s, id);
+    assert_eq!(n.segments[SHARED], shared, "the shared segment keeps its ends");
+    assert!(n.region_contains(0, ABOVE), "the area still fills");
+    assert_eq!(n.region_winding(0, ABOVE), Some(-above), "it really turned round");
+    assert_eq!(n.region_winding(1, BELOW), Some(below), "the neighbour did not");
+    // And the area that lists it last.
+    ex(&mut s, "vector.reverseLoop", json!({"id": id, "region": 1, "loop": 0}));
+    let n = net(&s, id);
+    assert_eq!(n.segments[SHARED], shared, "still untouched");
+    assert_eq!(n.region_winding(1, BELOW), Some(-below), "the second area really turned round");
+    assert_eq!(n.region_winding(0, ABOVE), Some(-above), "the first stays as it was");
+    // Undo turns each back.
+    s.undo().unwrap();
+    assert_eq!(net(&s, id).region_winding(1, BELOW), Some(below), "undo turns the second back");
+    s.undo().unwrap();
+    assert_eq!(net(&s, id).region_winding(0, ABOVE), Some(above), "and the first");
+}
+
+#[test]
+fn a_one_segment_loop_shared_with_another_is_refused_instead_of_claiming_a_turn() {
+    let mut s = Session::new();
+    let id = vector_layer(&mut s, one_shared_segment());
+    let before = net(&s, id);
+    let err = s.execute("vector.reverseLoop", &json!({"id": id, "region": 0, "loop": 0})).unwrap_err();
+    let message = err.to_string();
+    assert!(message.contains("shares its segments"), "the error says why: {message}");
+    assert_eq!(net(&s, id), before, "nothing changed");
+}
diff --git a/crates/engine/src/vector_multi_behaviour_tests.rs b/crates/engine/src/vector_multi_behaviour_tests.rs
index 1d2075b1e..b1e6a948e 100644
--- a/crates/engine/src/vector_multi_behaviour_tests.rs
+++ b/crates/engine/src/vector_multi_behaviour_tests.rs
@@ -169,13 +169,19 @@ fn editing_several_vectors_at_once() {
     assert!(near(page_pos(&s, a, atl), (1.0, 0.0)) && near(page_pos(&s, b, btl), (201.0, 0.0)), "an arrow nudges the points in every layer");
     s.undo().unwrap();
     assert!(near(page_pos(&s, a, atl), (0.0, 0.0)) && near(page_pos(&s, b, btl), (200.0, 0.0)), "one undo step for every layer");
-    // Dragging one selected point drags them all.
-    let active = editing(&s).unwrap().id;
-    let grab = if active == a { (0.0, 0.0) } else { (200.0, 0.0) };
-    drag(&mut s, grab, (grab.0 + 10.0, grab.1 + 20.0), NONE);
-    assert!(near(page_pos(&s, a, atl), (10.0, 20.0)) && near(page_pos(&s, b, btl), (210.0, 20.0)), "dragging one selected point moves them all");
+    // Dragging one selected point drags them all (one on the transform box's edge: its corners
+    // scale, as with points of one layer).
+    let atr = point_at(&s, a, (100.0, 0.0));
+    ex(&mut s, "vector.edit.select", json!({"id": a, "vertices": [atr], "add": true}));
+    drag(&mut s, (100.0, 0.0), (110.0, 20.0), NONE);
+    assert!(
+        near(page_pos(&s, a, atl), (10.0, 20.0)) && near(page_pos(&s, a, atr), (110.0, 20.0)) && near(page_pos(&s, b, btl), (210.0, 20.0)),
+        "dragging one selected point moves them all"
+    );
     s.undo().unwrap();
     assert!(near(page_pos(&s, a, atl), (0.0, 0.0)) && near(page_pos(&s, b, btl), (200.0, 0.0)), "the drag is one undo step");
+    ex(&mut s, "vector.edit.select", json!({"vertices": [atl]}));
+    ex(&mut s, "vector.edit.select", json!({"id": b, "vertices": [btl], "add": true}));
     // Corner radius, mirroring and deleting reach every layer's selected points.
     ex(&mut s, "vector.edit.cornerRadius", json!({"radius": 10}));
     assert!(net(&s, a).vertices[atl].radius == 10.0 && net(&s, b).vertices[btl].radius == 10.0, "the corner radius applies to every layer");
diff --git a/crates/engine/src/vector_offset_tests.rs b/crates/engine/src/vector_offset_tests.rs
new file mode 100644
index 000000000..e47158f29
--- /dev/null
+++ b/crates/engine/src/vector_offset_tests.rs
@@ -0,0 +1,49 @@
+//! `vector.offset` on layers with children: containers are left alone.
+
+use serde_json::{Value, json};
+
+use crate::Session;
+use crate::params::id_of;
+use figcraft_doc::{NodeId, NodeKind};
+
+fn id(v: &Value) -> NodeId {
+    id_of(&v["id"]).unwrap()
+}
+
+/// No node that holds children may be a non-container.
+fn assert_children_only_in_containers(s: &Session, ids: &[NodeId]) {
+    let doc = s.doc().unwrap();
+    for &i in ids {
+        let n = doc.node(i).unwrap();
+        assert!(n.kind.is_container() || n.kind.is_frame_like() || n.children.is_empty(), "a non-container layer now holds children");
+    }
+}
+
+#[test]
+fn offset_path_leaves_containers_with_children_alone() {
+    let mut s = Session::new();
+    let f = id(&s.execute("frame.create", &json!({"x": 0, "y": 0, "width": 100, "height": 100})).unwrap());
+    let inner = id(&s.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 10, "height": 10, "parent": f})).unwrap());
+    let a = id(&s.execute("shape.rectangle", &json!({"x": 200, "y": 0, "width": 10, "height": 10})).unwrap());
+    let b = id(&s.execute("shape.rectangle", &json!({"x": 220, "y": 0, "width": 10, "height": 10})).unwrap());
+    let g = id(&s.execute("object.group", &json!({"ids": [a, b]})).unwrap());
+    for target in [f, g] {
+        s.execute("vector.offset", &json!({"ids": [target], "offset": 5})).unwrap();
+        assert_children_only_in_containers(&s, &[f, g, inner, a, b]);
+    }
+    let doc = s.doc().unwrap();
+    assert!(doc.node(f).unwrap().kind.is_container());
+    assert_eq!(doc.node(f).unwrap().children, vec![inner]);
+    assert!(doc.node(g).unwrap().kind.is_container());
+    assert_eq!(doc.node(g).unwrap().children.len(), 2);
+}
+
+#[test]
+fn offset_path_still_converts_a_plain_rectangle() {
+    let mut s = Session::new();
+    let r = id(&s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 10, "height": 10})).unwrap());
+    s.execute("vector.offset", &json!({"ids": [r], "offset": 5})).unwrap();
+    let n = s.doc().unwrap().node(r).unwrap().clone();
+    assert!(matches!(n.kind, NodeKind::Vector { .. }));
+    assert!(n.width > 10.0);
+}
diff --git a/crates/engine/src/vectoredit.rs b/crates/engine/src/vectoredit.rs
index f923de804..3b79dd4b4 100644
--- a/crates/engine/src/vectoredit.rs
+++ b/crates/engine/src/vectoredit.rs
@@ -4,7 +4,7 @@
 //! Entering edit mode on a non-vector shape converts it to a vector first (like the incumbent).
 //! Vertex coordinates are node-local; after each edit the node is re-fitted so its box wraps the
 //! network again. The network edits themselves live in [`ops`]; pointer gestures in `pointer.rs`,
-//! the transform box around several points in [`transform`], point snapping in `point_snap.rs` and
+//! the transform box around several points (in one layer or several) in [`transform`], point snapping in `point_snap.rs` and
 //! hovering, hatching and selecting filled regions in [`regions`].
 
 pub mod ops;
@@ -508,16 +508,15 @@ pub fn begin_many(s: &mut Session, ids: &[NodeId]) -> Result<()> {
     let before = s.ds()?.doc.clone();
     let mut edited = Vec::new();
     let mut first_err = None;
-    {
-        let doc = s.doc_mut()?;
-        for id in ids.iter().take(MAX_EDITED) {
-            if edited.contains(id) {
-                continue;
-            }
-            match ensure_vector(doc, *id) {
-                Ok(()) => edited.push(*id),
-                Err(e) => first_err = first_err.or(Some(e)),
-            }
+    for id in ids.iter().take(MAX_EDITED) {
+        if edited.contains(id) {
+            continue;
+        }
+        // Vectors are left untouched, so editing only them records no undo step.
+        let is_vector = before.node(*id).is_some_and(|n| matches!(n.kind, NodeKind::Vector { .. }));
+        match if is_vector { Ok(()) } else { ensure_vector(s.doc_mut()?, *id) } {
+            Ok(()) => edited.push(*id),
+            Err(e) => first_err = first_err.or(Some(e)),
         }
     }
     let Some((&id, rest)) = edited.split_first() else {
diff --git a/crates/engine/src/vectoredit/pointer.rs b/crates/engine/src/vectoredit/pointer.rs
index 388fe245e..ed13ed70a 100644
--- a/crates/engine/src/vectoredit/pointer.rs
+++ b/crates/engine/src/vectoredit/pointer.rs
@@ -262,7 +262,7 @@ impl Session {
     }
 
     /// Every edited layer's selected points (segment ends included) other than the active one's.
-    fn others_moving(doc: &Document, ve: &VectorEdit) -> Vec<(NodeId, Vec<usize>)> {
+    pub(super) fn others_moving(doc: &Document, ve: &VectorEdit) -> Vec<(NodeId, Vec<usize>)> {
         ve.others
             .iter()
             .filter_map(|o| {
@@ -310,7 +310,7 @@ impl Session {
         let Some(b) = transform::shown_box(&doc, ve) else { return Ok(()) };
         match bh {
             BoxHit::Inside => {
-                let g = self.points_gesture(ve.id, ev.p(), b.points, vec![], None, true)?;
+                let g = self.points_gesture(ve.id, ev.p(), b.points, b.others, None, true)?;
                 self.begin_interaction("Move points")?;
                 self.vgesture(g);
             }
@@ -320,7 +320,7 @@ impl Session {
                 self.vgesture(VGesture::BoxRotate { b, start_angle, angle: 0.0 });
             }
             BoxHit::Handle(handle) => {
-                let targets = Arc::new(point_snap::targets(&doc, page, Some(ve.id), &b.points, &[]));
+                let targets = Arc::new(point_snap::targets_moving(&doc, page, Some(ve.id), &b.points, &[], &b.others));
                 self.begin_interaction("Scale points")?;
                 self.vgesture(VGesture::BoxScale { b, handle, targets, pick });
             }
@@ -428,11 +428,11 @@ impl Session {
     }
 
     /// The region of the active layer a press at `ev` would take (Move tool, `h` the network's part
-    /// there). Inside the transform box around points selected in their own right, the box keeps
-    /// its drag unless the region is already selected.
+    /// there). Inside the transform box around points selected in their own right (in any edited
+    /// layer), the box keeps its drag unless the region is already selected.
     fn region_under(doc: &Document, ve: &VectorEdit, h: Option<VHit>, ev: &PointerEvent) -> Option<usize> {
         let r = region_hit(doc, ve, ev.p(), ev.zoom)?;
-        let own = !ve.shown_vertices().is_empty() || !ve.segments.is_empty();
+        let own = !ve.shown_vertices().is_empty() || !ve.segments.is_empty() || ve.others_selected();
         let in_box = !ev.shift && own && transform::box_hit(doc, ve, h, ev.p(), ev.zoom) == Some(BoxHit::Inside);
         (!in_box || ve.regions.contains(&r)).then_some(r)
     }
@@ -883,7 +883,7 @@ impl Session {
                 let q = b.frame.inverse() * (ev.p() + c);
                 let (x0, y0, x1, y1) = crate::tools::resized_box(handle, q, b.width, b.height, ev.shift, ev.alt);
                 let m = b.onto(x0, y0, x1, y1);
-                self.preview(|doc, _| transform::transform_points(doc, id, &b.points, m))?;
+                self.preview(|doc, _| transform::transform_box(doc, id, &b, m))?;
             }
             VGesture::BoxRotate { b, start_angle, .. } => {
                 let c = b.center();
@@ -892,7 +892,7 @@ impl Session {
                     angle = (angle / 15.0).round() * 15.0;
                 }
                 let m = figcraft_geom::rotate_about(Affine::IDENTITY, c, -angle);
-                self.preview(|doc, _| transform::transform_points(doc, id, &b.points, m))?;
+                self.preview(|doc, _| transform::transform_box(doc, id, &b, m))?;
                 self.tool.overlay.cursor = Cursor::Rotate((ev.p() - c).atan2().to_degrees());
                 self.vgesture(VGesture::BoxRotate { b, start_angle, angle });
             }
@@ -996,8 +996,13 @@ impl Session {
         self.tool.overlay.guides.clear();
         let Gesture::Vector(g) = g else { return Ok(()) };
         match g {
-            VGesture::Points { moved, split, click_clears, .. } => {
+            VGesture::Points { verts, others, moved, split, click_clears, .. } => {
                 if moved || split.is_some() {
+                    if let ([v], None) = (verts.as_slice(), split)
+                        && others.iter().all(|(_, o)| o.is_empty())
+                    {
+                        self.merge_dropped_point(ve.id, *v, 6.0 / ev.zoom.max(1e-6))?;
+                    }
                     self.commit_interaction()?;
                 } else {
                     self.cancel_interaction()?;
@@ -1005,6 +1010,10 @@ impl Session {
                         set_state(self, |e| {
                             e.vertices.clear();
                             e.segments.clear();
+                            for o in &mut e.others {
+                                o.vertices.clear();
+                                o.segments.clear();
+                            }
                         })?;
                     }
                 }
@@ -1057,4 +1066,40 @@ impl Session {
         }
         Ok(())
     }
+
+    /// Point `v` of vector `id`, dragged and dropped within `tol` (page units) of another of its
+    /// points, merges into that point (in the same undo step as the move), which stays selected.
+    fn merge_dropped_point(&mut self, id: NodeId, v: usize, tol: f64) -> Result<()> {
+        let moved = self.ds()?.doc.get(id)?.clone();
+        let w = self.ds()?.doc.world_transform(id);
+        let NodeKind::Vector { network: net } = &moved.kind else { return Ok(()) };
+        let Some(p) = net.vertices.get(v).map(|x| w * x.point()) else { return Ok(()) };
+        let Some(keep) = net
+            .vertices
+            .iter()
+            .enumerate()
+            .filter(|(i, _)| *i != v)
+            .map(|(i, x)| (i, (w * x.point() - p).hypot()))
+            .filter(|(_, d)| *d <= tol)
+            .min_by(|a, b| a.1.total_cmp(&b.1))
+            .map(|(i, _)| i)
+        else {
+            return Ok(());
+        };
+        let mut merged = net.clone();
+        ops::merge_vertices(&mut merged, keep, v);
+        // A merge that would leave no segment (a 2-point line's ends dropped together) only moves.
+        if merged.segments.is_empty() {
+            return Ok(());
+        }
+        // The preview starts again from the document before the drag: bring the moved layer.
+        self.preview(|doc, _| {
+            *doc.get_mut(id)? = moved;
+            edit(doc, id, |net| *net = merged)
+        })?;
+        set_state(self, |e| {
+            e.vertices = vec![if keep > v { keep - 1 } else { keep }];
+            e.segments.clear();
+        })
+    }
 }
diff --git a/crates/engine/src/vectoredit/tests.rs b/crates/engine/src/vectoredit/tests.rs
index ae7ac27ec..0eba28e3d 100644
--- a/crates/engine/src/vectoredit/tests.rs
+++ b/crates/engine/src/vectoredit/tests.rs
@@ -280,6 +280,36 @@ fn mirroring_position_and_join_commands() {
     assert!(s.execute("vector.join", &json!({"ids": [id]})).is_ok());
 }
 
+#[test]
+fn a_point_dropped_on_another_merges_into_it() {
+    // #401: an open path's end dragged onto its start closes the path at that point.
+    let mut s = Session::new();
+    let r = ex(&mut s, "vector.create", json!({"points": [[0, 0], [100, 0], [100, 100], [0, 100]]}));
+    let id = crate::params::id_of(&r["id"]).unwrap();
+    ex(&mut s, "vector.edit.begin", json!({"id": id}));
+    drag(&mut s, (0.0, 100.0), (2.0, 3.0));
+    let n = net(&s, id);
+    assert_eq!(n.vertices.len(), 3, "the dropped point merged");
+    assert!((0..3).all(|v| n.incident(v).len() == 2), "a closed path: {n:?}");
+    assert_eq!(ve(&s).vertices, vec![vertex_at(&n, 0.0, 0.0)], "the point it merged into stays selected");
+    s.undo().unwrap();
+    let n = net(&s, id);
+    assert_eq!(n.vertices.len(), 4, "one undo step takes back the move and the merge");
+    vertex_at(&n, 0.0, 100.0);
+    // A drop away from every point only moves it.
+    ex(&mut s, "vector.edit.select", json!({"vertices": []}));
+    drag(&mut s, (0.0, 100.0), (0.0, 50.0));
+    assert_eq!(net(&s, id).vertices.len(), 4);
+    // A 2-point line's end dropped on its other end only moves: no segment would be left.
+    let mut s = Session::new();
+    let r = ex(&mut s, "vector.create", json!({"points": [[0, 0], [100, 0]]}));
+    let id = crate::params::id_of(&r["id"]).unwrap();
+    ex(&mut s, "vector.edit.begin", json!({"id": id}));
+    drag(&mut s, (100.0, 0.0), (2.0, 0.0));
+    let n = net(&s, id);
+    assert_eq!((n.vertices.len(), n.segments.len()), (2, 1), "still a line: {n:?}");
+}
+
 #[test]
 fn undo_back_past_the_conversion_leaves_edit_mode() {
     let mut s = Session::new();
diff --git a/crates/engine/src/vectoredit/transform.rs b/crates/engine/src/vectoredit/transform.rs
index 1d5f27a6a..ca6e59e23 100644
--- a/crates/engine/src/vectoredit/transform.rs
+++ b/crates/engine/src/vectoredit/transform.rs
@@ -1,11 +1,11 @@
 //! The transform box of vector edit mode. With two or more points selected (Move tool) a box in the
-//! vector's own axes wraps them: its corners and edges scale them (Shift keeps proportions, Alt
-//! scales from the centre), dragging just outside a corner rotates them about its centre (Shift:
-//! 15° steps) and dragging inside it moves them; each drag is one undo step (the gestures live in
-//! `pointer.rs`). Commands make the same edits for the Design panel, the control channel and MCP,
+//! vector's own axes wraps them (in the page's axes when they are in several layers): its corners
+//! and edges scale them (Shift keeps proportions, Alt scales from the centre), dragging just
+//! outside a corner rotates them about its centre (Shift: 15° steps) and dragging inside it moves
+//! them; each drag is one undo step for every layer (the gestures live in `pointer.rs`). Commands make the same edits for the Design panel, the control channel and MCP,
 //! and while points are selected the flip and 90°/180° rotation commands act on them.
 
-use figcraft_doc::Document;
+use figcraft_doc::{Document, NodeId};
 use figcraft_geom::{Affine, Point};
 use serde_json::{Value, json};
 
@@ -19,16 +19,23 @@ use crate::{Result, Session, bad, spec};
 const EPS: f64 = 1e-9;
 
 /// The selected points' box: the page transform of its top-left corner (axes along the vector's
-/// own), its size in those axes and the points in it.
+/// own), its size in those axes and the points in it: the active layer's, and other edited
+/// layers' in `others`.
 #[derive(Clone, Debug, PartialEq)]
 pub struct PointBox {
     pub frame: Affine,
     pub width: f64,
     pub height: f64,
     pub points: Vec<usize>,
+    pub others: Vec<(NodeId, Vec<usize>)>,
 }
 
 impl PointBox {
+    /// How many points the box wraps, in every layer.
+    pub fn point_count(&self) -> usize {
+        self.points.len() + self.others.iter().map(|(_, v)| v.len()).sum::<usize>()
+    }
+
     /// Corners in page coordinates (tl, tr, br, bl).
     pub fn corners(&self) -> [Point; 4] {
         let (f, w, h) = (self.frame, self.width, self.height);
@@ -62,17 +69,37 @@ pub fn point_box(doc: &Document, ve: &VectorEdit) -> Option<PointBox> {
     if !(x0.is_finite() && y0.is_finite() && width.is_finite() && height.is_finite()) {
         return None;
     }
-    Some(PointBox { frame: doc.world_transform(ve.id) * Affine::translate((x0, y0)), width, height, points })
+    Some(PointBox { frame: doc.world_transform(ve.id) * Affine::translate((x0, y0)), width, height, points, others: vec![] })
+}
+
+/// The box of the selected points of every edited layer, in the page's axes (the layers' own may
+/// differ).
+fn layers_box(doc: &Document, ve: &VectorEdit) -> Option<PointBox> {
+    let points = selected_points(network(doc, ve.id)?, ve);
+    let others = Session::others_moving(doc, ve);
+    let page = |id: NodeId, verts: &[usize]| -> Vec<Point> {
+        let w = doc.world_transform(id);
+        network(doc, id).map(|n| verts.iter().filter_map(|v| n.vertices.get(*v)).map(|v| w * v.point()).collect()).unwrap_or_default()
+    };
+    let all = page(ve.id, &points).into_iter().chain(others.iter().flat_map(|(id, v)| page(*id, v)));
+    let (x0, y0, x1, y1) = all.fold((f64::INFINITY, f64::INFINITY, f64::NEG_INFINITY, f64::NEG_INFINITY), |(a, b, c, d), p| {
+        (a.min(p.x), b.min(p.y), c.max(p.x), d.max(p.y))
+    });
+    let (width, height) = (x1 - x0, y1 - y0);
+    if !(x0.is_finite() && y0.is_finite() && width.is_finite() && height.is_finite()) {
+        return None;
+    }
+    Some(PointBox { frame: Affine::translate((x0, y0)), width, height, points, others })
 }
 
 /// The box drawn and dragged on the canvas: the Move tool, no open pen path, and two or more
-/// points that aren't all in one place, all in the active layer.
-/// shortcut: with points selected in several layers there is no box (drags, nudges and the Design panel still reach them all); wrap them all if asked for.
+/// points that aren't all in one place, in any of the edited layers.
 pub fn shown_box(doc: &Document, ve: &VectorEdit) -> Option<PointBox> {
-    if ve.tool != VTool::Move || ve.anchor.is_some() || ve.others_selected() {
+    if ve.tool != VTool::Move || ve.anchor.is_some() {
         return None;
     }
-    point_box(doc, ve).filter(|b| b.points.len() >= 2 && (b.width > EPS || b.height > EPS))
+    let b = if ve.others_selected() { layers_box(doc, ve) } else { point_box(doc, ve) };
+    b.filter(|b| b.point_count() >= 2 && (b.width > EPS || b.height > EPS))
 }
 
 /// What the transform box does under the pointer.
@@ -115,12 +142,21 @@ pub fn box_hit(doc: &Document, ve: &VectorEdit, h: Option<VHit>, p: Point, zoom:
 
 /// Map points `verts` of vector `id` (and the handles at them) through page transform `m`, then
 /// re-fit the vector.
-pub fn transform_points(doc: &mut Document, id: figcraft_doc::NodeId, verts: &[usize], m: Affine) -> Result<()> {
+pub fn transform_points(doc: &mut Document, id: NodeId, verts: &[usize], m: Affine) -> Result<()> {
     let w = doc.world_transform(id);
     let local = w.inverse() * m * w;
     edit(doc, id, |net| ops::transform_vertices(net, verts, local))
 }
 
+/// Map the points of box `b` (`id`: the active layer) in every layer through page transform `m`.
+pub fn transform_box(doc: &mut Document, id: NodeId, b: &PointBox, m: Affine) -> Result<()> {
+    transform_points(doc, id, &b.points, m)?;
+    for (o, verts) in &b.others {
+        transform_points(doc, *o, verts, m)?;
+    }
+    Ok(())
+}
+
 /// Transform the selected points by `f(box)` (page space) when editing with points selected and
 /// the command names no layers (`p` has no `ids` or `id`); `None` otherwise (it then acts on
 /// layers).
diff --git a/crates/engine/src/vectoredit/transform_tests.rs b/crates/engine/src/vectoredit/transform_tests.rs
index d69baf52f..f29ed2a54 100644
--- a/crates/engine/src/vectoredit/transform_tests.rs
+++ b/crates/engine/src/vectoredit/transform_tests.rs
@@ -307,3 +307,122 @@ fn edit_mode_transform_commands_survive_junk() {
         }
     }
 }
+
+/// Two edited layers turned differently: `a` a 100×100 square at the origin turned -20°, `b` one
+/// at (200, 0) turned 30° (the active layer), with two of `a`'s corners and all of `b`'s points
+/// selected. Neither layer's axes are the page's. Snapping (the pixel grid too) is off so drags
+/// land exactly.
+fn two_layers(s: &mut Session) -> (NodeId, NodeId) {
+    let mut square = |x: f64| crate::params::id_of(&ex(s, "shape.rectangle", json!({"x": x, "y": 0, "width": 100, "height": 100}))["id"]).unwrap();
+    let (a, b) = (square(0.0), square(200.0));
+    ex(s, "node.set", json!({"id": a, "props": {"rotation": -20}}));
+    ex(s, "node.set", json!({"id": b, "props": {"rotation": 30}}));
+    ex(s, "view.snapGeometry", json!({"on": false}));
+    ex(s, "view.snapObjects", json!({"on": false}));
+    ex(s, "view.snapPixel", json!({"on": false}));
+    ex(s, "vector.edit.begin", json!({"ids": [a, b]}));
+    let n = net(s, a);
+    ex(s, "vector.edit.select", json!({"vertices": [vertex_at(&n, 0.0, 0.0), vertex_at(&n, 100.0, 100.0)]}));
+    ex(s, "vector.edit.select", json!({"id": b, "vertices": [0, 1, 2, 3], "add": true}));
+    assert_eq!(ve(s).id, b, "the layer named last is the active one");
+    (a, b)
+}
+
+/// Every selected point's page position, layer by layer.
+fn selected_page_points(s: &Session, a: NodeId, b: NodeId) -> Vec<(NodeId, usize, Point)> {
+    let e = ve(s);
+    let parts = e.parts();
+    [a, b]
+        .iter()
+        .flat_map(|id| {
+            let part = parts.iter().find(|p| p.id == *id).unwrap();
+            part.vertices.iter().map(|v| (*id, *v, page_pt(s, *id, *v))).collect::<Vec<_>>()
+        })
+        .collect()
+}
+
+#[test]
+fn the_box_wraps_points_selected_in_several_layers() {
+    let mut s = Session::new();
+    let (a, b) = two_layers(&mut s);
+    let before = selected_page_points(&s, a, b);
+    assert_eq!(before.len(), 6);
+    // On the page's axes: `b` is turned, so neither layer's own axes fit both.
+    let (x0, y0) = before.iter().fold((f64::INFINITY, f64::INFINITY), |(x, y), (_, _, p)| (x.min(p.x), y.min(p.y)));
+    let (x1, y1) = before.iter().fold((f64::NEG_INFINITY, f64::NEG_INFINITY), |(x, y), (_, _, p)| (x.max(p.x), y.max(p.y)));
+    let c = s.vector_edit_box().expect("a box around the points of both layers");
+    assert!(near(c[0], pt(x0, y0)) && near(c[2], pt(x1, y1)), "{c:?} vs ({x0}, {y0})–({x1}, {y1})");
+
+    // The bottom-right corner dragged to twice the width scales every point in both layers.
+    drag(&mut s, (x1, y1), (x0 + 2.0 * (x1 - x0), y1));
+    for (id, v, p) in &before {
+        let q = page_pt(&s, *id, *v);
+        assert!(near(q, pt(x0 + 2.0 * (p.x - x0), p.y)), "point {v} of {id:?}: {p:?} → {q:?}");
+    }
+    s.undo().unwrap();
+    for (id, v, p) in &before {
+        assert!(near(page_pt(&s, *id, *v), *p), "one undo step brings back point {v} of {id:?}");
+    }
+
+    // From just outside the top-right corner, a quarter turn clockwise about the box's centre.
+    let ctr = pt((x0 + x1) / 2.0, (y0 + y1) / 2.0);
+    let from = pt(x1 + 10.0, y0 - 10.0);
+    let d = from - ctr;
+    drag(&mut s, (from.x, from.y), (ctr.x - d.y, ctr.y + d.x));
+    for (id, v, p) in &before {
+        let r = *p - ctr;
+        let q = page_pt(&s, *id, *v);
+        assert!(near(q, pt(ctr.x - r.y, ctr.y + r.x)), "point {v} of {id:?}: {p:?} → {q:?}");
+    }
+    s.undo().unwrap();
+    for (id, v, p) in &before {
+        assert!(near(page_pt(&s, *id, *v), *p), "one undo step brings back point {v} of {id:?}");
+    }
+}
+
+#[test]
+fn inside_the_box_of_several_layers_drags_and_a_click_clears_them_all() {
+    let mut s = Session::new();
+    let (a, b) = two_layers(&mut s);
+    let before = selected_page_points(&s, a, b);
+    // Clear of both networks: between the two squares, inside the box.
+    let doc = s.doc().unwrap().clone();
+    assert!(hit_any(&doc, &ve(&s), pt(150.0, 50.0), 6.0).is_none());
+    assert_eq!(box_hit(&doc, &ve(&s), None, pt(150.0, 50.0), 1.0), Some(BoxHit::Inside));
+    drag(&mut s, (150.0, 50.0), (170.0, 60.0));
+    for (id, v, p) in &before {
+        assert!(near(page_pt(&s, *id, *v), *p + Vec2::new(20.0, 10.0)), "point {v} of {id:?} moves along");
+    }
+    s.undo().unwrap();
+    click(&mut s, 150.0, 50.0);
+    assert!(ve(&s).parts().iter().all(|p| p.vertices.is_empty()), "a click inside clears every layer's points");
+}
+
+#[test]
+fn inside_the_box_of_another_layer_drags_over_a_region_of_the_active_one() {
+    // `b`'s points selected, `a` (a filled 300 square around `b`) active with nothing selected:
+    // the press at the box's centre lands on `a`'s region too.
+    let mut s = Session::new();
+    let mut square = |x: f64, size: f64| {
+        crate::params::id_of(&ex(&mut s, "shape.rectangle", json!({"x": x, "y": x, "width": size, "height": size}))["id"]).unwrap()
+    };
+    let (a, b) = (square(0.0, 300.0), square(100.0, 50.0));
+    ex(&mut s, "view.snapGeometry", json!({"on": false}));
+    ex(&mut s, "view.snapObjects", json!({"on": false}));
+    ex(&mut s, "view.snapPixel", json!({"on": false}));
+    ex(&mut s, "vector.edit.begin", json!({"ids": [a, b]}));
+    ex(&mut s, "vector.edit.select", json!({"id": b, "vertices": [0, 1, 2, 3]}));
+    ex(&mut s, "vector.edit.select", json!({"id": a, "add": true}));
+    let doc = s.doc().unwrap().clone();
+    let e = ve(&s);
+    assert!(e.id == a && e.vertices.is_empty() && e.others_selected());
+    assert!(hit_any(&doc, &e, pt(125.0, 125.0), 6.0).is_none());
+    assert!(regions::region_hit(&doc, &e, pt(125.0, 125.0), 1.0).is_some(), "a region of the active layer under the press");
+    assert_eq!(box_hit(&doc, &e, None, pt(125.0, 125.0), 1.0), Some(BoxHit::Inside));
+    let before: Vec<Point> = (0..4).map(|v| page_pt(&s, b, v)).collect();
+    drag(&mut s, (125.0, 125.0), (145.0, 135.0));
+    assert!(ve(&s).regions.is_empty(), "the region isn't selected");
+    for (v, p) in before.iter().enumerate() {
+        assert!(near(page_pt(&s, b, v), *p + Vec2::new(20.0, 10.0)), "point {v} of b moves along");
+    }
+}
diff --git a/crates/engine/src/view_behaviour_tests.rs b/crates/engine/src/view_behaviour_tests.rs
index 27bc37710..7f9e5a844 100644
--- a/crates/engine/src/view_behaviour_tests.rs
+++ b/crates/engine/src/view_behaviour_tests.rs
@@ -742,3 +742,32 @@ fn alt_measures_between_layers() {
         assert_eq!(measured(&mut s, p, m), want, "{why}");
     }
 }
+
+#[test]
+fn view_toggles_are_kept_for_the_next_launch() {
+    let mut s = Session::new();
+    // (command, turned to, ViewState field, derivation)
+    let rows: Vec<(&str, bool, fn(&ViewState) -> bool, &str)> = vec![
+        ("view.rulers", true, |v| v.rulers, "rulers shown stay shown"),
+        ("view.pixelGrid", false, |v| v.pixel_grid, "a hidden pixel grid stays hidden"),
+        ("view.layoutGrids", false, |v| v.layout_grids, "hidden layout grids stay hidden"),
+        ("view.snapPixel", false, |v| v.snap_pixel, "snapping to the pixel grid off stays off"),
+    ];
+    for (cmd, on, _, _) in &rows {
+        ex(&mut s, cmd, json!({"on": on}));
+    }
+    // Modes stay with their file: a new one never opens in outline mode or soft-proofing.
+    for cmd in ["view.outlines", "view.outlinesSelection", "view.proofSrgb"] {
+        ex(&mut s, cmd, json!({"on": true}));
+    }
+    // The app writes its preferences as JSON and reads them back at the next launch.
+    let saved = serde_json::to_value(&s.prefs).unwrap();
+    let mut next = Session::empty();
+    next.prefs = serde_json::from_value(saved).unwrap();
+    ex(&mut next, "file.new", json!({}));
+    let view = &next.ds().unwrap().view;
+    for (cmd, on, get, why) in rows {
+        assert_eq!(get(view), on, "{cmd}: {why}");
+    }
+    assert!(!view.outlines && !view.outlines_selection && !view.proof_srgb, "{view:?}");
+}
diff --git a/crates/engine/src/widgets_tests.rs b/crates/engine/src/widgets_tests.rs
index 7079905ff..f228d35cc 100644
--- a/crates/engine/src/widgets_tests.rs
+++ b/crates/engine/src/widgets_tests.rs
@@ -248,6 +248,19 @@ fn clicking_a_widget_on_the_canvas_calls_its_plugin_back() {
     assert!(after.x - before.x > 30.0 && state(&mut s, w) == json!({"n": 2}), "{before:?} → {after:?}");
 }
 
+#[test]
+fn a_shift_click_on_a_selected_widget_only_deselects_it() {
+    let mut s = session();
+    let (w, _) = insert(&mut s);
+    let target = s.doc().unwrap().world_bounds(node(&s, w).children[1]).unwrap().center();
+    let mut down = PointerEvent::at(PointerKind::Down, target.x, target.y, 1.0);
+    down.shift = true;
+    // Shift let go before the button: still a Shift-click, not a click on the widget.
+    s.pointer(&down).unwrap();
+    s.pointer(&PointerEvent::at(PointerKind::Up, target.x, target.y, 1.0)).unwrap();
+    assert_eq!((s.selection(), state(&mut s, w)), (vec![], json!({"n": 1})));
+}
+
 #[test]
 fn bad_widgets_and_clicks_are_refused_and_roll_back() {
     let mut s = session();
diff --git a/crates/engine/tests/empty_text_box_undo.rs b/crates/engine/tests/it/empty_text_box_undo.rs
similarity index 96%
rename from crates/engine/tests/empty_text_box_undo.rs
rename to crates/engine/tests/it/empty_text_box_undo.rs
index ec73b83aa..0a302ac2b 100644
--- a/crates/engine/tests/empty_text_box_undo.rs
+++ b/crates/engine/tests/it/empty_text_box_undo.rs
@@ -1,5 +1,3 @@
-#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
-
 use figcraft_engine::{
     Session,
     doc::NodeKind,
diff --git a/crates/engine/tests/library_style_acceptance.rs b/crates/engine/tests/it/library_style_acceptance.rs
similarity index 98%
rename from crates/engine/tests/library_style_acceptance.rs
rename to crates/engine/tests/it/library_style_acceptance.rs
index 8398fc720..079401320 100644
--- a/crates/engine/tests/library_style_acceptance.rs
+++ b/crates/engine/tests/it/library_style_acceptance.rs
@@ -1,5 +1,4 @@
 //! Accepting a library update that changes only a paint style refreshes the layers linked to it.
-#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
 
 use figcraft_doc::{NodeId, StyleKind};
 use figcraft_engine::Session;
diff --git a/crates/engine/tests/list_indent_response.rs b/crates/engine/tests/it/list_indent_response.rs
similarity index 97%
rename from crates/engine/tests/list_indent_response.rs
rename to crates/engine/tests/it/list_indent_response.rs
index 1dae87546..e6d479569 100644
--- a/crates/engine/tests/list_indent_response.rs
+++ b/crates/engine/tests/it/list_indent_response.rs
@@ -1,5 +1,4 @@
 //! `text.listIndent` / `text.listOutdent` report `changed` only when the document changed.
-#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
 
 use figcraft_engine::{
     Session,
diff --git a/crates/engine/tests/it/main.rs b/crates/engine/tests/it/main.rs
new file mode 100644
index 000000000..a97e34343
--- /dev/null
+++ b/crates/engine/tests/it/main.rs
@@ -0,0 +1,14 @@
+//! The crate's integration tests, built as one test binary.
+
+#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+mod empty_text_box_undo;
+#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::disallowed_methods)]
+mod library_style_acceptance;
+#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+mod list_indent_response;
+#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+mod scope_reset;
+#[allow(clippy::unwrap_used)]
+mod selection_colors;
+#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+mod shape_builder_response;
diff --git a/crates/engine/tests/scope_reset.rs b/crates/engine/tests/it/scope_reset.rs
similarity index 95%
rename from crates/engine/tests/scope_reset.rs
rename to crates/engine/tests/it/scope_reset.rs
index 6d875d124..1838e8a95 100644
--- a/crates/engine/tests/scope_reset.rs
+++ b/crates/engine/tests/it/scope_reset.rs
@@ -1,5 +1,3 @@
-#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
-
 use figcraft_engine::Session;
 use serde_json::json;
 
diff --git a/crates/engine/tests/it/selection_colors.rs b/crates/engine/tests/it/selection_colors.rs
new file mode 100644
index 000000000..4e559d278
--- /dev/null
+++ b/crates/engine/tests/it/selection_colors.rs
@@ -0,0 +1,272 @@
+use figcraft_color::Paint;
+use figcraft_doc::NodeId;
+use figcraft_engine::{
+    Session,
+    selection_colors::{SelectionColor, collect},
+};
+use serde_json::{Value, json};
+
+fn run(s: &mut Session, cmd: &str, p: Value) -> Value {
+    s.execute(cmd, &p).unwrap()
+}
+fn rectangle(s: &mut Session, color: &str) -> NodeId {
+    NodeId(run(s, "shape.rectangle", json!({"width":40,"height":40,"props":{"fill":color}}))["id"].as_u64().unwrap())
+}
+fn group(s: &Session, ids: &[NodeId], hex: &str) -> SelectionColor {
+    collect(s.doc().unwrap(), ids).into_iter().find(|g| g.paint.solid_color().is_some_and(|c| c.to_hex() == hex)).unwrap()
+}
+fn fill(s: &Session, id: NodeId) -> String {
+    s.doc().unwrap().node(id).unwrap().fills[0].solid_color().unwrap().to_hex()
+}
+
+#[test]
+fn aggregate_descendants_deduplicate_roots_and_ignore_images_and_hidden_paints() {
+    let mut s = Session::new();
+    let a = rectangle(&mut s, "#ff0000");
+    let b = rectangle(&mut s, "#00ff00");
+    run(&mut s, "stroke.add", json!({"id":b,"color":"#ff0000"}));
+    let parent = NodeId(run(&mut s, "object.group", json!({"ids":[a,b]}))["id"].as_u64().unwrap());
+    let colors = collect(s.doc().unwrap(), &[parent, a]);
+    assert_eq!(colors.len(), 2);
+    assert_eq!(group(&s, &[parent, a], "FF0000").targets.len(), 2);
+    run(&mut s, "fill.add", json!({"id":a,"paint":Paint::image("synthetic",figcraft_color::ImageScaleMode::Fill)}));
+    run(&mut s, "fill.add", json!({"id":a,"paint":{"type":"solid","color":"#0000ff","visible":false}}));
+    assert_eq!(collect(s.doc().unwrap(), &[parent]).len(), 2);
+    run(&mut s, "select.set", json!({"ids":[parent]}));
+    assert_eq!(run(&mut s, "selection.colors", json!({}))["colors"].as_array().unwrap().len(), 2);
+}
+
+#[test]
+fn editing_only_matching_slots_is_one_undo_step_and_keeps_selection() {
+    let mut s = Session::new();
+    let a = rectangle(&mut s, "#ff0000");
+    let b = rectangle(&mut s, "#0000ff");
+    let c = rectangle(&mut s, "#00ff00");
+    run(&mut s, "stroke.add", json!({"id":b,"color":"#ff0000"}));
+    run(&mut s, "select.set", json!({"ids":[a,b]}));
+    let red = group(&s, &[a, b], "FF0000");
+    let before = s.undo_depth();
+    run(&mut s, "selection.setPaint", json!({"targets":red.targets,"paint":"#ffff00"}));
+    assert_eq!(fill(&s, a), "FFFF00");
+    assert_eq!(fill(&s, b), "0000FF");
+    assert_eq!(fill(&s, c), "00FF00");
+    assert_eq!(s.doc().unwrap().node(b).unwrap().strokes[0].solid_color().unwrap().to_hex(), "FFFF00");
+    assert_eq!(s.selection(), vec![a, b]);
+    assert_eq!(s.undo_depth().0, before.0 + 1);
+    s.undo().unwrap();
+    assert_eq!(fill(&s, a), "FF0000");
+    s.redo().unwrap();
+    assert_eq!(fill(&s, a), "FFFF00");
+}
+
+#[test]
+fn live_picker_targets_do_not_expand_when_colors_merge() {
+    let mut s = Session::new();
+    let a = rectangle(&mut s, "#ff0000");
+    let b = rectangle(&mut s, "#0000ff");
+    let red = group(&s, &[a, b], "FF0000");
+    let before = s.undo_depth();
+    s.begin_interaction("Color").unwrap();
+    for hex in ["#0000ff", "#00ff00"] {
+        run(&mut s, "selection.setPaint", json!({"targets":red.targets,"paint":hex}));
+    }
+    s.commit_interaction().unwrap();
+    assert_eq!(fill(&s, a), "00FF00");
+    assert_eq!(fill(&s, b), "0000FF");
+    assert_eq!(s.undo_depth().0, before.0 + 1);
+    s.undo().unwrap();
+    assert_eq!(fill(&s, a), "FF0000");
+}
+
+#[test]
+fn text_range_colors_use_character_offsets_and_preserve_typography() {
+    let mut s = Session::new();
+    let id = NodeId(run(&mut s, "text.create", json!({"text":"Яab","props":{"fill":"#ff0000"}}))["id"].as_u64().unwrap());
+    run(&mut s, "text.style", json!({"id":id,"start":1,"end":2,"fontSize":30,"textFills":["#0000ff"]}));
+    let blue = group(&s, &[id], "0000FF");
+    assert_eq!(blue.targets[0].range, Some((1, 2)));
+    run(&mut s, "selection.setPaint", json!({"targets":blue.targets,"paint":"#00ff00"}));
+    let n = s.doc().unwrap().node(id).unwrap();
+    let t = n.kind.text().unwrap();
+    assert_eq!(t.characters, "Яab");
+    assert_eq!(t.style_at(1).font_size, 30.0);
+    assert_eq!(t.style_at(1).fills.as_ref().unwrap()[0].solid_color().unwrap().to_hex(), "00FF00");
+    assert_eq!(t.style_at(0).fills.as_deref().unwrap_or(&n.fills)[0].solid_color().unwrap().to_hex(), "FF0000");
+    assert_eq!(t.style_at(2).fills.as_deref().unwrap_or(&n.fills)[0].solid_color().unwrap().to_hex(), "FF0000");
+}
+
+#[test]
+fn selecting_color_selects_its_unique_owners_without_document_history() {
+    let mut s = Session::new();
+    let a = rectangle(&mut s, "#ff0000");
+    let b = rectangle(&mut s, "#0000ff");
+    run(&mut s, "stroke.add", json!({"id":a,"color":"#ff0000"}));
+    let red = group(&s, &[a, b], "FF0000");
+    let before = s.undo_depth();
+    run(&mut s, "selection.selectColor", json!({"targets":red.targets}));
+    assert_eq!(s.selection(), vec![a]);
+    assert_eq!(s.undo_depth(), before);
+}
+
+#[test]
+fn applying_color_styles_links_matching_fill_and_stroke_lists_only() {
+    let mut s = Session::new();
+    let a = rectangle(&mut s, "#ff0000");
+    let b = rectangle(&mut s, "#0000ff");
+    run(&mut s, "stroke.add", json!({"id":b,"color":"#ff0000"}));
+    let red = group(&s, &[a, b], "FF0000");
+    let style = run(&mut s, "style.create", json!({"type":"paint","name":"Brand","value":"#00ff00"}))["id"].clone();
+    let before = s.undo_depth();
+    run(&mut s, "selection.applyColorStyle", json!({"targets":red.targets,"style":style}));
+    assert_eq!(fill(&s, a), "00FF00");
+    assert_eq!(fill(&s, b), "0000FF");
+    assert_eq!(s.doc().unwrap().node(a).unwrap().styles.fill.as_deref(), style.as_str());
+    assert_eq!(s.doc().unwrap().node(b).unwrap().styles.stroke.as_deref(), style.as_str());
+    assert_eq!(s.undo_depth().0, before.0 + 1);
+    run(&mut s, "style.update", json!({"style":style,"value":"#ffff00"}));
+    assert_eq!(fill(&s, a), "FFFF00");
+    assert_eq!(fill(&s, b), "0000FF");
+}
+
+#[test]
+fn explicit_color_detaches_its_binding_but_keeps_other_bindings() {
+    let mut s = Session::new();
+    let a = rectangle(&mut s, "#ff0000");
+    run(&mut s, "variable.createCollection", json!({"name":"Theme"}));
+    let v = run(&mut s, "variable.create", json!({"collection":"Theme","name":"Brand","type":"color","value":"#ff0000"}))["id"].clone();
+    run(&mut s, "variable.bind", json!({"id":a,"field":"fill","variable":v}));
+    let red = group(&s, &[a], "FF0000");
+    run(&mut s, "selection.setPaint", json!({"targets":red.targets,"paint":"#0000ff"}));
+    assert_eq!(fill(&s, a), "0000FF");
+    assert!(s.doc().unwrap().node(a).unwrap().bound.is_empty());
+    s.undo().unwrap();
+    assert_eq!(fill(&s, a), "FF0000");
+    assert!(!s.doc().unwrap().node(a).unwrap().bound.is_empty());
+}
+
+#[test]
+fn invalid_or_stale_targets_roll_back_atomically() {
+    let mut s = Session::new();
+    let a = rectangle(&mut s, "#ff0000");
+    let mut red = group(&s, &[a], "FF0000");
+    let mut bad = red.targets[0].clone();
+    bad.index = 999;
+    red.targets.push(bad);
+    let before = s.undo_depth();
+    assert!(s.execute("selection.setPaint", &json!({"targets":red.targets,"paint":"#0000ff"})).is_err());
+    assert_eq!(fill(&s, a), "FF0000");
+    assert_eq!(s.undo_depth(), before);
+    for command in ["selection.setPaint", "selection.selectColor", "selection.applyColorStyle"] {
+        for params in [json!({}), json!({"targets":[]}), json!({"targets":[{"id":a,"fills":true,"index":0,"range":[0,1]}]})] {
+            assert!(s.execute(command, &params).is_err());
+        }
+    }
+}
+
+#[test]
+fn equal_resolved_colors_from_different_styles_or_variables_stay_separate() {
+    let mut s = Session::new();
+    let a = rectangle(&mut s, "#ff0000");
+    let b = rectangle(&mut s, "#ff0000");
+    let c = rectangle(&mut s, "#ff0000");
+    let style = run(&mut s, "style.create", json!({"type":"paint","name":"Brand","value":"#ff0000"}))["id"].clone();
+    run(&mut s, "style.apply", json!({"id":a,"style":style,"target":"fill"}));
+    run(&mut s, "variable.createCollection", json!({"name":"Theme"}));
+    let variable = run(&mut s, "variable.create", json!({"collection":"Theme","name":"Accent","type":"color","value":"#ff0000"}))["id"].clone();
+    run(&mut s, "variable.bind", json!({"id":b,"field":"fill","variable":variable}));
+    let colors = collect(s.doc().unwrap(), &[a, b, c]);
+    assert_eq!(colors.len(), 3);
+    assert_eq!(colors[0].style.as_deref(), style.as_str());
+    assert_eq!(colors[1].variable.as_deref(), variable.as_str());
+    assert!(colors[2].style.is_none() && colors[2].variable.is_none());
+}
+
+#[test]
+fn gradients_and_multiple_paints_are_edited_without_replacing_other_slots() {
+    use figcraft_color::{Color, Gradient, GradientKind};
+    let mut s = Session::new();
+    let a = rectangle(&mut s, "#ff0000");
+    let paint = Paint::gradient(Gradient::default_for(GradientKind::Linear, Color::BLACK));
+    run(&mut s, "fill.add", json!({"id":a,"paint":paint}));
+    let colors = collect(s.doc().unwrap(), &[a]);
+    assert_eq!(colors.len(), 2);
+    let gradient = colors.iter().find(|g| g.paint == paint).unwrap();
+    run(&mut s, "selection.setPaint", json!({"targets":gradient.targets,"paint":"#00ff00"}));
+    let paints = &s.doc().unwrap().node(a).unwrap().fills;
+    assert_eq!(paints.len(), 2);
+    assert_eq!(paints[0].solid_color().unwrap().to_hex(), "FF0000");
+    assert_eq!(paints[1].solid_color().unwrap().to_hex(), "00FF00");
+}
+
+#[test]
+fn masks_and_boolean_operands_are_not_selection_colors() {
+    let mut s = Session::new();
+    let a = rectangle(&mut s, "#ff0000");
+    let b = rectangle(&mut s, "#00ff00");
+    let boolean = NodeId(run(&mut s, "bool.union", json!({"ids":[a,b]}))["id"].as_u64().unwrap());
+    run(&mut s, "fill.set", json!({"id":boolean,"color":"#0000ff"}));
+    let colors = collect(s.doc().unwrap(), &[boolean]);
+    assert_eq!(colors.len(), 1);
+    assert_eq!(colors[0].paint.solid_color().unwrap().to_hex(), "0000FF");
+    s.doc_mut().unwrap().get_mut(boolean).unwrap().is_mask = true;
+    assert!(collect(s.doc().unwrap(), &[boolean]).is_empty());
+}
+
+#[test]
+fn range_edit_keeps_a_node_binding_that_other_characters_inherit() {
+    let mut s = Session::new();
+    let id = NodeId(run(&mut s, "text.create", json!({"text":"abc","props":{"fill":"#ff0000"}}))["id"].as_u64().unwrap());
+    run(&mut s, "variable.createCollection", json!({"name":"Theme"}));
+    let v = run(&mut s, "variable.create", json!({"collection":"Theme","name":"Brand","type":"color","value":"#ff0000"}))["id"].clone();
+    run(&mut s, "variable.bind", json!({"id":id,"field":"fill","variable":v}));
+    run(&mut s, "text.style", json!({"id":id,"start":1,"end":2,"textFills":["#0000ff"]}));
+    let blue = group(&s, &[id], "0000FF");
+    run(&mut s, "selection.setPaint", json!({"targets":blue.targets,"paint":"#00ff00"}));
+    assert!(!s.doc().unwrap().node(id).unwrap().bound.is_empty());
+    assert_eq!(fill(&s, id), "FF0000");
+    assert_eq!(
+        s.doc().unwrap().node(id).unwrap().kind.text().unwrap().style_at(1).fills.as_ref().unwrap()[0].solid_color().unwrap().to_hex(),
+        "00FF00"
+    );
+}
+
+#[test]
+fn selection_color_edits_respect_read_only_version_previews() {
+    let mut s = Session::new();
+    let a = rectangle(&mut s, "#ff0000");
+    run(&mut s, "file.saveVersion", json!({"name":"Before"}));
+    run(&mut s, "version.preview", json!({"index":0}));
+    let red = group(&s, &[a], "FF0000");
+    let before = s.undo_depth();
+    assert!(s.execute("selection.setPaint", &json!({"targets":red.targets,"paint":"#0000ff"})).is_err());
+    assert_eq!(fill(&s, a), "FF0000");
+    assert_eq!(s.undo_depth(), before);
+}
+
+#[test]
+fn opacity_edits_keep_the_color_variable_binding() {
+    let mut s = Session::new();
+    let a = rectangle(&mut s, "#ff0000");
+    run(&mut s, "variable.createCollection", json!({"name":"Theme"}));
+    let v = run(&mut s, "variable.create", json!({"collection":"Theme","name":"Brand","type":"color","value":"#ff0000"}))["id"].clone();
+    run(&mut s, "variable.bind", json!({"id":a,"field":"fill","variable":v}));
+    let mut red = group(&s, &[a], "FF0000");
+    red.paint.opacity = 0.5;
+    run(&mut s, "selection.setPaint", json!({"targets":red.targets,"paint":red.paint}));
+    let n = s.doc().unwrap().node(a).unwrap();
+    assert_eq!(n.fills[0].opacity, 0.5);
+    assert!(!n.bound.is_empty());
+}
+
+#[test]
+fn whole_text_fill_keeps_a_color_style_link() {
+    let mut s = Session::new();
+    let id = NodeId(run(&mut s, "text.create", json!({"text":"Text","props":{"fill":"#ff0000"}}))["id"].as_u64().unwrap());
+    let red = group(&s, &[id], "FF0000");
+    assert_eq!(red.targets[0].range, None);
+    let style = run(&mut s, "style.create", json!({"type":"paint","name":"Brand","value":"#0000ff"}))["id"].clone();
+    run(&mut s, "selection.applyColorStyle", json!({"targets":red.targets,"style":style}));
+    assert_eq!(s.doc().unwrap().node(id).unwrap().styles.fill.as_deref(), style.as_str());
+    run(&mut s, "style.update", json!({"style":style,"value":"#00ff00"}));
+    assert_eq!(fill(&s, id), "00FF00");
+}
diff --git a/crates/engine/tests/shape_builder_response.rs b/crates/engine/tests/it/shape_builder_response.rs
similarity index 95%
rename from crates/engine/tests/shape_builder_response.rs
rename to crates/engine/tests/it/shape_builder_response.rs
index e1426823b..6187e556e 100644
--- a/crates/engine/tests/shape_builder_response.rs
+++ b/crates/engine/tests/it/shape_builder_response.rs
@@ -1,4 +1,3 @@
-#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
 use figcraft_engine::Session;
 use serde_json::{Value, json};
 
diff --git a/crates/format/src/fig/assets_tests.rs b/crates/format/src/fig/assets_tests.rs
index 4777be185..b48dd9d38 100644
--- a/crates/format/src/fig/assets_tests.rs
+++ b/crates/format/src/fig/assets_tests.rs
@@ -104,7 +104,10 @@ fn themed() -> Document {
     add(&mut doc, frame, NodeKind::Rectangle, "Swatch", (10.0, 10.0), (80.0, 60.0), &|n| {
         let mut g = Gradient::default_for(GradientKind::Linear, Color::BLACK);
         g.stops = vec![ColorStop { position: 0.0, color: Color::BLACK }, ColorStop { position: 1.0, color: Color::WHITE }];
-        n.fills = vec![solid(0.5, 0.5, 0.5), Paint { kind: PaintKind::Gradient(g), opacity: 1.0, visible: true, blend: BlendMode::Normal }];
+        n.fills = vec![
+            solid(0.5, 0.5, 0.5),
+            Paint { kind: PaintKind::Gradient(g), opacity: 1.0, visible: true, blend: BlendMode::Normal, color_alpha: false },
+        ];
         n.strokes = vec![solid(0.0, 0.0, 0.0), solid(1.0, 0.0, 0.0)];
         n.effects = vec![Effect {
             kind: EffectKind::DropShadow(Shadow {
diff --git a/crates/format/src/fig/auto_layout_sizing_tests.rs b/crates/format/src/fig/auto_layout_sizing_tests.rs
new file mode 100644
index 000000000..29580afb9
--- /dev/null
+++ b/crates/format/src/fig/auto_layout_sizing_tests.rs
@@ -0,0 +1,218 @@
+//! How auto layout frames and text size on import (hug or fixed), on encoded `.fig` files built in
+//! code and REST file JSON: the sizing a file records, an auto layout frame that records none, and
+//! text that hugs by its resize mode. Also how distributed main-axis alignment reads.
+
+use figcraft_doc::{Document, MainAlign, Sizing};
+use serde_json::{Value, json};
+
+use super::kiwi::{Kv, Schema};
+
+const SCHEMA: &str = "
+enum NodeType NONE DOCUMENT CANVAS FRAME TEXT SYMBOL INSTANCE
+enum StackMode NONE HORIZONTAL VERTICAL
+enum StackSize FIXED RESIZE_TO_FIT RESIZE_TO_FIT_WITH_IMPLICIT_SIZE
+enum StackJustify MIN CENTER MAX SPACE_EVENLY SPACE_BETWEEN SPACE_AROUND SPACE_EVENLY_CSS
+enum TextAutoResize NONE WIDTH_AND_HEIGHT HEIGHT
+struct GUID uint sessionID, uint localID
+struct Vector float x, float y
+struct Matrix float m00, float m01, float m02, float m10, float m11, float m12
+message ParentIndex GUID guid, string position
+message TextData string characters
+message SymbolData GUID symbolID
+message NodeChange GUID guid, ParentIndex parentIndex, NodeType type, string name, Vector size, Matrix transform, StackMode stackMode, StackSize stackPrimarySizing, StackSize stackCounterSizing, StackJustify stackPrimaryAlignItems, TextAutoResize textAutoResize, float fontSize, TextData textData, SymbolData symbolData
+message Message NodeChange[] nodeChanges
+";
+
+type Fields = Vec<(&'static str, Kv<'static>)>;
+
+fn o(fields: Fields) -> Kv<'static> {
+    Kv::Object(fields)
+}
+
+fn g(id: u64) -> Kv<'static> {
+    o(vec![("sessionID", Kv::Uint(1)), ("localID", Kv::Uint(id))])
+}
+
+fn xy(x: f64, y: f64) -> Kv<'static> {
+    o(vec![("x", Kv::Float(x as f32)), ("y", Kv::Float(y as f32))])
+}
+
+fn at(x: f64, y: f64) -> Kv<'static> {
+    let f = |v: f64| Kv::Float(v as f32);
+    o(vec![("m00", f(1.0)), ("m01", f(0.0)), ("m02", f(x)), ("m10", f(0.0)), ("m11", f(1.0)), ("m12", f(y))])
+}
+
+fn node(id: u64, parent: u64, pos: &str, ty: &'static str, name: &str, mut more: Fields) -> Kv<'static> {
+    let mut v = vec![("guid", g(id)), ("parentIndex", o(vec![("guid", g(parent)), ("position", Kv::Str(pos.into()))]))];
+    v.extend([("type", Kv::Enum(ty)), ("name", Kv::Str(name.into()))]);
+    v.append(&mut more);
+    o(v)
+}
+
+/// An auto layout frame's fields: its direction and the sizing it records (`None`: none).
+fn stack(mode: &'static str, primary: Option<&'static str>, counter: Option<&'static str>) -> Fields {
+    let mut f = vec![("stackMode", Kv::Enum(mode))];
+    f.extend(primary.map(|p| ("stackPrimarySizing", Kv::Enum(p))));
+    f.extend(counter.map(|c| ("stackCounterSizing", Kv::Enum(c))));
+    f
+}
+
+/// A text layer "<name> text" in `parent`, with resize mode `resize` (`None`: none recorded).
+fn label(id: u64, parent: u64, name: &str, resize: Option<&'static str>) -> Kv<'static> {
+    let mut f = vec![("size", xy(40.0, 16.0)), ("transform", at(0.0, 0.0)), ("fontSize", Kv::Float(12.0))];
+    f.push(("textData", o(vec![("characters", Kv::Str(name.into()))])));
+    f.extend(resize.map(|r| ("textAutoResize", Kv::Enum(r))));
+    node(id, parent, "!", "TEXT", &format!("{name} text"), f)
+}
+
+/// A component at `x` holding a text layer, with `fields` of its own.
+fn component(id: u64, x: f64, name: &str, fields: Fields, resize: Option<&'static str>) -> Vec<Kv<'static>> {
+    let mut f = vec![("size", xy(40.0, 16.0)), ("transform", at(x, 0.0))];
+    f.extend(fields);
+    vec![node(id, 1, &format!("{id}"), "SYMBOL", name, f), label(id + 1, id, name, resize)]
+}
+
+fn import(nodes: Vec<Kv<'static>>) -> Document {
+    let mut all = vec![
+        o(vec![
+            ("guid", o(vec![("sessionID", Kv::Uint(0)), ("localID", Kv::Uint(0))])),
+            ("type", Kv::Enum("DOCUMENT")),
+            ("name", Kv::Str("D".into())),
+        ]),
+        o(vec![
+            ("guid", g(1)),
+            ("parentIndex", o(vec![("guid", o(vec![("sessionID", Kv::Uint(0)), ("localID", Kv::Uint(0))])), ("position", Kv::Str("!".into()))])),
+            ("type", Kv::Enum("CANVAS")),
+            ("name", Kv::Str("Page".into())),
+        ]),
+    ];
+    all.extend(nodes);
+    let schema = Schema::parse(SCHEMA).unwrap();
+    let bytes = super::tests::canvas(&schema, &o(vec![("nodeChanges", Kv::Array(all))]));
+    super::import(&bytes, "sizing").unwrap().0
+}
+
+fn sizing(doc: &Document, name: &str) -> (Sizing, Sizing) {
+    let n = doc.nodes().find(|n| n.name == name).unwrap_or_else(|| panic!("no layer {name}"));
+    (n.child_layout.sizing_h, n.child_layout.sizing_v)
+}
+
+#[test]
+fn auto_layout_frames_hug_as_recorded_and_by_default_on_their_primary_axis() {
+    use Sizing::{Fixed, Hug};
+    let fit = Some("RESIZE_TO_FIT");
+    // (component, its auto layout fields, expected (horizontal, vertical), derivation)
+    let rows: Vec<(&str, Fields, (Sizing, Sizing), &str)> = vec![
+        ("Button", stack("HORIZONTAL", fit, fit), (Hug, Hug), "both axes hug, as recorded"),
+        ("Implicit", stack("HORIZONTAL", Some("RESIZE_TO_FIT_WITH_IMPLICIT_SIZE"), fit), (Hug, Hug), "hugging with an implicit size"),
+        ("Fixed", stack("HORIZONTAL", Some("FIXED"), Some("FIXED")), (Fixed, Fixed), "both axes fixed, as recorded"),
+        ("Legacy", stack("HORIZONTAL", None, fit), (Hug, Hug), "no primary sizing: the primary axis sizes by its content"),
+        ("Legacy column", stack("VERTICAL", None, None), (Fixed, Hug), "no sizing: the primary (vertical) axis hugs, the counter axis is fixed"),
+    ];
+    let mut nodes = Vec::new();
+    for (k, (name, fields, _, _)) in rows.iter().enumerate() {
+        nodes.extend(component(10 * (k as u64 + 1), 60.0 * k as f64, name, fields.clone(), Some("WIDTH_AND_HEIGHT")));
+    }
+    let doc = import(nodes);
+    for (name, _, want, why) in rows {
+        assert_eq!(sizing(&doc, name), want, "{name}: {why}");
+    }
+}
+
+#[test]
+fn text_hugs_by_its_resize_mode() {
+    use Sizing::{Fixed, Hug};
+    let fit = Some("RESIZE_TO_FIT");
+    let mut nodes = Vec::new();
+    for (k, (name, resize)) in
+        [("Auto width", Some("WIDTH_AND_HEIGHT")), ("Auto height", Some("HEIGHT")), ("Fixed box", Some("NONE")), ("Unset", None)]
+            .into_iter()
+            .enumerate()
+    {
+        nodes.extend(component(10 * (k as u64 + 1), 60.0 * k as f64, name, stack("HORIZONTAL", fit, fit), resize));
+    }
+    // An instance of the auto width one: it hugs, and so does its copy of the text.
+    nodes.push(node(
+        90,
+        1,
+        "~",
+        "INSTANCE",
+        "Auto width instance",
+        [vec![("size", xy(40.0, 16.0)), ("transform", at(0.0, 100.0)), ("symbolData", o(vec![("symbolID", g(10))]))], stack("HORIZONTAL", fit, fit)]
+            .concat(),
+    ));
+    // One that records nothing of its auto layout: it has its main's.
+    nodes.push(node(
+        91,
+        1,
+        "~~",
+        "INSTANCE",
+        "Bare instance",
+        vec![("size", xy(40.0, 16.0)), ("transform", at(0.0, 150.0)), ("symbolData", o(vec![("symbolID", g(10))]))],
+    ));
+    let doc = import(nodes);
+    for (name, want) in
+        [("Auto width text", (Hug, Hug)), ("Auto height text", (Fixed, Hug)), ("Fixed box text", (Fixed, Fixed)), ("Unset text", (Fixed, Fixed))]
+    {
+        assert_eq!(sizing(&doc, name), want, "{name}");
+    }
+    let inst = doc.nodes().find(|n| n.name == "Auto width instance").unwrap();
+    assert_eq!((inst.child_layout.sizing_h, inst.child_layout.sizing_v), (Hug, Hug));
+    let copy = inst.children.first().and_then(|c| doc.node(*c)).unwrap();
+    assert_eq!((copy.child_layout.sizing_h, copy.child_layout.sizing_v), (Hug, Hug));
+    let bare = doc.nodes().find(|n| n.name == "Bare instance").unwrap();
+    assert_eq!(bare.layout.as_ref().map(|l| l.mode), Some(figcraft_doc::LayoutMode::Horizontal));
+    assert_eq!((bare.child_layout.sizing_h, bare.child_layout.sizing_v), (Hug, Hug));
+}
+
+#[test]
+fn rest_files_read_left_out_sizing_modes_as_hug_and_text_by_its_resize_mode() {
+    use Sizing::{Fixed, Hug};
+    let at = json!([[1, 0, 0], [0, 1, 0]]);
+    let text = |id: &str, name: &str, more: Value| {
+        let mut t = json!({"id": id, "name": name, "type": "TEXT", "relativeTransform": at, "size": {"x": 40, "y": 16}, "characters": name,
+            "style": {"fontFamily": "Inter", "fontSize": 12, "textAutoResize": "WIDTH_AND_HEIGHT"}});
+        t.as_object_mut().unwrap().extend(more.as_object().unwrap().clone());
+        t
+    };
+    let frame = |id: &str, name: &str, more: Value, kids: Value| {
+        let mut f = json!({"id": id, "name": name, "type": "COMPONENT", "relativeTransform": at, "size": {"x": 40, "y": 16},
+            "layoutMode": "HORIZONTAL", "children": kids});
+        f.as_object_mut().unwrap().extend(more.as_object().unwrap().clone());
+        f
+    };
+    let file = json!({"name": "Sizing", "document": {"id": "0:0", "type": "DOCUMENT", "children": [{"id": "0:1", "name": "Page", "type": "CANVAS", "children": [
+        frame("1:1", "Defaults", json!({}), json!([text("1:2", "Label", json!({}))])),
+        frame("2:1", "Fixed", json!({"primaryAxisSizingMode": "FIXED", "counterAxisSizingMode": "FIXED"}),
+            json!([text("2:2", "Fixed label", json!({"layoutSizingHorizontal": "FIXED"}))])),
+    ]}]}});
+    let (doc, _) = crate::rest::import(&file, &crate::rest::no_images).unwrap();
+    // The REST API leaves out the default sizing modes (AUTO); explicit per-axis sizing wins.
+    for (name, want) in [("Defaults", (Hug, Hug)), ("Label", (Hug, Hug)), ("Fixed", (Fixed, Fixed)), ("Fixed label", (Fixed, Hug))] {
+        assert_eq!(sizing(&doc, name), want, "{name}");
+    }
+}
+
+#[test]
+fn distributed_alignment_reads_the_older_evenly_name_as_space_between() {
+    let rows = [
+        ("Between", "SPACE_BETWEEN", MainAlign::SpaceBetween),
+        ("Older evenly", "SPACE_EVENLY", MainAlign::SpaceBetween),
+        ("Around", "SPACE_AROUND", MainAlign::SpaceAround),
+        ("Evenly", "SPACE_EVENLY_CSS", MainAlign::SpaceEvenly),
+    ];
+    let nodes = rows
+        .iter()
+        .enumerate()
+        .flat_map(|(i, (name, align, _))| {
+            let mut fields = stack("HORIZONTAL", None, None);
+            fields.push(("stackPrimaryAlignItems", Kv::Enum(align)));
+            component(10 + 2 * i as u64, 50.0 * i as f64, name, fields, None)
+        })
+        .collect();
+    let doc = import(nodes);
+    for (name, _, want) in rows {
+        let n = doc.nodes().find(|n| n.name == name).unwrap_or_else(|| panic!("no layer {name}"));
+        assert_eq!(n.layout.as_ref().map(|l| l.main_align), Some(want), "{name}");
+    }
+}
diff --git a/crates/format/src/fig/connector_label_tests.rs b/crates/format/src/fig/connector_label_tests.rs
new file mode 100644
index 000000000..de0c4f2fb
--- /dev/null
+++ b/crates/format/src/fig/connector_label_tests.rs
@@ -0,0 +1,243 @@
+use super::{kiwi::Kv, map};
+
+fn obj(fields: Vec<(&'static str, Kv<'static>)>) -> Kv<'static> {
+    Kv::Object(fields)
+}
+
+fn scalar(value: f32) -> Kv<'static> {
+    Kv::Float(value)
+}
+
+fn guid(local_id: u64) -> Kv<'static> {
+    obj(vec![("sessionID", Kv::Uint(40_000_000)), ("localID", Kv::Uint(local_id))])
+}
+
+fn record(local_id: u64, children: Vec<(&'static str, Kv<'static>)>) -> Kv<'static> {
+    let mut fields = vec![("guidPath", obj(vec![("guids", Kv::Array(vec![guid(local_id)]))]))];
+    fields.extend(children);
+    obj(fields)
+}
+
+fn transform(x: f32, y: f32) -> Kv<'static> {
+    obj(vec![("m00", scalar(1.0)), ("m01", scalar(0.0)), ("m02", scalar(x)), ("m10", scalar(0.0)), ("m11", scalar(1.0)), ("m12", scalar(y))])
+}
+
+fn point(x: f32, y: f32) -> Kv<'static> {
+    obj(vec![("x", scalar(x)), ("y", scalar(y))])
+}
+
+fn path_blob() -> Vec<u8> {
+    let mut bytes = vec![1]; // MoveTo
+    bytes.extend(0.0f32.to_le_bytes());
+    bytes.extend(0.0f32.to_le_bytes());
+    bytes.push(2); // LineTo
+    bytes.extend(20.0f32.to_le_bytes());
+    bytes.extend(10.0f32.to_le_bytes());
+    bytes
+}
+
+fn paint() -> Kv<'static> {
+    obj(vec![
+        ("type", Kv::Enum("SOLID")),
+        ("color", obj(vec![("r", scalar(0.1)), ("g", scalar(0.2)), ("b", scalar(0.8)), ("a", scalar(1.0))])),
+        ("visible", Kv::Bool(true)),
+    ])
+}
+
+fn synthetic_connector(version: f32, include_text: bool, text_x: f32) -> Kv<'static> {
+    let line_geometry = Kv::Array(vec![obj(vec![("commandsBlob", Kv::Uint(0))])]);
+    let line = record(0, vec![("transform", transform(7.0, 9.0)), ("size", point(20.0, 10.0)), ("fillGeometry", line_geometry)]);
+    let text = record(1, vec![("transform", transform(text_x, 3.0)), ("size", point(80.0, 24.0))]);
+    let background = record(2, vec![("transform", transform(100.0, 30.0)), ("size", point(90.0, 30.0))]);
+    let mut derived = vec![line];
+    if include_text {
+        derived.extend([text, background]);
+    }
+    let line_style = record(0, vec![("strokePaints", Kv::Array(vec![paint()]))]);
+    let text_style = record(
+        1,
+        vec![
+            ("textData", obj(vec![("characters", Kv::Str("synthetic label".into()))])),
+            ("fontSize", scalar(24.0)),
+            ("fontName", obj(vec![("family", Kv::Str("Inter".into())), ("style", Kv::Str("Regular".into()))])),
+            ("fillPaints", Kv::Array(vec![paint()])),
+            ("visible", Kv::Bool(false)),
+        ],
+    );
+    let bg_style = record(2, vec![("fillPaints", Kv::Array(vec![])), ("visible", Kv::Bool(false))]);
+    let mut styles = vec![line_style];
+    if include_text {
+        styles.extend([text_style, bg_style]);
+    }
+    obj(vec![
+        (
+            "nodeChanges",
+            Kv::Array(vec![
+                obj(vec![("guid", guid(0)), ("type", Kv::Enum("DOCUMENT")), ("name", Kv::Str("Doc".into()))]),
+                obj(vec![
+                    ("guid", guid(1)),
+                    ("parentIndex", obj(vec![("guid", guid(0)), ("position", Kv::Str("!".into()))])),
+                    ("type", Kv::Enum("CANVAS")),
+                    ("name", Kv::Str("Page".into())),
+                ]),
+                obj(vec![
+                    ("guid", obj(vec![("sessionID", Kv::Uint(1)), ("localID", Kv::Uint(123))])),
+                    ("parentIndex", obj(vec![("guid", guid(1)), ("position", Kv::Str("!".into()))])),
+                    ("type", Kv::Enum("CONNECTOR")),
+                    ("name", Kv::Str("synthetic connector".into())),
+                    ("size", point(140.0, 50.0)),
+                    ("opacity", scalar(0.5)),
+                    ("connectorType", Kv::Enum("MANUAL")),
+                    ("connectorVersion", scalar(version)),
+                    ("connectorLineStyle", Kv::Enum("STRAIGHT")),
+                    ("connectorStartCap", Kv::Enum("NONE")),
+                    ("connectorEndCap", Kv::Enum("ARROW")),
+                    ("derivedImmutableFrameData", obj(vec![("version", scalar(1.0)), ("overrides", Kv::Array(derived))])),
+                    ("nodeGenerationData", obj(vec![("overrides", Kv::Array(styles))])),
+                ]),
+            ]),
+        ),
+        ("blobs", Kv::Array(vec![obj(vec![("bytes", Kv::Bytes(path_blob()))])])),
+    ])
+}
+
+fn map_synthetic(version: f32, include_text: bool, text_x: f32) -> (serde_json::Value, Vec<String>) {
+    let (rest, warnings, _) = map::to_rest(&synthetic_connector(version, include_text, text_x), "synthetic", crate::rest::MAX_NODES);
+    (rest, warnings)
+}
+
+fn find_node<'a>(doc: &'a figcraft_doc::Document, name: &str) -> &'a figcraft_doc::Node {
+    doc.nodes().find(|node| node.name == name).expect("native node")
+}
+
+#[test]
+fn synthetic_label_style_transform_and_container_opacity_survive_native_roundtrip() {
+    let (rest, warnings) = map_synthetic(1.0, true, 8.5);
+    let connector = &rest["document"]["children"][0]["children"][0];
+    assert_eq!(connector["type"], "FRAME");
+    assert_eq!(connector["opacity"], 0.5);
+    assert_eq!(connector["children"].as_array().unwrap().len(), 2, "empty/hidden background is omitted; hidden text remains explicit");
+    let text = &connector["children"][1];
+    assert_eq!(text["type"], "TEXT");
+    assert_eq!(text["visible"], false);
+    assert_eq!(text["fills"].as_array().unwrap().len(), 1);
+    assert!((text["fills"][0]["color"]["b"].as_f64().unwrap() - 0.8).abs() < 1e-6);
+    assert_eq!(text["style"]["fontSize"], 24.0);
+    assert_eq!(text["relativeTransform"], serde_json::json!([[1.0, 0.0, 108.5], [0.0, 1.0, 33.0]]));
+    assert!(warnings.iter().any(|warning| warning.contains("live endpoint bindings are not retained")));
+
+    let (native, _) = crate::rest::import_fig(&rest, &|_| None).unwrap();
+    let bytes = crate::save_bytes(&native, None).unwrap();
+    let (reopened, _) = crate::load_bytes(&bytes).unwrap();
+    let frame = find_node(&reopened, "synthetic connector");
+    assert_eq!(frame.opacity, 0.5);
+    let text = find_node(&reopened, "synthetic label");
+    assert!(!text.visible);
+    assert_eq!(text.opacity, 1.0, "root opacity must not be copied to child");
+    assert_eq!(text.transform.as_coeffs()[4..], [108.5, 33.0]);
+    assert_eq!(text.fills.len(), 1);
+    let figcraft_doc::NodeKind::Text(data) = &text.kind else { panic!("text child kind") };
+    assert_eq!(data.style.font_size, 24.0);
+}
+
+#[test]
+fn synthetic_connector_missing_optional_derived_label_keeps_vector() {
+    let (rest, warnings) = map_synthetic(1.0, false, 0.0);
+    let connector = &rest["document"]["children"][0]["children"][0];
+    assert_eq!(connector["type"], "VECTOR", "an unlabelled connector keeps the single-vector shape");
+    assert!(connector.get("children").is_none());
+    assert!(warnings.iter().all(|warning| !warning.contains("connector labels were skipped")));
+}
+
+#[test]
+fn synthetic_unlabelled_connector_imports_as_one_vector_with_line_style() {
+    let (rest, warnings) = map_synthetic(1.0, false, 0.0);
+    let connector = &rest["document"]["children"][0]["children"][0];
+    assert_eq!(connector["type"], "VECTOR");
+    assert_eq!(connector["name"], "synthetic connector");
+    assert_eq!(connector["opacity"], 0.5);
+    assert_eq!(connector["strokes"].as_array().map(Vec::len), Some(1));
+    assert_eq!(connector["strokeCapEnd"], "ARROW");
+    assert!(warnings.iter().all(|warning| !warning.contains("connector label")), "{warnings:?}");
+
+    let (native, _) = crate::rest::import_fig(&rest, &|_| None).unwrap();
+    let node = find_node(&native, "synthetic connector");
+    assert!(matches!(node.kind, figcraft_doc::NodeKind::Vector { .. }));
+}
+
+#[test]
+fn synthetic_connector_unsupported_version_uses_legacy_warning() {
+    let (rest, warnings) = map_synthetic(2.0, true, 8.5);
+    let connector = &rest["document"]["children"][0]["children"][0];
+    assert_eq!(connector["type"], "VECTOR");
+    assert!(warnings.iter().any(|warning| warning == "connector labels were skipped"));
+}
+
+#[test]
+fn synthetic_connector_malformed_label_bounds_or_transform_keep_vector() {
+    let mut malformed_bounds = synthetic_connector(1.0, true, 8.5);
+    set_override_field(&mut malformed_bounds, "derivedImmutableFrameData", 1, "size", point(f32::NAN, 24.0));
+    let (rest, warnings, _) = map::to_rest(&malformed_bounds, "synthetic", crate::rest::MAX_NODES);
+    let connector = &rest["document"]["children"][0]["children"][0];
+    assert_eq!(connector["children"].as_array().unwrap().len(), 1);
+    assert_eq!(connector["children"][0]["type"], "VECTOR");
+    assert!(warnings.iter().any(|warning| warning == "connector label was skipped: text bounds are invalid"));
+
+    let mut malformed_transform = synthetic_connector(1.0, true, 8.5);
+    set_override_field(&mut malformed_transform, "derivedImmutableFrameData", 1, "transform", transform(f32::NAN, 3.0));
+    let (rest, warnings, _) = map::to_rest(&malformed_transform, "synthetic", crate::rest::MAX_NODES);
+    let connector = &rest["document"]["children"][0]["children"][0];
+    assert_eq!(connector["children"].as_array().unwrap().len(), 1);
+    assert_eq!(connector["children"][0]["type"], "VECTOR");
+    assert!(warnings.iter().any(|warning| warning == "connector label was skipped: text transform is invalid"));
+}
+
+#[test]
+fn synthetic_connector_authored_hidden_background_is_retained() {
+    let mut message = synthetic_connector(1.0, true, 8.5);
+    set_override_field(&mut message, "nodeGenerationData", 2, "fillPaints", Kv::Array(vec![paint()]));
+    let (rest, _, _) = map::to_rest(&message, "synthetic", crate::rest::MAX_NODES);
+    let connector = &rest["document"]["children"][0]["children"][0];
+    let background = connector["children"].as_array().unwrap().iter().find(|child| child["type"] == "RECTANGLE").expect("authored background");
+    assert_eq!(background["visible"], false);
+    assert_eq!(background["fills"].as_array().unwrap().len(), 1);
+}
+
+fn field_mut<'a, 's>(value: &'a mut Kv<'s>, key: &str) -> Option<&'a mut Kv<'s>> {
+    let Kv::Object(fields) = value else { return None };
+    fields.iter_mut().find(|(name, _)| *name == key).map(|(_, value)| value)
+}
+
+fn connector_mut<'a, 's>(message: &'a mut Kv<'s>, local_id: u64) -> Option<&'a mut Kv<'s>> {
+    let Kv::Object(fields) = message else { return None };
+    let node_changes = fields.iter_mut().find(|(name, _)| *name == "nodeChanges").map(|(_, value)| value)?;
+    let Kv::Array(nodes) = node_changes else { return None };
+    nodes.iter_mut().find(|node| {
+        node.get("type").and_then(Kv::str) == Some("CONNECTOR")
+            && node.get("guid").and_then(|guid| guid.get("localID")).and_then(Kv::f64) == Some(local_id as f64)
+    })
+}
+
+fn set_override_field(message: &mut Kv<'_>, field: &str, local_id: u64, key: &'static str, value: Kv<'static>) {
+    let connector = connector_mut(message, 123).expect("synthetic connector");
+    let section = field_mut(connector, field).expect("connector override section");
+    let overrides = field_mut(section, "overrides").expect("override list");
+    let Kv::Array(rows) = overrides else { panic!("override list array") };
+    let row = rows
+        .iter_mut()
+        .find(|row| {
+            row.get("guidPath")
+                .and_then(|path| path.get("guids"))
+                .and_then(|ids| ids.list().first())
+                .and_then(|id| id.get("localID"))
+                .and_then(Kv::f64)
+                == Some(local_id as f64)
+        })
+        .expect("override row");
+    let Kv::Object(fields) = row else { panic!("override row object") };
+    if let Some((_, current)) = fields.iter_mut().find(|(name, _)| *name == key) {
+        *current = value;
+    } else {
+        fields.push((key, value));
+    }
+}
diff --git a/crates/format/src/fig/export.rs b/crates/format/src/fig/export.rs
index bfd0b6155..2d02539eb 100644
--- a/crates/format/src/fig/export.rs
+++ b/crates/format/src/fig/export.rs
@@ -25,10 +25,10 @@ use figcraft_doc::proto::{
     Action, Direction, Easing, GAMEPAD_BUTTONS, Interaction, KeyMods, Overflow, OverlayPosition, ScrollPosition, Transition, Trigger,
 };
 use figcraft_doc::{
-    AutoLayout, BoolOp, ContentAlign, CrossAlign, Document, EffectKind, ExportSize, GridAlign, GridKind, HConstraint, LayoutMode, LetterSpacing,
-    LineHeight, ListStyle, MainAlign, MaskType, Node, NodeId, NodeKind, NoiseMode, PropDef, Sizing, StrokeAlign, StrokeCap, StrokeJoin, StyleKind,
-    TextAlignH, TextAlignV, TextAutoResize, TextCase, TextData, TextDecoration, TextStyle, VConstraint, VariableType, VariableValue, VectorNetwork,
-    WindingRule,
+    AutoLayout, BoolOp, ContentAlign, CrossAlign, Document, EffectKind, ExportSize, GridAlign, GridKind, GridTrack, HConstraint, LayoutMode,
+    LetterSpacing, LineHeight, ListStyle, MainAlign, MaskType, Node, NodeId, NodeKind, NoiseMode, PropDef, Sizing, StrokeAlign, StrokeCap,
+    StrokeJoin, StyleKind, TextAlignH, TextAlignV, TextAutoResize, TextCase, TextData, TextDecoration, TextStyle, VConstraint, VariableType,
+    VariableValue, VectorNetwork, WindingRule,
 };
 use serde_json::Value;
 
@@ -73,7 +73,7 @@ enum StrokeJoin MITER=0 BEVEL=1 ROUND=2
 enum ConstraintType MIN=0 CENTER=1 MAX=2 STRETCH=3 SCALE=4
 enum StackMode NONE=0 HORIZONTAL=1 VERTICAL=2 GRID=3
 enum StackAlign MIN=0 CENTER=1 MAX=2 BASELINE=3
-enum StackJustify MIN=0 CENTER=1 MAX=2 SPACE_EVENLY=3 SPACE_BETWEEN=4 SPACE_AROUND=5
+enum StackJustify MIN=0 CENTER=1 MAX=2 SPACE_EVENLY=3 SPACE_BETWEEN=4 SPACE_AROUND=5 SPACE_EVENLY_CSS=6
 enum StackCounterAlign MIN=0 CENTER=1 MAX=2 STRETCH=3 AUTO=4 BASELINE=5
 enum StackSize FIXED=0 RESIZE_TO_FIT=1
 enum StackWrap NO_WRAP=0 WRAP=1
@@ -168,7 +168,12 @@ message PrototypeStartingPoint string name=1, string position=3
 message OverlayBackgroundAppearance OverlayBackgroundType backgroundType=1, Color backgroundColor=2
 message GUIDPositionMapEntry GUID id=1, string position=2
 message GUIDPositionMap GUIDPositionMapEntry[] entries=1
-message NodeChange GUID guid=1, NodePhase phase=2, ParentIndex parentIndex=3, NodeType type=4, string name=5, bool visible=6, bool locked=7, float opacity=8, BlendMode blendMode=9, Vector size=11, Matrix transform=12, bool mask=16, MaskType maskType=317, float backgroundOpacity=19, bool backgroundEnabled=15, bool internalOnly=142, string description=318, StyleType styleType=163, string sortPosition=320, StyleId styleIdForFill=332, StyleId styleIdForStrokeFill=333, StyleId styleIdForText=334, StyleId styleIdForEffect=335, StyleId styleIdForGrid=336, VariableDataMap variableConsumptionMap=307, VariableModeBySetMap variableModeBySetMap=316, VariableSetMode[] variableSetModes=312, VariableSetID variableSetID=313, VariableResolvedDataType variableResolvedType=314, VariableDataValues variableDataValues=315, VariableScope[] variableScopes=353, DocumentColorProfile documentColorProfile=349, Paint[] fillPaints=38, Paint[] strokePaints=39, float strokeWeight=26, StrokeAlign strokeAlign=29, StrokeJoin strokeJoin=31, StrokeCap strokeCap=30, float[] dashPattern=13, float miterLimit=25, bool borderStrokeWeightsIndependent=299, float borderTopWeight=295, float borderRightWeight=298, float borderBottomWeight=296, float borderLeftWeight=297, Effect[] effects=43, float cornerRadius=20, float cornerSmoothing=160, bool rectangleCornerRadiiIndependent=149, float rectangleTopLeftCornerRadius=145, float rectangleTopRightCornerRadius=146, float rectangleBottomRightCornerRadius=148, float rectangleBottomLeftCornerRadius=147, ConstraintType horizontalConstraint=28, ConstraintType verticalConstraint=37, bool frameMaskDisabled=115, bool resizeToFit=117, bool isStateGroup=225, bool sectionContentsHidden=283, Color backgroundColor=50, StackMode stackMode=105, float stackSpacing=107, float stackCounterSpacing=324, StackWrap stackWrap=323, StackCounterAlignContent stackCounterAlignContent=343, float stackHorizontalPadding=209, float stackVerticalPadding=210, float stackPaddingRight=233, float stackPaddingBottom=234, StackJustify stackPrimaryAlignItems=230, StackAlign stackCounterAlignItems=231, StackSize stackPrimarySizing=229, StackSize stackCounterSizing=221, bool bordersTakeSpace=294, bool stackReverseZIndex=271, float gridColumnGap=438, float gridRowGap=437, GUIDPositionMap gridColumns=436, GUIDPositionMap gridRows=435, float stackChildPrimaryGrow=232, StackCounterAlign stackChildAlignSelf=236, StackPositioning stackPositioning=269, OptionalVector minSize=325, OptionalVector maxSize=326, GUID gridColumnAnchor=440, GUID gridRowAnchor=439, uint gridColumnSpan=442, uint gridRowSpan=441, LayoutGrid[] layoutGrids=47, ExportSettings[] exportSettings=45, TextData textData=42, FontName fontName=41, float fontSize=21, Number lineHeight=40, Number letterSpacing=165, TextCase textCase=34, TextDecoration textDecoration=35, TextAlignHorizontal textAlignHorizontal=32, TextAlignVertical textAlignVertical=33, TextAutoResize textAutoResize=46, TextTruncation textTruncation=280, int maxLines=351, float paragraphSpacing=23, float paragraphIndent=22, Hyperlink hyperlink=223, bool autoRename=14, bool fontVariantCommonLigatures=127, bool fontVariantContextualLigatures=128, string fontVersion=202, uint textUserLayoutVersion=203, uint textExplicitLayoutVersion=396, uint textBidiVersion=279, float textTracking=27, bool textDecorationSkipInk=412, EmojiImageSet emojiImageSet=391, uint styleID=49, Path[] fillGeometry=51, Path[] strokeGeometry=52, VectorData vectorData=48, VectorMirror handleMirroring=44, uint count=10, float starInnerScale=24, ArcData arcData=195, BooleanOperation booleanOperation=36, string symbolDescription=144, VariableWidthPoint[] variableWidthPoints=447, PluginData[] pluginData=204, SymbolData symbolData=113, NodeChange[] derivedSymbolData=125, GUID overriddenSymbolID=143, ComponentPropDef[] componentPropDefs=266, ComponentPropAssignment[] componentPropAssignments=268, VariableDataMap parameterConsumptionMap=445, GUIDPath guidPath=111, PrototypeInteraction[] prototypeInteractions=226, PrototypeStartingPoint prototypeStartingPoint=249, ScrollDirection scrollDirection=159, ScrollBehavior scrollBehavior=186, OverlayPositionType overlayPositionType=198, OverlayBackgroundInteraction overlayBackgroundInteraction=200, OverlayBackgroundAppearance overlayBackgroundAppearance=201
+enum GridTrackSizingType FLEX=0 FIXED=1 HUG=2 UNKNOWN=3
+message GridTrackSizeFunction GridTrackSizingType type=1, float value=2
+message GridTrackSize GridTrackSizeFunction minSizing=1, GridTrackSizeFunction maxSizing=2
+message GridTrackSizeEntry GUID id=1, GridTrackSize trackSize=2
+message GridTrackSizeMap GridTrackSizeEntry[] entries=1
+message NodeChange GUID guid=1, NodePhase phase=2, ParentIndex parentIndex=3, NodeType type=4, string name=5, bool visible=6, bool locked=7, float opacity=8, BlendMode blendMode=9, Vector size=11, Matrix transform=12, bool mask=16, MaskType maskType=317, float backgroundOpacity=19, bool backgroundEnabled=15, bool internalOnly=142, string description=318, StyleType styleType=163, string sortPosition=320, StyleId styleIdForFill=332, StyleId styleIdForStrokeFill=333, StyleId styleIdForText=334, StyleId styleIdForEffect=335, StyleId styleIdForGrid=336, VariableDataMap variableConsumptionMap=307, VariableModeBySetMap variableModeBySetMap=316, VariableSetMode[] variableSetModes=312, VariableSetID variableSetID=313, VariableResolvedDataType variableResolvedType=314, VariableDataValues variableDataValues=315, VariableScope[] variableScopes=353, DocumentColorProfile documentColorProfile=349, Paint[] fillPaints=38, Paint[] strokePaints=39, float strokeWeight=26, StrokeAlign strokeAlign=29, StrokeJoin strokeJoin=31, StrokeCap strokeCap=30, float[] dashPattern=13, float miterLimit=25, bool borderStrokeWeightsIndependent=299, float borderTopWeight=295, float borderRightWeight=298, float borderBottomWeight=296, float borderLeftWeight=297, Effect[] effects=43, float cornerRadius=20, float cornerSmoothing=160, bool rectangleCornerRadiiIndependent=149, float rectangleTopLeftCornerRadius=145, float rectangleTopRightCornerRadius=146, float rectangleBottomRightCornerRadius=148, float rectangleBottomLeftCornerRadius=147, ConstraintType horizontalConstraint=28, ConstraintType verticalConstraint=37, bool frameMaskDisabled=115, bool resizeToFit=117, bool isStateGroup=225, bool sectionContentsHidden=283, Color backgroundColor=50, StackMode stackMode=105, float stackSpacing=107, float stackCounterSpacing=324, StackWrap stackWrap=323, StackCounterAlignContent stackCounterAlignContent=343, float stackHorizontalPadding=209, float stackVerticalPadding=210, float stackPaddingRight=233, float stackPaddingBottom=234, StackJustify stackPrimaryAlignItems=230, StackAlign stackCounterAlignItems=231, StackSize stackPrimarySizing=229, StackSize stackCounterSizing=221, bool bordersTakeSpace=294, bool stackReverseZIndex=271, float gridColumnGap=438, float gridRowGap=437, GUIDPositionMap gridColumns=436, GUIDPositionMap gridRows=435, GridTrackSizeMap gridColumnsSizing=443, GridTrackSizeMap gridRowsSizing=444, float stackChildPrimaryGrow=232, StackCounterAlign stackChildAlignSelf=236, StackPositioning stackPositioning=269, OptionalVector minSize=325, OptionalVector maxSize=326, GUID gridColumnAnchor=440, GUID gridRowAnchor=439, uint gridColumnSpan=442, uint gridRowSpan=441, LayoutGrid[] layoutGrids=47, ExportSettings[] exportSettings=45, TextData textData=42, FontName fontName=41, float fontSize=21, Number lineHeight=40, Number letterSpacing=165, TextCase textCase=34, TextDecoration textDecoration=35, TextAlignHorizontal textAlignHorizontal=32, TextAlignVertical textAlignVertical=33, TextAutoResize textAutoResize=46, TextTruncation textTruncation=280, int maxLines=351, float paragraphSpacing=23, float paragraphIndent=22, Hyperlink hyperlink=223, bool autoRename=14, bool fontVariantCommonLigatures=127, bool fontVariantContextualLigatures=128, string fontVersion=202, uint textUserLayoutVersion=203, uint textExplicitLayoutVersion=396, uint textBidiVersion=279, float textTracking=27, bool textDecorationSkipInk=412, EmojiImageSet emojiImageSet=391, uint styleID=49, Path[] fillGeometry=51, Path[] strokeGeometry=52, VectorData vectorData=48, VectorMirror handleMirroring=44, uint count=10, float starInnerScale=24, ArcData arcData=195, BooleanOperation booleanOperation=36, string symbolDescription=144, VariableWidthPoint[] variableWidthPoints=447, PluginData[] pluginData=204, SymbolData symbolData=113, NodeChange[] derivedSymbolData=125, GUID overriddenSymbolID=143, ComponentPropDef[] componentPropDefs=266, ComponentPropAssignment[] componentPropAssignments=268, VariableDataMap parameterConsumptionMap=445, GUIDPath guidPath=111, PrototypeInteraction[] prototypeInteractions=226, PrototypeStartingPoint prototypeStartingPoint=249, ScrollDirection scrollDirection=159, ScrollBehavior scrollBehavior=186, OverlayPositionType overlayPositionType=198, OverlayBackgroundInteraction overlayBackgroundInteraction=200, OverlayBackgroundAppearance overlayBackgroundAppearance=201
 struct Blob byte[] bytes
 message Message MessageType type=1, uint sessionID=2, NodeChange[] nodeChanges=4, Blob[] blobs=6
 ";
@@ -277,6 +282,20 @@ fn s(x: &str) -> Kv<'static> {
 fn b(x: bool) -> Kv<'static> {
     Kv::Bool(x)
 }
+
+/// A track's size as the format's enum name and value, when both sizing functions agree (the
+/// importer keeps only those). `None`: the format has no name for it, so an equal track stands in.
+fn grid_track_size(track: &GridTrack) -> Option<(&'static str, f64)> {
+    let value = track.value;
+    let fits = value.is_finite() && (0.0..=crate::fig::map::MAX_GRID_TRACK_VALUE).contains(&value);
+    match track.sizing {
+        Sizing::Fixed if fits => Some(("FIXED", value)),
+        Sizing::Fill if fits && value > 0.0 => Some(("FLEX", value)),
+        Sizing::Hug => Some(("HUG", 0.0)),
+        _ => None,
+    }
+}
+
 fn guid(session: u32, local: u32) -> Kv<'static> {
     o(vec![("sessionID", u(session)), ("localID", u(local))])
 }
@@ -1371,7 +1390,7 @@ impl<'d> Exporter<'d> {
             MainAlign::Max => "MAX",
             MainAlign::SpaceBetween => "SPACE_BETWEEN",
             MainAlign::SpaceAround => "SPACE_AROUND",
-            MainAlign::SpaceEvenly => "SPACE_EVENLY",
+            MainAlign::SpaceEvenly => "SPACE_EVENLY_CSS",
         };
         let cross = match l.cross_align {
             CrossAlign::Min => "MIN",
@@ -1415,8 +1434,32 @@ impl<'d> Exporter<'d> {
                 )])
             };
             f.extend([("gridColumnGap", fl(l.gap)), ("gridRowGap", fl(l.cross_gap)), ("gridColumns", map(&cols)), ("gridRows", map(&rows))]);
-            if l.column_tracks.iter().chain(&l.row_tracks).any(|t| t.sizing != Sizing::Fill) {
-                self.warn("grid tracks of fixed or content size were written as equal tracks");
+            // Sizing is keyed by track id like the order map. A track the document doesn't set is
+            // left out, and one the format can't hold keeps its id (the import equalises it).
+            let mut dropped = false;
+            let sizing = |tracks: &[GridTrack], ids: &[u32], dropped: &mut bool| -> Option<Kv<'static>> {
+                let mut entries = Vec::new();
+                for (i, id) in ids.iter().enumerate() {
+                    let Some(track) = tracks.get(i) else { continue };
+                    match grid_track_size(track) {
+                        Some((kind, value)) => {
+                            let size = || o(vec![("type", e(kind)), ("value", fl(value))]);
+                            entries.push(o(vec![("id", guid(AUX, *id)), ("trackSize", o(vec![("minSizing", size()), ("maxSizing", size())]))]));
+                        }
+                        None => *dropped = true,
+                    }
+                }
+                (!entries.is_empty()).then(|| o(vec![("entries", arr(entries))]))
+            };
+            let column_sizing = sizing(&l.column_tracks, &cols, &mut dropped);
+            let row_sizing = sizing(&l.row_tracks, &rows, &mut dropped);
+            if dropped {
+                self.warn("grid tracks whose size the format can't hold were written as equal tracks");
+            }
+            for (name, sizing) in [("gridColumnsSizing", column_sizing), ("gridRowsSizing", row_sizing)] {
+                if let Some(v) = sizing {
+                    f.push((name, v));
+                }
             }
             self.tracks.insert(key, (cols, rows));
         } else {
@@ -1502,7 +1545,6 @@ impl<'d> Exporter<'d> {
             ("textExplicitLayoutVersion", u(1)),
             ("textBidiVersion", u(1)),
             ("textTracking", fl(0.0)),
-            ("textDecorationSkipInk", b(true)),
             ("emojiImageSet", e("APPLE")),
         ]);
         if td.auto_resize == TextAutoResize::Truncate {
@@ -1565,6 +1607,20 @@ impl<'d> Exporter<'d> {
             data.extend([("characterStyleIDs", arr(ids)), ("styleOverrideTable", arr(entries))]);
         }
         let lists: Vec<ListStyle> = (0..td.paragraph_count()).map(|p| td.para_list(p).list).collect();
+        let first = |i: usize, l: &ListStyle| *l != ListStyle::None && (i == 0 || lists.get(i - 1) != Some(l));
+        // Where each line's numbered list starts counting, less one: its first item's start, on
+        // every line of the list.
+        let mut run = 0;
+        let starts: Vec<u32> = lists
+            .iter()
+            .enumerate()
+            .map(|(i, l)| {
+                if first(i, l) {
+                    run = td.para_list(i).start_offset;
+                }
+                if *l == ListStyle::Numbered { run } else { 0 }
+            })
+            .collect();
         // One entry per paragraph, each with every field a reader expects.
         let line = |(i, l): (usize, &ListStyle)| {
             let ty = match l {
@@ -1573,14 +1629,15 @@ impl<'d> Exporter<'d> {
                 ListStyle::Bulleted => "UNORDERED_LIST",
             };
             let listed = *l != ListStyle::None;
-            let first = listed && (i == 0 || lists.get(i - 1) != Some(l));
+            let begins = first(i, l);
+            let start = starts.get(i).copied().unwrap_or(0);
             o(vec![
                 ("lineType", e(ty)),
                 ("styleId", int(0)),
                 ("indentationLevel", int(i64::from(listed))),
                 ("sourceDirectionality", e("AUTO")),
-                ("listStartOffset", int(0)),
-                ("isFirstLineOfList", b(first)),
+                ("listStartOffset", int(i64::from(start))),
+                ("isFirstLineOfList", b(begins)),
             ])
         };
         data.push(("lines", arr(lists.iter().enumerate().map(line).collect())));
@@ -1589,7 +1646,7 @@ impl<'d> Exporter<'d> {
             self.warn("nested list levels were written as the first level");
         }
         let styles = std::iter::once(&td.style).chain(td.runs.iter().map(|r| &r.style));
-        if styles.clone().any(|st| st.decoration_look.is_some() || !st.variations.is_empty()) {
+        if styles.clone().any(|st| unsupported_decoration_look(st) || !st.variations.is_empty()) {
             self.warn("text decoration looks and variable font settings were left out");
         }
         if td.path.is_some() {
@@ -1669,7 +1726,13 @@ impl<'d> Exporter<'d> {
             let segments = net
                 .segments
                 .iter()
-                .map(|sg| network::Segment { a: sg.a, ta: (finite(sg.ta.0), finite(sg.ta.1)), b: sg.b, tb: (finite(sg.tb.0), finite(sg.tb.1)) })
+                .map(|sg| network::Segment {
+                    style: 0,
+                    a: sg.a,
+                    ta: (finite(sg.ta.0), finite(sg.ta.1)),
+                    b: sg.b,
+                    tb: (finite(sg.tb.0), finite(sg.tb.1)),
+                })
                 .collect();
             let regions = net
                 .regions
@@ -1716,7 +1779,7 @@ impl<'d> Exporter<'d> {
         let sp = &n.stroke;
         let (w, h, weight) = (n.width, n.height, sp.weight);
         let plain = n.strokes.iter().any(|p| p.visible) && sp.dashes.is_empty() && sp.sides.is_none() && sp.profile().is_none() && sp.brush.is_none();
-        if !plain || !(weight.is_finite() && weight > 0.0 && w.is_finite() && h.is_finite()) {
+        if !(plain && weight.is_finite() && weight > 0.0 && w.is_finite() && h.is_finite()) {
             return;
         }
         let whole = matches!(n.kind, NodeKind::Ellipse { sweep, inner, .. } if inner == 0.0 && sweep.abs() >= std::f64::consts::TAU - 1e-9);
@@ -1838,12 +1901,13 @@ impl<'d> Exporter<'d> {
         let named = set.is_none_or(|s| s.name != n.name);
         let root_mine: Fields = f.iter().filter(|(k, _)| !OWN.contains(k) && (named || *k != "name")).cloned().collect();
         // Each layer below: its id path, the fields that differ from the main's layer, that layer's
-        // fields, and the component a nested instance was swapped for.
+        // fields, whether its size is its own (a nested instance, a size override) and the
+        // component a nested instance was swapped for.
         struct Row {
             path: Kv<'static>,
             changed: Fields,
             theirs: Fields,
-            nested: bool,
+            sized: bool,
             swap: Option<Kv<'static>>,
         }
         let mut rows: Vec<Row> = Vec::new();
@@ -1871,8 +1935,8 @@ impl<'d> Exporter<'d> {
                 (NodeKind::Instance { component, .. }, _) => self.guid_of(*component),
                 _ => None,
             };
-            let nested = matches!(d.kind, NodeKind::Instance { .. });
-            rows.push(Row { path: o(vec![("guids", arr(guids))]), changed: changed(mine, &theirs), theirs, nested, swap });
+            let sized = matches!(d.kind, NodeKind::Instance { .. }) || d.overrides.contains("size");
+            rows.push(Row { path: o(vec![("guids", arr(guids))]), changed: changed(mine, &theirs), theirs, sized, swap });
         }
         // An instance scaled as a whole (the Scale tool) is `factor` times its main in every length:
         // sizes, places and stroke weights, its own and its layers'. A resized one keeps its weights.
@@ -1907,8 +1971,8 @@ impl<'d> Exporter<'d> {
             let (mut of, mut df): (Fields, Fields) = (vec![("guidPath", r.path.clone())], vec![("guidPath", r.path)]);
             for (k, v) in r.changed {
                 let follows = follows(k, &v, &r.theirs);
-                // A nested instance's size is its own to set.
-                if follows && r.nested && k == "size" {
+                // A nested instance's size is its own to set, as is a size the layer overrides.
+                if follows && r.sized && k == "size" {
                     of.push((k, v.clone()));
                 }
                 if follows { &mut df } else { &mut of }.push((k, v));
@@ -2196,12 +2260,13 @@ fn outlined(n: &Node) -> Option<(Node, String)> {
         NodeKind::Line | NodeKind::Vector { .. } | NodeKind::Ellipse { .. } | NodeKind::Polygon { .. } | NodeKind::Star { .. } | NodeKind::Rectangle
     );
     let shown = |paints: &[Paint]| paints.iter().any(|p| p.visible);
-    if !shape
-        || sp.brush.is_some()
-        || !sp.profile().is_some_and(one_sided)
-        || !(sp.weight.is_finite() && sp.weight > 0.0)
-        || !shown(&n.strokes)
-        || shown(&n.fills)
+    if !(shape
+        && sp.brush.is_none()
+        && sp.profile().is_some_and(one_sided)
+        && sp.weight.is_finite()
+        && sp.weight > 0.0
+        && shown(&n.strokes)
+        && !shown(&n.fills))
     {
         return None;
     }
@@ -2393,6 +2458,13 @@ fn key_codes(key: &str) -> Option<(Vec<i64>, bool)> {
     Some((codes, false))
 }
 
+/// Whether the decoration look has more than skip ink, which the file can't hold.
+fn unsupported_decoration_look(st: &TextStyle) -> bool {
+    let mut look = st.look();
+    look.skip_ink = false;
+    look != Default::default()
+}
+
 /// The text style fields of a layer or of an override table entry.
 fn style_fields(st: &TextStyle, f: &mut Fields) {
     let line_height = match st.line_height {
@@ -2425,6 +2497,9 @@ fn style_fields(st: &TextStyle, f: &mut Fields) {
         ("letterSpacing", letter_spacing),
         ("textCase", e(case)),
         ("textDecoration", e(decoration)),
+        // Skip ink only shows on an underline; other text gets the files' default (on), the value
+        // the import leaves out again.
+        ("textDecorationSkipInk", b(st.look().skip_ink || st.decoration != TextDecoration::Underline)),
     ]);
     if let Some(url) = &st.link {
         f.push(("hyperlink", o(vec![("url", s(url))])));
diff --git a/crates/format/src/fig/export_tests.rs b/crates/format/src/fig/export_tests.rs
index 67215b0c7..ae7da3ed6 100644
--- a/crates/format/src/fig/export_tests.rs
+++ b/crates/format/src/fig/export_tests.rs
@@ -74,7 +74,7 @@ fn paint(r: &mut Lcg, image: &str) -> Paint {
             p.kind
         }
     };
-    Paint { kind, opacity: r.pick(&[1.0, 0.5, 0.25]), visible: r.chance(85), blend: r.pick(&BLENDS) }
+    Paint { kind, opacity: r.pick(&[1.0, 0.5, 0.25]), visible: r.chance(85), blend: r.pick(&BLENDS), color_alpha: false }
 }
 
 fn effect(r: &mut Lcg) -> Effect {
@@ -595,6 +595,17 @@ fn normalize(n: &mut Node, ix: &dyn Fn(NodeId) -> NodeId) {
     n.source = None;
     n.overrides.clear();
     n.constrain_proportions = false;
+    // A text's resize mode is its sizing (the editor keeps them together; generated documents
+    // don't): auto width hugs both axes, auto height its height.
+    if let NodeKind::Text(t) = &n.kind {
+        let cl = &mut n.child_layout;
+        let hug = |s: &mut Sizing| *s = if *s == Sizing::Fixed { Sizing::Hug } else { *s };
+        match t.auto_resize {
+            TextAutoResize::WidthAndHeight => [&mut cl.sizing_h, &mut cl.sizing_v].into_iter().for_each(hug),
+            TextAutoResize::Height => hug(&mut cl.sizing_v),
+            _ => {}
+        }
+    }
     let fold = |ps: &mut Vec<Paint>| {
         for p in ps.iter_mut() {
             if let PaintKind::Solid { color } = &mut p.kind {
@@ -619,9 +630,6 @@ fn normalize(n: &mut Node, ix: &dyn Fn(NodeId) -> NodeId) {
         }
     }
     if let Some(l) = &mut n.layout {
-        if matches!(l.main_align, MainAlign::SpaceAround | MainAlign::SpaceEvenly) {
-            l.main_align = MainAlign::SpaceBetween;
-        }
         // Track counts only matter (and are only written) for grids.
         if l.mode != LayoutMode::Grid {
             let d = AutoLayout::default();
@@ -680,7 +688,7 @@ fn normalize(n: &mut Node, ix: &dyn Fn(NodeId) -> NodeId) {
             for r in &mut td.runs {
                 px(&mut r.style);
             }
-            td.paragraphs = (0..td.paragraph_count()).map(|p| ParaList { list: td.para_list(p).list, indent: 0 }).collect();
+            td.paragraphs = (0..td.paragraph_count()).map(|p| ParaList { indent: 0, ..td.para_list(p) }).collect();
             td.list = ListStyle::None;
         }
         NodeKind::Vector { network } => {
@@ -1014,6 +1022,45 @@ fn junk_documents_never_panic() {
     }
 }
 
+/// Grid track sizes reach the file and come back: fixed px, fractional fill and hug tracks, and a
+/// track the format has no name for leaves an equal track behind instead of failing the write.
+#[test]
+fn grid_track_sizes_round_trip() {
+    let mut doc = Document::new("File");
+    let page = doc.first_page().unwrap();
+    let grid = doc.create(page, NodeKind::Frame, "Grid", 0.0, 0.0, 400.0, 200.0).unwrap();
+    {
+        let node = doc.node_mut(grid).unwrap();
+        node.layout = Some(AutoLayout {
+            mode: LayoutMode::Grid,
+            grid_columns: 3,
+            grid_rows: 2,
+            column_tracks: vec![GridTrack::fixed(120.0), GridTrack::fill(2.0), GridTrack::hug()],
+            row_tracks: vec![GridTrack::fill(1.0), GridTrack::fixed(50.0)],
+            ..AutoLayout::default()
+        });
+    }
+    let (bytes, warnings) = export(&doc, None).unwrap();
+    assert!(warnings.is_empty(), "{warnings:?}");
+    let (back, iw) = import(&bytes, "File").unwrap();
+    assert!(iw.is_empty(), "{iw:?}");
+    let l = back.node(back.pages[0]).and_then(|p| p.children.first()).and_then(|c| back.node(*c)).and_then(|n| n.layout.clone()).unwrap();
+    assert_eq!(l.column_tracks, vec![GridTrack::fixed(120.0), GridTrack::fill(2.0), GridTrack::hug()]);
+    assert_eq!(l.row_tracks, vec![GridTrack::fill(1.0), GridTrack::fixed(50.0)]);
+
+    // A negative fixed track is no size the format can name: the write still succeeds, the track
+    // falls back to an equal one, and the warning says so.
+    let mut odd = doc.clone();
+    if let Some(l) = odd.node_mut(grid).and_then(|n| n.layout.as_mut()) {
+        l.column_tracks[0] = GridTrack::fixed(-5.0);
+    }
+    let (bytes, warnings) = export(&odd, None).unwrap();
+    assert_eq!(warnings, vec!["grid tracks whose size the format can't hold were written as equal tracks".to_string()]);
+    let (back, _) = import(&bytes, "File").unwrap();
+    let l = back.node(back.pages[0]).and_then(|p| p.children.first()).and_then(|c| back.node(*c)).and_then(|n| n.layout.clone()).unwrap();
+    assert_eq!(l.column_tracks[0], GridTrack::fill(1.0), "an unwritable track reads back equal");
+}
+
 /// A frame's own min/max size survives whatever its parent is, not only under auto layout.
 #[test]
 fn frame_size_limits_survive_without_auto_layout_parent() {
diff --git a/crates/format/src/fig/image_filter_tests.rs b/crates/format/src/fig/image_filter_tests.rs
new file mode 100644
index 000000000..3fa50a200
--- /dev/null
+++ b/crates/format/src/fig/image_filter_tests.rs
@@ -0,0 +1,104 @@
+//! Image paint filters read from `.fig` files, on fixtures built in code with the parent module's
+//! helpers.
+
+use super::*;
+
+/// The shared schema plus the image filter containers only these tests use.
+fn image_filter_schema() -> Schema {
+    let text = SCHEMA
+        .replace(
+            "message Paint ",
+            "message FilterColorAdjust float tint, float shadows, float highlights, float detail, float exposure, float vignette, float temperature, float vibrance\n\
+             message PaintFilterMessage float tint, float shadows, float highlights, float detail, float exposure, float vignette, float temperature, float vibrance, float contrast, float brightness, float mystery\n\
+             message Paint ",
+        )
+        .replace("message Paint PaintType type,", "message Paint PaintFilterMessage paintFilter, FilterColorAdjust filterColorAdjust, PaintType type,");
+    Schema::parse(&text).unwrap()
+}
+
+#[test]
+fn image_filters_import_from_current_container_and_skip_ambiguous_data() {
+    let filter = |fields: Vec<(&'static str, Kv<'static>)>| o(fields);
+    let image_paint = |id: u64, name: &'static str, mut extra: Vec<(&'static str, Kv<'static>)>| {
+        let mut paint = vec![("type", e("IMAGE")), ("image", o(vec![("hash", Kv::Bytes(HASH.to_vec()))]))];
+        paint.append(&mut extra);
+        node(id, Some((1, "!")), "RECTANGLE", name, vec![("size", xy(2.0, 1.0)), ("fillPaints", arr(vec![o(paint)]))])
+    };
+    let nodes = vec![
+        node(0, None, "DOCUMENT", "Document", vec![]),
+        node(1, Some((0, "!")), "CANVAS", "Page", vec![]),
+        image_paint(
+            2,
+            "Current",
+            vec![(
+                "paintFilter",
+                filter(vec![
+                    ("exposure", f(0.25)),
+                    ("contrast", f(0.3)),
+                    ("vibrance", f(-0.4)),
+                    ("temperature", f(0.5)),
+                    ("tint", f(1.0)),
+                    ("highlights", f(-0.6)),
+                    ("shadows", f(0.7)),
+                ]),
+            )],
+        ),
+        image_paint(3, "Negative tint", vec![("paintFilter", filter(vec![("tint", f(-1.0)), ("contrast", f(-0.3))]))]),
+        image_paint(4, "Neutral", vec![]),
+        image_paint(5, "Explicit neutral", vec![("paintFilter", filter(vec![("exposure", f(0.0)), ("vibrance", f(0.0))]))]),
+        image_paint(6, "Legacy", vec![("filterColorAdjust", filter(vec![("exposure", f(0.8))]))]),
+        image_paint(7, "Both", vec![("filterColorAdjust", filter(vec![("exposure", f(0.8))])), ("paintFilter", filter(vec![("contrast", f(0.2))]))]),
+        image_paint(
+            8,
+            "Unsupported",
+            vec![("paintFilter", filter(vec![("brightness", f(0.4)), ("detail", f(-0.2)), ("vignette", f(0.3)), ("mystery", f(0.1))]))],
+        ),
+    ];
+    let bytes = zip_file(&canvas(&image_filter_schema(), &o(vec![("nodeChanges", arr(nodes))])));
+    let (doc, warnings) = import(&bytes, "ImageFilters.fig").unwrap();
+    let get = |name: &str| {
+        let node = doc.nodes().find(|node| node.name == name).unwrap();
+        let figcraft_doc::color::PaintKind::Image(image) = &node.fills[0].kind else { panic!("{name} is not an image fill") };
+        image
+    };
+    let current = get("Current");
+    assert!((current.filters.exposure - 0.25).abs() < 1e-6);
+    assert!((current.filters.contrast - 0.3).abs() < 1e-6, "observed raw contrast remains 0.3");
+    assert!((current.filters.saturation + 0.4).abs() < 1e-6, "vibrance maps to saturation");
+    assert!((current.filters.temperature - 0.5).abs() < 1e-6);
+    assert!((current.filters.tint + 1.0).abs() < 1e-6, "a positive (magenta) tint in the file is a negative native tint");
+    assert!((current.filters.highlights + 0.6).abs() < 1e-6);
+    assert!((current.filters.shadows - 0.7).abs() < 1e-6);
+    assert!((get("Negative tint").filters.tint - 1.0).abs() < 1e-6);
+    assert!((get("Negative tint").filters.contrast + 0.3).abs() < 1e-6);
+    assert_eq!(get("Neutral").filters, Default::default());
+    assert_eq!(get("Explicit neutral").filters, Default::default());
+    assert_eq!(doc.images.get(&current.image).map(|image| image.bytes.as_slice()), Some(png().as_slice()));
+    assert!(warnings.iter().any(|w| w.contains("legacy image filter container is unsupported")), "{warnings:?}");
+    assert!(warnings.iter().any(|w| w.contains("both filter containers are present")), "{warnings:?}");
+    for field in ["brightness", "detail", "vignette", "mystery"] {
+        assert!(warnings.iter().any(|w| w.contains(field)), "missing {field} warning: {warnings:?}");
+    }
+    assert_eq!(warnings.iter().filter(|w| w.contains("approximate renderer")).count(), 1, "deduplicated approximation warning: {warnings:?}");
+}
+
+#[test]
+fn warnings_naming_unknown_filter_fields_are_capped() {
+    // A schema can name any number of fields; each nonzero unknown one is a warning of its own.
+    let names: Vec<&'static str> = (0..300).map(|i| &*Box::leak(format!("unknown{i}").into_boxed_str())).collect();
+    let fields: Vec<String> = names.iter().map(|n| format!("float {n}")).collect();
+    let text = SCHEMA
+        .replace("message Paint ", &format!("message ManyFilters {}\nmessage Paint ", fields.join(", ")))
+        .replace("message Paint PaintType type,", "message Paint ManyFilters paintFilter, PaintType type,");
+    let filters = o(names.iter().map(|n| (*n, f(0.5))).collect());
+    let paint = o(vec![("type", e("IMAGE")), ("image", o(vec![("hash", Kv::Bytes(HASH.to_vec()))])), ("paintFilter", filters)]);
+    let nodes = vec![
+        node(0, None, "DOCUMENT", "Document", vec![]),
+        node(1, Some((0, "!")), "CANVAS", "Page", vec![]),
+        node(2, Some((1, "!")), "RECTANGLE", "Photo", vec![("size", xy(2.0, 1.0)), ("fillPaints", arr(vec![paint]))]),
+    ];
+    let bytes = zip_file(&canvas(&Schema::parse(&text).unwrap(), &o(vec![("nodeChanges", arr(nodes))])));
+    let (_, warnings) = import(&bytes, "ManyFilters.fig").unwrap();
+    let named = warnings.iter().filter(|w| w.contains("unsupported image filter")).count();
+    assert!((100..=crate::rest::MAX_WARNINGS).contains(&named), "{named} of {} warnings", warnings.len());
+}
diff --git a/crates/format/src/fig/kiwi.rs b/crates/format/src/fig/kiwi.rs
index 528dbbf06..5c735b280 100644
--- a/crates/format/src/fig/kiwi.rs
+++ b/crates/format/src/fig/kiwi.rs
@@ -10,8 +10,16 @@ use std::fmt;
 
 /// Deepest struct/message nesting decoded.
 const MAX_DEPTH: usize = 64;
-/// Most values decoded from one message (every scalar, array element and field counts).
-const MAX_VALUES: usize = 20_000_000;
+/// Most values decoded from one message (every scalar, array element and field counts): at least
+/// [`MIN_VALUES`], and one per byte of the file's compressed canvas up to [`MAX_VALUES`], so a
+/// large real file decodes while a small one can't expand into a huge tree, however far its
+/// chunks inflate. 32-bit targets (wasm32) have a 4 GB address space in all, so their ceiling is
+/// lower: past it the file is refused cleanly instead of running out of memory.
+const MIN_VALUES: usize = 20_000_000;
+#[cfg(not(target_pointer_width = "32"))]
+const MAX_VALUES: usize = 128 << 20;
+#[cfg(target_pointer_width = "32")]
+const MAX_VALUES: usize = 32 << 20;
 /// Most definitions in a schema, and fields in one definition.
 const MAX_DEFS: usize = 10_000;
 const MAX_FIELDS: usize = 10_000;
@@ -284,13 +292,23 @@ impl Schema {
         self.defs.iter().position(|d| d.name == name)
     }
 
-    /// Decode a message of definition `root`.
+    /// Decode a message of definition `root`, within [`MIN_VALUES`] values.
     pub fn decode_message<'s>(&'s self, root: usize, data: &[u8]) -> Result<Kv<'s>, KiwiError> {
-        let mut d = Decoder { schema: self, r: Reader { data, pos: 0 }, budget: MAX_VALUES };
+        self.decode_message_within(root, data, MIN_VALUES)
+    }
+
+    /// [`Self::decode_message`] within `budget` values (see [`value_budget`]).
+    pub fn decode_message_within<'s>(&'s self, root: usize, data: &[u8], budget: usize) -> Result<Kv<'s>, KiwiError> {
+        let mut d = Decoder { schema: self, r: Reader { data, pos: 0 }, budget };
         d.def(root, 0)
     }
 }
 
+/// Most values decoded from a file whose compressed canvas is `packed` bytes.
+pub(crate) fn value_budget(packed: usize) -> usize {
+    packed.clamp(MIN_VALUES, MAX_VALUES)
+}
+
 struct Decoder<'s, 'b> {
     schema: &'s Schema,
     r: Reader<'b>,
@@ -327,6 +345,8 @@ impl<'s> Decoder<'s, '_> {
                 loop {
                     let id = self.r.var_uint()?;
                     if id == 0 {
+                        // Grown by doubling: trimmed, a large file's tree takes a good part less.
+                        out.shrink_to_fit();
                         return Ok(Kv::Object(out));
                     }
                     let f = d.fields.iter().find(|f| f.value == id).ok_or_else(|| KiwiError(format!("message: {} has no field {id}", d.name)))?;
diff --git a/crates/format/src/fig/map.rs b/crates/format/src/fig/map.rs
index 66a00129f..ec0dd8e46 100644
--- a/crates/format/src/fig/map.rs
+++ b/crates/format/src/fig/map.rs
@@ -6,9 +6,10 @@
 //! are expanded here from the main component (overrides and derived layout matched by id path,
 //! component property values applied) so the import looks as saved.
 
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, BTreeSet, HashMap};
 use std::rc::Rc;
 
+use figcraft_doc::VectorNetwork;
 use figcraft_doc::geom::{Affine, Point};
 use figcraft_doc::proto::{MAX_ACTION_DEPTH, MAX_EXPR_DEPTH};
 use serde_json::{Map, Value, json};
@@ -18,21 +19,29 @@ use super::network;
 
 type Obj = Map<String, Value>;
 
-/// Most layers produced (instance expansion included) and deepest nesting followed.
-const MAX_NODES: usize = crate::rest::MAX_NODES;
+/// Deepest nesting followed.
 const MAX_DEPTH: usize = 256;
 /// Most path commands read from one geometry blob.
 const MAX_COMMANDS: usize = 200_000;
+const MAX_GRID_TRACKS: usize = 1_000;
+pub(super) const MAX_GRID_TRACK_VALUE: f64 = 1e6;
 /// Id of "no style".
 const NO_STYLE: &str = "4294967295:4294967295";
 /// Longest asset `key` or `version` kept for resolving references given as assets.
 const MAX_ASSET_PART: usize = 256;
 
-/// The REST API file JSON for message `msg`, with the warnings about what was skipped.
-pub(super) fn to_rest(msg: &Kv, name: &str) -> (Value, Vec<String>) {
-    let mut m = Mapper::new(msg);
+/// The REST API file JSON for message `msg`, with the warnings about what was skipped and the
+/// vector networks its layers name by `vectorNetworkRef` (for [`crate::rest::import_with_networks`]).
+pub(super) fn to_rest(msg: &Kv, name: &str, max_nodes: usize) -> (Value, Vec<String>, Vec<Option<VectorNetwork>>) {
+    let mut m = Mapper::new(msg, max_nodes);
     let doc = m.document();
-    let mut out = json!({"name": name, "document": doc});
+    // Large values are moved in, never passed through `json!`, which serialises its arguments:
+    // a deep copy of the whole tree, briefly holding it twice.
+    let mut out = json!({"name": name});
+    out["document"] = doc;
+    if !m.library_contexts.is_empty() {
+        out[crate::rest::FIG_LIBRARY_CONTEXTS_FIELD] = Value::Array(std::mem::take(&mut m.library_contexts));
+    }
     if !m.styles.is_empty() {
         out["styles"] = Value::Object(std::mem::take(&mut m.styles));
     }
@@ -49,9 +58,13 @@ pub(super) fn to_rest(msg: &Kv, name: &str) -> (Value, Vec<String>) {
     if !styles.is_empty() {
         out["styleDefinitions"] = Value::Array(styles);
     }
-    (out, m.warnings)
+    (out, m.warnings, m.networks)
 }
 
+#[cfg(test)]
+#[path = "map_image_filter_tests.rs"]
+mod image_filter_tests;
+
 /// REST importer warnings reworded for a `.fig` import (`None`: drop it).
 pub(super) fn adapt_warning(w: String) -> Option<String> {
     if w.contains("geometry=paths") {
@@ -70,15 +83,51 @@ fn num(n: &Kv, k: &str) -> Option<f64> {
     n.get(k).and_then(Kv::f64)
 }
 
+fn filter_number(value: &Kv) -> Option<f64> {
+    let number = match value {
+        Kv::Float(value) => f64::from(*value),
+        Kv::Int(value) => *value as f64,
+        Kv::Uint(value) => *value as f64,
+        _ => return None,
+    };
+    number.is_finite().then_some(number)
+}
+
 fn guid(v: &Kv) -> Option<String> {
     Some(format!("{}:{}", num(v, "sessionID")? as u64, num(v, "localID")? as u64))
 }
 
+/// An override row names a layer of the main by its current GUID or by the `overrideKey` the
+/// layer had when the row was written: the key becomes the current GUID, unless the layer is
+/// current already or the key is ambiguous.
+fn normalize_override_segment(path: &mut [String], index: usize, scope: &OverrideScope) {
+    let Some(segment) = path.get(index) else { return };
+    if scope.current.contains(segment) {
+        return;
+    }
+    if let Some(Some(current)) = scope.aliases.get(segment) {
+        path[index] = current.clone();
+    }
+}
+
+#[cfg(test)]
+#[path = "map_connector_snapshot_budget_tests.rs"]
+mod connector_snapshot_budget_tests;
+
 /// A `GUID`-holding reference (`StyleId`, `VariableID`, …): its `guid`.
 fn ref_guid(v: &Kv) -> Option<String> {
     v.get("guid").and_then(guid).filter(|g| g != NO_STYLE)
 }
 
+/// The style a layer links in `key`, or in the older `legacy` field when `key` names none. An
+/// explicit NO_STYLE in `key` is a detach and wins over the legacy field.
+fn style_link(v: &View, key: &str, legacy: &str) -> Option<String> {
+    match v.get(key).and_then(|r| r.get("guid")).and_then(guid) {
+        Some(id) => Some(id).filter(|g| g != NO_STYLE),
+        None => v.get(legacy).and_then(guid).filter(|g| g != NO_STYLE),
+    }
+}
+
 fn color(c: &Kv) -> Value {
     let ch = |k: &str| num(c, k).unwrap_or(0.0);
     json!({"r": ch("r"), "g": ch("g"), "b": ch("b"), "a": num(c, "a").unwrap_or(1.0)})
@@ -115,6 +164,41 @@ fn copy_str(o: &mut Obj, n: &View, from: &str, to: &str) {
     }
 }
 
+/// The value from the last override layer holding a valid one for an optional text setting; invalid instance rows fall through.
+fn text_num(v: &View, key: &str) -> Option<f64> {
+    v.layers.iter().rev().find_map(|layer| {
+        layer.get(key).and_then(|value| match value {
+            Kv::Bool(_) => None,
+            _ => value.f64(),
+        })
+    })
+}
+
+fn text_flag(v: &View, key: &str) -> Option<bool> {
+    v.layers.iter().rev().find_map(|layer| layer.get(key).and_then(Kv::bool))
+}
+
+fn insert_text_options(style: &mut Obj, v: &View) {
+    if let Some(value) = text_num(v, "listSpacing") {
+        style.insert("listSpacing".into(), json!(value));
+    }
+    for k in ["hangingList", "hangingPunctuation"] {
+        if let Some(value) = text_flag(v, k) {
+            style.insert(k.into(), json!(value));
+        }
+    }
+    if let Some(value) = leading_trim(v) {
+        style.insert("leadingTrim".into(), json!(value));
+    }
+}
+
+fn leading_trim<'a>(v: &View<'a>) -> Option<&'a str> {
+    v.layers.iter().rev().find_map(|layer| match layer.get("leadingTrim").and_then(Kv::str) {
+        Some(value @ ("NONE" | "CAP_HEIGHT")) => Some(value),
+        _ => None,
+    })
+}
+
 /// A node seen through override layers: the last layer with a field wins.
 #[derive(Clone)]
 struct View<'a> {
@@ -142,6 +226,16 @@ impl<'a> View<'a> {
         v
     }
 
+    /// This view with `style` just above the node itself: the style beats the node's own copy of
+    /// its fields (stale when the style changed since), and override rows beat both.
+    fn styled(&self, style: Option<&'a Kv<'a>>) -> Self {
+        let mut v = self.clone();
+        if let Some(s) = style {
+            v.layers.insert(v.layers.len().min(1), s);
+        }
+        v
+    }
+
     fn get(&self, k: &str) -> Option<&'a Kv<'a>> {
         self.layers.iter().rev().find_map(|l| l.get(k))
     }
@@ -221,7 +315,7 @@ impl Fit {
 }
 
 /// Overrides and derived layout by id path.
-type Overrides<'a> = BTreeMap<Vec<String>, Vec<(Entry, &'a Kv<'a>)>>;
+type Overrides<'a> = BTreeMap<Vec<String>, Vec<OverrideRow<'a>>>;
 
 /// Where an override entry comes from.
 #[derive(Clone, Copy, PartialEq)]
@@ -233,6 +327,25 @@ enum Entry {
     Stale,
 }
 
+/// One override or derived-layout row addressed to a layer.
+#[derive(Clone)]
+struct OverrideRow<'a> {
+    row: &'a Kv<'a>,
+    entry: Entry,
+    /// How many mains are being expanded around the instance that wrote the row: the rows of
+    /// the enclosing (outer) instances win over those of the inner ones.
+    source_depth: usize,
+    /// Position among the rows of the instance that wrote it; later rows win.
+    ordinal: usize,
+}
+
+/// The layers of a main by current GUID, and the old `overrideKey` of each that has one
+/// (`None` when two layers claim the same key).
+struct OverrideScope {
+    current: BTreeSet<String>,
+    aliases: BTreeMap<String, Option<String>>,
+}
+
 /// Where an instance's expanded layers are: the overrides and derived layout of the outermost
 /// instance (by id path), the path of the instance being expanded, and the property values.
 #[derive(Clone)]
@@ -241,6 +354,10 @@ struct Inst<'a> {
     path: Vec<String>,
     overrides: Rc<Overrides<'a>>,
     props: Rc<BTreeMap<String, &'a Kv<'a>>>,
+    /// Slot property GUID → private slot-content node GUID.
+    slot_contents: Rc<BTreeMap<String, String>>,
+    /// Layers imported from a slot's independent content subtree.
+    slot_content: bool,
     /// Mains being expanded (an instance inside its own main stops there).
     symbols: Vec<String>,
 }
@@ -251,6 +368,9 @@ struct Mapper<'a> {
     blobs: Vec<&'a [u8]>,
     /// Component property definitions: id → (REST name "Name#id", type).
     prop_defs: BTreeMap<String, (String, &'a str)>,
+    /// The copies of a set's definitions each variant keeps (no name or type of their own; the
+    /// variant's layers and its instances' assignments use them): copy id → the definition's id.
+    prop_parents: BTreeMap<String, String>,
     /// File nodes by asset `key` and `version`: references can name a collection, variable or
     /// style as the asset instead of the guid, and the file carries the resources to resolve
     /// them (the collection node itself says the same `key`).
@@ -259,18 +379,46 @@ struct Mapper<'a> {
     /// Descriptions of components and component sets (REST `components` / `componentSets`).
     components: Obj,
     sets: Obj,
+    /// Layers and keys of each main, built when an instance of it first needs them.
+    override_scopes: BTreeMap<String, Rc<OverrideScope>>,
+    /// Entries held by `override_scopes` (bounded by `max_nodes` together).
+    override_scope_entries: usize,
+    /// Component-bearing branches of the file's internal canvases (cached library definitions).
+    library_contexts: Vec<Value>,
+    /// Layers visited while scanning internal canvases, across all of them.
+    library_scan_count: usize,
     warnings: Vec<String>,
     count: usize,
+    /// Most layers produced or scanned, instance expansion included; the one place the cap comes
+    /// from (see [`super::layer_budget`]).
+    max_nodes: usize,
+    /// Vector networks, each built once: the layers that show one (every instance of a main
+    /// holding it) name it by `vectorNetworkRef`. Kept out of the JSON, where a large file's
+    /// networks took gigabytes.
+    networks: Vec<Option<VectorNetwork>>,
+    /// Index in `networks` by what a network is made from: its blob, its scale and its style table.
+    network_ids: HashMap<(usize, u64, u64, usize), usize>,
 }
 
 impl<'a> Mapper<'a> {
-    fn new(msg: &'a Kv<'a>) -> Self {
+    fn new(msg: &'a Kv<'a>, max_nodes: usize) -> Self {
         let mut nodes = BTreeMap::new();
         let mut kids: BTreeMap<String, Vec<(&'a str, String)>> = BTreeMap::new();
         let mut prop_defs = BTreeMap::new();
-        for n in msg.get("nodeChanges").map(Kv::list).unwrap_or_default() {
+        let mut prop_parents = BTreeMap::new();
+        let changes = msg.get("nodeChanges").map(Kv::list).unwrap_or_default();
+        // The last change of a GUID wins; a REMOVED change deletes what came before it.
+        for n in changes {
             let Some(id) = n.get("guid").and_then(guid) else { continue };
             if n.get("phase").and_then(Kv::str) == Some("REMOVED") {
+                nodes.remove(&id);
+            } else {
+                nodes.insert(id, n);
+            }
+        }
+        for n in changes {
+            let Some(id) = n.get("guid").and_then(guid) else { continue };
+            if !nodes.get(&id).is_some_and(|latest| std::ptr::eq(*latest, n)) {
                 continue;
             }
             if let Some(p) = n.get("parentIndex")
@@ -279,13 +427,13 @@ impl<'a> Mapper<'a> {
                 kids.entry(parent).or_default().push((p.get("position").and_then(Kv::str).unwrap_or(""), id.clone()));
             }
             for d in n.get("componentPropDefs").map(Kv::list).unwrap_or_default() {
-                if let (Some(did), Some(name), Some(ty)) =
-                    (d.get("id").and_then(guid), d.get("name").and_then(Kv::str), d.get("type").and_then(Kv::str))
-                {
+                let Some(did) = d.get("id").and_then(guid) else { continue };
+                if let (Some(name), Some(ty)) = (d.get("name").and_then(Kv::str), d.get("type").and_then(Kv::str)) {
                     prop_defs.insert(did.clone(), (format!("{name}#{did}"), ty));
+                } else if let Some(parent) = d.get("parentPropDefId").and_then(guid) {
+                    prop_parents.insert(did, parent);
                 }
             }
-            nodes.insert(id, n);
         }
         for list in kids.values_mut() {
             list.sort();
@@ -302,7 +450,26 @@ impl<'a> Mapper<'a> {
             let version = n.get("version").and_then(Kv::str).filter(|v| !v.is_empty() && v.len() <= MAX_ASSET_PART).unwrap_or("");
             assets.entry(key.to_string()).or_default().entry(version.to_string()).or_insert(id);
         }
-        Self { nodes, kids, blobs, prop_defs, assets, styles: Obj::new(), components: Obj::new(), sets: Obj::new(), warnings: Vec::new(), count: 0 }
+        Self {
+            nodes,
+            kids,
+            blobs,
+            prop_defs,
+            prop_parents,
+            assets,
+            styles: Obj::new(),
+            components: Obj::new(),
+            sets: Obj::new(),
+            override_scopes: BTreeMap::new(),
+            override_scope_entries: 0,
+            library_contexts: Vec::new(),
+            library_scan_count: 0,
+            warnings: Vec::new(),
+            count: 0,
+            max_nodes,
+            networks: Vec::new(),
+            network_ids: HashMap::new(),
+        }
     }
 
     /// The id of the resource a `VariableSetID` (or `VariableID`, `StyleId`) names: its `guid`,
@@ -328,7 +495,8 @@ impl<'a> Mapper<'a> {
 
     fn warn(&mut self, w: impl Into<String>) {
         let w = w.into();
-        if !self.warnings.contains(&w) {
+        // Capped like the REST importer's list: some warnings name fields of the file (image filters).
+        if self.warnings.len() < crate::rest::MAX_WARNINGS && !self.warnings.contains(&w) {
             self.warnings.push(w);
         }
     }
@@ -337,6 +505,50 @@ impl<'a> Mapper<'a> {
         self.kids.get(id).map(|k| k.iter().map(|(_, c)| c.clone()).collect()).unwrap_or_default()
     }
 
+    /// The layers of main `main` by current GUID and by `overrideKey`. An instance nested in the
+    /// main is not entered: its layers belong to another main.
+    fn override_scope(&mut self, main: &str) -> Rc<OverrideScope> {
+        if let Some(scope) = self.override_scopes.get(main) {
+            return Rc::clone(scope);
+        }
+        let mut current = BTreeSet::new();
+        let mut aliases: BTreeMap<String, Option<String>> = BTreeMap::new();
+        let mut visited = BTreeSet::new();
+        let mut pending: Vec<(String, usize)> = self.children(main).into_iter().map(|id| (id, 1)).collect();
+        let mut complete = true;
+        while let Some((id, depth)) = pending.pop() {
+            if depth > MAX_DEPTH || visited.len() >= self.max_nodes {
+                complete = false;
+                break;
+            }
+            if !visited.insert(id.clone()) {
+                continue;
+            }
+            let Some(node) = self.nodes.get(&id) else { continue };
+            current.insert(id.clone());
+            if let Some(alias) = node.get("overrideKey").and_then(guid) {
+                let target = aliases.entry(alias).or_insert_with(|| Some(id.clone()));
+                if target.as_deref().is_some_and(|target| target != id) {
+                    *target = None;
+                }
+            }
+            if node.get("type").and_then(Kv::str) != Some("INSTANCE") {
+                pending.extend(self.children(&id).into_iter().map(|child| (child, depth + 1)));
+            }
+        }
+        // A scope cut short could name the wrong layer for a key: use none of the keys.
+        if !complete {
+            aliases.clear();
+        }
+        let scope = Rc::new(OverrideScope { current, aliases });
+        let cost = scope.current.len() + scope.aliases.len();
+        if cost <= self.max_nodes.saturating_sub(self.override_scope_entries) {
+            self.override_scope_entries += cost;
+            self.override_scopes.insert(main.to_string(), Rc::clone(&scope));
+        }
+        scope
+    }
+
     /// The DOCUMENT with its pages.
     fn document(&mut self) -> Value {
         let doc_id = self.nodes.iter().find(|(_, n)| n.get("type").and_then(Kv::str) == Some("DOCUMENT")).map(|(id, _)| id.clone());
@@ -345,6 +557,8 @@ impl<'a> Mapper<'a> {
             None => self.nodes.iter().filter(|(_, n)| n.get("type").and_then(Kv::str) == Some("CANVAS")).map(|(id, _)| id.clone()).collect(),
         };
         let mut out = Vec::new();
+        let mut internal = Vec::new();
+        let mut visible_pages = Vec::new();
         for p in pages {
             let Some(&n) = self.nodes.get(&p) else { continue };
             if n.get("type").and_then(Kv::str) != Some("CANVAS") {
@@ -353,14 +567,195 @@ impl<'a> Mapper<'a> {
             }
             // The hidden page that holds styles, variables and library copies.
             if n.get("internalOnly").and_then(Kv::bool) == Some(true) {
+                internal.push((p, n));
                 continue;
             }
+            visible_pages.push(p.clone());
             out.push(self.page(&p, n));
         }
+        let required_mains = self.referenced_component_mains(&visible_pages);
+        for (id, canvas) in internal {
+            if let Some(context) = self.library_context(&id, canvas, &required_mains) {
+                self.library_contexts.push(context);
+            }
+        }
         if out.is_empty() {
             self.warn("the file has no pages");
         }
-        json!({"id": doc_id.unwrap_or_else(|| "0:0".into()), "type": "DOCUMENT", "children": out})
+        let mut doc = json!({"id": doc_id.unwrap_or_else(|| "0:0".into()), "type": "DOCUMENT"});
+        doc["children"] = Value::Array(out);
+        doc
+    }
+
+    /// The ids of the components the visible pages use, directly or through the components they
+    /// use in turn (nested instances, swap targets, overrides naming another main).
+    fn referenced_component_mains(&mut self, visible_pages: &[String]) -> BTreeSet<String> {
+        let mut mains = BTreeSet::new();
+        let mut visited = BTreeSet::new();
+        let mut pending: Vec<(String, usize)> = visible_pages.iter().flat_map(|page| self.children(page)).map(|id| (id, 1)).collect();
+        while let Some((id, depth)) = pending.pop() {
+            if depth > MAX_DEPTH {
+                self.warn(format!("component references below {MAX_DEPTH} layer levels were skipped"));
+                continue;
+            }
+            if !visited.insert(id.clone()) {
+                continue;
+            }
+            if visited.len() > self.max_nodes {
+                let max = self.max_nodes;
+                self.warn(format!("the component reference scan reached the {max}-layer limit"));
+                break;
+            }
+            let Some(node) = self.nodes.get(&id) else { continue };
+            for target in self.component_main_targets(node) {
+                if mains.insert(target.clone()) {
+                    pending.push((target, 1));
+                }
+            }
+            pending.extend(self.children(&id).into_iter().map(|child| (child, depth + 1)));
+        }
+        mains
+    }
+
+    /// The mains a layer names: an instance's own, the ones its overrides swap in, the instance-swap
+    /// defaults and values of component properties.
+    fn component_main_targets(&self, node: &Kv<'a>) -> Vec<String> {
+        let mut targets: Vec<String> = node
+            .get("componentPropDefs")
+            .map(Kv::list)
+            .unwrap_or_default()
+            .iter()
+            .filter_map(|definition| {
+                self.is_instance_swap(definition.get("id")?)?;
+                definition.get("initialValue")?.get("guidValue").and_then(guid)
+            })
+            .collect();
+        if node.get("type").and_then(Kv::str) != Some("INSTANCE") {
+            return targets;
+        }
+        // The instance and the override rows below it (rows carry the same fields, nested).
+        let mut pending: Vec<(&Kv<'a>, usize)> = vec![(node, 0)];
+        let mut rows = 0usize;
+        while let Some((row, depth)) = pending.pop() {
+            rows += 1;
+            if depth > MAX_DEPTH || rows > self.max_nodes {
+                break;
+            }
+            let data = row.get("symbolData");
+            targets.extend(row.get("overriddenSymbolID").and_then(guid));
+            targets.extend(data.and_then(|d| d.get("symbolID")).and_then(guid));
+            for assignment in row.get("componentPropAssignments").map(Kv::list).unwrap_or_default() {
+                if assignment.get("defID").is_some_and(|def| self.is_instance_swap(def).is_some()) {
+                    targets.extend(assigned(assignment).and_then(prop_guid));
+                }
+            }
+            let overrides = data.and_then(|d| d.get("symbolOverrides")).map(Kv::list).unwrap_or_default();
+            let derived = row.get("derivedSymbolData").map(Kv::list).unwrap_or_default();
+            pending.extend(overrides.iter().chain(derived).map(|row| (row, depth + 1)));
+        }
+        targets
+    }
+
+    fn is_instance_swap(&self, def: &Kv) -> Option<()> {
+        matches!(self.prop_def(&guid(def)?), Some((_, "INSTANCE_SWAP"))).then_some(())
+    }
+
+    /// The definition a copy of it was made from, followed to the original: the values an instance
+    /// sets are kept under it, since an assignment and the layers that read it may name different
+    /// copies of one definition.
+    fn prop_root(&self, def: &str) -> String {
+        let mut def = def;
+        for _ in 0..=MAX_DEPTH {
+            let Some(parent) = self.prop_parents.get(def) else { break };
+            def = parent;
+        }
+        def.to_string()
+    }
+
+    /// The definition `def` names: its own, or the set's for a variant's copy of it.
+    fn prop_def(&self, def: &str) -> Option<&(String, &'a str)> {
+        let mut def = def;
+        for _ in 0..=MAX_DEPTH {
+            if let Some(found) = self.prop_defs.get(def) {
+                return Some(found);
+            }
+            def = self.prop_parents.get(def)?;
+        }
+        None
+    }
+
+    /// The branches of the internal canvas `id` that hold the `required_mains` (with the frames
+    /// they sit in), as a frame of its own: the cached definitions of components that come from a
+    /// library. `None` when it holds none.
+    fn library_context(&mut self, id: &str, canvas: &'a Kv<'a>, required_mains: &BTreeSet<String>) -> Option<Value> {
+        let mut included = BTreeSet::new();
+        let mut parents: BTreeMap<String, String> = BTreeMap::new();
+        // The canvas itself is never a layer of the walk, whatever the parent links say.
+        let mut visited = BTreeSet::from([id.to_string()]);
+        // Each entry: layer, depth, inside a required definition.
+        let mut pending: Vec<(String, usize, bool)> = self.children(id).into_iter().map(|child| (child, 1, false)).collect();
+        while let Some((node_id, depth, in_definition)) = pending.pop() {
+            if depth > MAX_DEPTH {
+                self.warn(format!("internal library branches deeper than {MAX_DEPTH} levels were skipped"));
+                continue;
+            }
+            if !visited.insert(node_id.clone()) {
+                continue;
+            }
+            self.library_scan_count += 1;
+            if self.library_scan_count > self.max_nodes {
+                let max = self.max_nodes;
+                self.warn(format!("the internal library scan reached the {max}-layer limit; the remaining branches were skipped"));
+                break;
+            }
+            let Some(node) = self.nodes.get(&node_id) else { continue };
+            let kind = node.get("type").and_then(Kv::str);
+            let definition = (kind == Some("SYMBOL") || (kind == Some("FRAME") && node.get("isStateGroup").and_then(Kv::bool) == Some(true)))
+                && required_mains.contains(&node_id);
+            let in_definition = in_definition || definition;
+            if in_definition {
+                included.insert(node_id.clone());
+            }
+            if definition {
+                // The frames around it keep the path its layers are addressed by.
+                let mut ancestor = parents.get(&node_id);
+                for _ in 0..=MAX_DEPTH {
+                    let Some(parent) = ancestor else { break };
+                    if !included.insert(parent.clone()) {
+                        break;
+                    }
+                    ancestor = parents.get(parent);
+                }
+            }
+            for child in self.children(&node_id).into_iter().rev() {
+                // A layer reached again keeps the parent it was first reached by, so the parents
+                // lead back to the canvas.
+                if visited.contains(&child) {
+                    continue;
+                }
+                parents.entry(child.clone()).or_insert_with(|| node_id.clone());
+                pending.push((child, depth + 1, in_definition));
+            }
+        }
+        if included.is_empty() {
+            return None;
+        }
+        let mut context = Obj::new();
+        context.insert("id".into(), json!(id));
+        context.insert("type".into(), json!("FRAME"));
+        copy_str(&mut context, &View::of(canvas), "name", "name");
+        context.insert("size".into(), json!({"x": 0.0, "y": 0.0}));
+        context.insert("relativeTransform".into(), rows(Affine::IDENTITY));
+        context.insert(crate::rest::FIG_SOURCE_FIELD.into(), json!({"origin": id, "expanded": false, "wireFrame": true, "wireInstance": false}));
+        self.variable_bindings(&mut context, &View::of(canvas));
+        let mut children = Vec::new();
+        for child in self.children(id) {
+            children.extend(self.layer_filtered(&child, None, Affine::IDENTITY, None, None, 0, Some(&included)));
+        }
+        if !children.is_empty() {
+            context.insert("children".into(), Value::Array(children));
+        }
+        Some(Value::Object(context))
     }
 
     fn page(&mut self, id: &str, n: &'a Kv<'a>) -> Value {
@@ -405,34 +800,53 @@ impl<'a> Mapper<'a> {
         fit: Option<Fit>,
         depth: usize,
     ) -> Option<Value> {
+        self.layer_filtered(id, inst, space, parent, fit, depth, None)
+    }
+
+    /// [`Self::layer`], keeping only the layers in `included` (all when `None`) below the
+    /// top-level one: the cached library definitions of an internal canvas.
+    fn layer_filtered(
+        &mut self,
+        id: &str,
+        inst: Option<&Inst<'a>>,
+        space: Affine,
+        parent: Option<&View<'a>>,
+        fit: Option<Fit>,
+        depth: usize,
+        included: Option<&BTreeSet<String>>,
+    ) -> Option<Value> {
+        if included.is_some_and(|ids| !ids.contains(id)) {
+            return None;
+        }
         if depth > MAX_DEPTH {
             self.warn(format!("layers nested deeper than {MAX_DEPTH} levels were skipped"));
             return None;
         }
-        if self.count >= MAX_NODES {
-            self.warn(format!("the file has more than {MAX_NODES} layers; the rest were skipped"));
+        if self.count >= self.max_nodes {
+            let max = self.max_nodes;
+            self.warn(format!("the file has more than {max} layers; the rest were skipped"));
             return None;
         }
         let base = *self.nodes.get(id)?;
         let path = inst.map(|i| [i.path.as_slice(), &[id.to_string()]].concat());
-        let entries = match (inst, &path) {
+        let entries: &[OverrideRow<'a>] = match (inst, &path) {
             (Some(i), Some(p)) => i.overrides.get(p).map(Vec::as_slice).unwrap_or_default(),
             _ => &[],
         };
-        let mut view = View::of(base).with(entries.iter().map(|e| e.1));
+        let mut view = View::of(base).with(entries.iter().map(|e| e.row));
         // A layer of a resized instance the file gives no derived layout for follows its
         // constraints from the main's geometry, then takes the size and place overridden on it
         // (auto layout places the others, as in the editor).
-        let derived = entries.iter().any(|(d, l)| *d == Entry::Derived && (l.get("size").is_some() || l.get("transform").is_some()));
+        let derived = entries.iter().any(|e| e.entry == Entry::Derived && (e.row.get("size").is_some() || e.row.get("transform").is_some()));
         let stacked = parent.and_then(|p| p.str("stackMode")).is_some_and(|m| matches!(m, "HORIZONTAL" | "VERTICAL" | "GRID"))
             && view.str("stackPositioning") != Some("ABSOLUTE");
         let main = View::of(base);
-        let set = |k: &str| entries.iter().rev().filter(|e| e.0 != Entry::Stale).find_map(|(_, l)| l.get(k));
+        let set = |k: &str| entries.iter().rev().filter(|e| e.entry != Entry::Stale).find_map(|e| e.row.get(k));
         if let (Some(f), false, false, Some((w, h))) = (fit, derived, stacked, main.size()) {
             let t = main.transform().unwrap_or_default();
             let (fw, ft) = f.apply(w, h, t, view.str("horizontalConstraint"), view.str("verticalConstraint"));
             view.fitted = Some((set("size").and_then(size).unwrap_or(fw), set("transform").and_then(matrix).unwrap_or(ft)));
-        } else if entries.iter().any(|(d, l)| *d == Entry::Stale && (l.get("size").is_some() || l.get("transform").is_some()))
+        } else if entries.iter().any(|e| e.entry == Entry::Stale && (e.row.get("size").is_some() || e.row.get("transform").is_some()))
             && let Some(s) = set("size").and_then(size).or_else(|| main.size())
         {
             view.fitted = Some((s, set("transform").and_then(matrix).or_else(|| main.transform()).unwrap_or_default()));
@@ -442,26 +856,54 @@ impl<'a> Mapper<'a> {
             _ => id.to_string(),
         };
         let own = view.str("type").unwrap_or("");
-        let stand = stand_in(own);
+        let connector_snapshot = own == "CONNECTOR" && self.connector_snapshot_supported(&view);
+        // Only a connector with a saved label needs the frame wrapper; an unlabelled one stays a single vector.
+        let connector_terminal =
+            connector_snapshot && (!connector_has_saved_label(&view) || depth >= MAX_DEPTH || self.count.saturating_add(1) >= self.max_nodes);
+        // A supported connector snapshot has its own note below instead of the generic stand-in one.
+        let stand = stand_in(own).filter(|_| !connector_snapshot);
         let ty = match own {
             "ROUNDED_RECTANGLE" => "RECTANGLE",
             "SYMBOL" => "COMPONENT",
             "FRAME" if view.flag("isStateGroup") == Some(true) => "COMPONENT_SET",
             "FRAME" if view.flag("resizeToFit") == Some(true) => "GROUP",
             "VARIABLE" | "VARIABLE_SET" => return None,
+            "CONNECTOR" if connector_snapshot && connector_terminal => "VECTOR",
+            "CONNECTOR" if connector_snapshot => "FRAME",
             t => stand.map_or(t, |s| s.0),
         };
-        if let Some((_, what)) = stand {
+        if let Some((_, what)) = stand.filter(|_| own != "TEXT_PATH") {
             self.warn(format!("{} layers import as {what}", own.to_ascii_lowercase().replace('_', " ")));
         }
+        if connector_snapshot {
+            self.warn("connector layers import as static frame/vector snapshots with labels when present; live endpoint bindings are not retained");
+        }
         self.count += 1;
         let mut o = Obj::new();
         o.insert("id".into(), json!(rest_id));
+        // Private provenance for the .fig importer; ordinary REST import ignores it.
+        o.insert(
+            crate::rest::FIG_SOURCE_FIELD.into(),
+            json!({
+                "origin": id,
+                "expanded": inst.is_some(),
+                "wireFrame": own == "FRAME",
+                "wireInstance": own == "INSTANCE",
+                "slotContent": inst.is_some_and(|i| i.slot_content),
+                // A size the instance gives this layer itself (kept when the instance relays out).
+                "sizeOverride": entries.iter().any(|e| e.entry == Entry::Override && e.row.get("size").is_some()),
+            }),
+        );
         o.insert("type".into(), json!(ty));
         copy_str(&mut o, &view, "name", "name");
         self.common(&mut o, &view, ty, space, parent);
         match ty {
-            "TEXT" => self.text(&mut o, &view),
+            "TEXT" => {
+                self.text(&mut o, &view);
+                if own == "TEXT_PATH" {
+                    self.text_path(&mut o, &view);
+                }
+            }
             "VECTOR" | "STAR" | "REGULAR_POLYGON" => self.geometry(&mut o, &view),
             "ELLIPSE" => {
                 if let Some(a) = view.get("arcData") {
@@ -477,23 +919,64 @@ impl<'a> Mapper<'a> {
             }
             _ => {}
         }
-        if own == "CONNECTOR" {
+        if own == "CONNECTOR" && connector_snapshot {
+            if connector_terminal {
+                self.connector_snapshot_flatten(&mut o, &view, &rest_id, space);
+            } else {
+                o.insert("fills".into(), json!([]));
+                o.insert("strokes".into(), json!([]));
+                for key in ["styles", "strokeWeight", "strokeAlign", "strokeJoin", "strokeDashes", "strokeCap"] {
+                    o.remove(key);
+                }
+                o.insert("clipsContent".into(), json!(false));
+            }
+        } else if own == "CONNECTOR" {
             self.connector(&mut o, &view, space);
         }
         if ty == "COMPONENT" || ty == "COMPONENT_SET" {
             self.component(&mut o, &view, &rest_id);
         }
         self.prop_refs(&mut o, &view, inst);
+        let slot_content = if own == "FRAME" {
+            prop_ref(&view, "SLOT_CONTENT_ID").and_then(|def| inst.and_then(|i| i.slot_contents.get(&self.prop_root(&def)).cloned()))
+        } else {
+            None
+        };
+        if slot_content.is_some()
+            && let Some(source) = o.get_mut(crate::rest::FIG_SOURCE_FIELD).and_then(Value::as_object_mut)
+        {
+            source.insert("slotOverride".into(), json!(true));
+        }
         let child_space = if matches!(ty, "GROUP" | "BOOLEAN_OPERATION") { space * view.transform().unwrap_or_default() } else { Affine::IDENTITY };
-        let mut kids = Vec::new();
-        if ty == "INSTANCE" {
+        let mut kids = if connector_snapshot && !connector_terminal { self.connector_snapshot_children(&view, &rest_id) } else { Vec::new() };
+        if connector_terminal {
+            // The saved vector is flattened into the connector node when no child slot remains.
+        } else if ty == "INSTANCE" {
             if let Some((sub, sym)) = self.instance(&mut o, &view, id, inst, &rest_id) {
                 let main = self.nodes.get(&sym).map(|m| View::of(m));
-                let fit = Fit::frame(main.and_then(|m| m.size()), view.size());
+                let fit = Fit::frame(main.as_ref().and_then(View::size), view.size());
+                // An instance that records no auto layout of its own has its main's.
+                let view = match main {
+                    Some(m) if view.get("stackMode").is_none() && m.get("stackMode").is_some() => {
+                        let layered = View { fitted: view.fitted, ..m.with(view.layers.iter().copied()) };
+                        self.auto_layout(&mut o, &layered);
+                        layered
+                    }
+                    _ => view.clone(),
+                };
                 for c in self.children(&sym) {
-                    kids.extend(self.layer(&c, Some(&sub), child_space, Some(&view), fit, depth + 1));
+                    // The main's branch can live outside the cached context being mapped.
+                    kids.extend(self.layer_filtered(&c, Some(&sub), child_space, Some(&view), fit, depth + 1, None));
                 }
             }
+        } else if let Some(content) = slot_content {
+            let mut content_inst = inst.cloned();
+            if let Some(content_inst) = &mut content_inst {
+                content_inst.slot_content = true;
+            }
+            for c in self.children(&content) {
+                kids.extend(self.layer_filtered(&c, content_inst.as_ref(), child_space, Some(&view), None, depth + 1, included));
+            }
         } else {
             // Inside an instance a layer's children are its main's: they follow it from the main's
             // size to its own.
@@ -503,7 +986,7 @@ impl<'a> Mapper<'a> {
                 (Some(_), _) => Fit::frame(View::of(base).size(), view.size()),
             };
             for c in self.children(id) {
-                kids.extend(self.layer(&c, inst, child_space, Some(&view), fit, depth + 1));
+                kids.extend(self.layer_filtered(&c, inst, child_space, Some(&view), fit, depth + 1, included));
             }
         }
         if stand.is_some_and(|s| s.0 == "FRAME") {
@@ -521,7 +1004,7 @@ impl<'a> Mapper<'a> {
     fn shape_with_text(&mut self, o: &mut Obj, v: &View<'a>, own: &str, rest_id: &str) -> Option<Value> {
         let shape = v.str("shapeWithTextType").unwrap_or("SQUARE");
         let outlined = !v.list("fillGeometry").is_empty() || !v.list("strokeGeometry").is_empty();
-        if own != "SHAPE_WITH_TEXT" || matches!(shape, "SQUARE" | "ROUNDED_RECTANGLE") || !outlined || self.count >= MAX_NODES {
+        if own != "SHAPE_WITH_TEXT" || matches!(shape, "SQUARE" | "ROUNDED_RECTANGLE") || !outlined || self.count >= self.max_nodes {
             return None;
         }
         let mut s = Obj::new();
@@ -553,7 +1036,7 @@ impl<'a> Mapper<'a> {
     /// layer filling it, inset a little; centred unless it's a note.
     fn inner_text(&mut self, o: &Obj, v: &View<'a>, rest_id: &str, note: bool) -> Option<Value> {
         let chars = own_text(v)?;
-        if self.count >= MAX_NODES {
+        if self.count >= self.max_nodes {
             return None;
         }
         self.count += 1;
@@ -584,10 +1067,10 @@ impl<'a> Mapper<'a> {
                 o.insert(to.into(), json!(cap_name(c)));
             }
         }
-        if own_text(v).is_some() {
+        if connector_has_saved_label(v) {
             self.warn("connector labels were skipped");
         }
-        if ["vectorNetwork", "fillGeometry", "strokeGeometry"].iter().any(|k| o.contains_key(*k)) {
+        if ["vectorNetwork", "vectorNetworkRef", "fillGeometry", "strokeGeometry"].iter().any(|k| o.contains_key(*k)) {
             return;
         }
         let parent = v.get("parentIndex").and_then(|p| p.get("guid")).and_then(guid);
@@ -624,6 +1107,207 @@ impl<'a> Mapper<'a> {
         );
     }
 
+    fn connector_snapshot_supported(&self, v: &View<'a>) -> bool {
+        if v.str("connectorType") != Some("MANUAL")
+            || v.get("connectorVersion").and_then(Kv::f64) != Some(1.0)
+            || v.str("connectorLineStyle") != Some("STRAIGHT")
+            || v.get("derivedImmutableFrameData").and_then(|data| data.get("version")).and_then(Kv::f64) != Some(1.0)
+        {
+            return false;
+        }
+        let Some(line) = connector_record(v, "derivedImmutableFrameData", 0) else { return false };
+        if line.get("transform").and_then(matrix).is_none() || valid_size(line.get("size")).is_none() {
+            return false;
+        }
+        let geometry = ["fillGeometry", "strokeGeometry"].iter().any(|key| {
+            line.get(key).map(Kv::list).unwrap_or_default().iter().any(|path| {
+                num(path, "commandsBlob")
+                    .and_then(|index| self.blobs.get(index as usize))
+                    .and_then(|blob| svg_path(blob))
+                    .is_some_and(|data| !data.is_empty())
+            })
+        });
+        let network = line
+            .get("vectorData")
+            .and_then(|data| num(data, "vectorNetworkBlob"))
+            .and_then(|index| self.blobs.get(index as usize))
+            .and_then(|blob| network::decode(blob))
+            .is_some_and(|network| !network.segments.is_empty());
+        (geometry || network) && connector_record(v, "nodeGenerationData", 0).is_some()
+    }
+
+    fn connector_snapshot_flatten(&mut self, out: &mut Obj, v: &View<'a>, rest_id: &str, space: Affine) {
+        let parent = space * v.get("transform").and_then(matrix).unwrap_or_default();
+        let Some(vector) = self.connector_snapshot_vector(v, rest_id, parent, false) else {
+            self.warn("connector snapshot vector data is missing; connector was left empty");
+            return;
+        };
+        for key in [
+            "size",
+            "relativeTransform",
+            "fills",
+            "strokes",
+            "strokeWeight",
+            "strokeAlign",
+            "strokeJoin",
+            "strokeDashes",
+            "strokeCap",
+            "strokeCapStart",
+            "strokeCapEnd",
+            "styles",
+            "fillGeometry",
+            "strokeGeometry",
+            "vectorNetwork",
+        ] {
+            if let Some(value) = vector.get(key) {
+                out.insert(key.to_string(), value.clone());
+            }
+        }
+        if vector.get("visible").and_then(Value::as_bool) == Some(false) {
+            out.insert("visible".into(), json!(false));
+        }
+        if let Some(line_opacity) = vector.get("opacity").and_then(Value::as_f64) {
+            let root_opacity = out.get("opacity").and_then(Value::as_f64).unwrap_or(1.0);
+            out.insert("opacity".into(), json!(root_opacity * line_opacity));
+        }
+        if connector_has_saved_label(v) {
+            let reason = if self.count >= self.max_nodes { "node budget" } else { "depth limit" };
+            self.warn(format!("connector label was skipped: {reason} prevents nested snapshot children"));
+        }
+    }
+
+    /// Build the saved vector child or flattened terminal connector from the same child-only view.
+    fn connector_snapshot_vector(&mut self, v: &View<'a>, rest_id: &str, space: Affine, nested: bool) -> Option<Obj> {
+        let (Some(line), Some(line_style)) = (connector_record(v, "derivedImmutableFrameData", 0), connector_record(v, "nodeGenerationData", 0))
+        else {
+            return None;
+        };
+        let mut vector = Obj::new();
+        vector.insert("id".into(), json!(if nested { format!("{rest_id};vector") } else { rest_id.to_string() }));
+        vector.insert("type".into(), json!("VECTOR"));
+        if let Some(name) = v.str("name") {
+            vector.insert("name".into(), json!(if nested { format!("{name} vector") } else { name.to_string() }));
+        }
+        let line_view = View::of(line).with([line_style]);
+        self.common(&mut vector, &line_view, "VECTOR", space, None);
+        self.geometry(&mut vector, &line_view);
+        for (from, to) in [("connectorStartCap", "strokeCapStart"), ("connectorEndCap", "strokeCapEnd")] {
+            if let Some(cap) = v.str(from) {
+                vector.entry(to).or_insert_with(|| json!(cap_name(cap)));
+            }
+        }
+        Some(vector)
+    }
+
+    /// Snapshot the straight, manual connector contract carried by its generated children.
+    fn connector_snapshot_children(&mut self, v: &View<'a>, rest_id: &str) -> Vec<Value> {
+        if self.count >= self.max_nodes {
+            self.warn(format!("the file has more than {} layers; connector snapshot children were skipped", self.max_nodes));
+            return Vec::new();
+        }
+        let Some(vector) = self.connector_snapshot_vector(v, rest_id, Affine::IDENTITY, true) else {
+            self.warn("connector snapshot vector data is missing; connector was left empty");
+            return Vec::new();
+        };
+        let mut children = Vec::new();
+        children.push(Value::Object(vector));
+        self.count += 1;
+
+        let Some(text_frame) = connector_record(v, "derivedImmutableFrameData", 1) else {
+            if connector_has_saved_label(v) {
+                self.warn("connector label was skipped: derived text bounds are missing");
+            }
+            return children;
+        };
+        let Some(background) = connector_record(v, "derivedImmutableFrameData", 2) else {
+            if connector_has_saved_label(v) || valid_size(text_frame.get("size")).is_some_and(|(w, h)| w > 0.0 && h > 0.0) {
+                self.warn("connector label was skipped: derived background bounds are missing");
+            }
+            return children;
+        };
+        let Some(text_style) = connector_record(v, "nodeGenerationData", 1) else {
+            if valid_size(text_frame.get("size")).is_some_and(|(w, h)| w > 0.0 && h > 0.0) {
+                self.warn("connector label was skipped: text style data is missing");
+            }
+            return children;
+        };
+        let text_view = View::of(text_frame).with([text_style]);
+        let Some(characters) = text_view.get("textData").and_then(|d| d.get("characters")).and_then(Kv::str).filter(|s| !s.trim().is_empty()) else {
+            return children;
+        };
+        let Some(text_transform) = text_frame.get("transform").and_then(matrix) else {
+            self.warn("connector label was skipped: text transform is invalid");
+            return children;
+        };
+        let Some(background_transform) = background.get("transform").and_then(matrix) else {
+            self.warn("connector label was skipped: background transform is invalid");
+            return children;
+        };
+        let Some(text_size) = valid_size(text_frame.get("size")) else {
+            self.warn("connector label was skipped: text bounds are invalid");
+            return children;
+        };
+        let Some(background_size) = valid_size(background.get("size")) else {
+            self.warn("connector label was skipped: background bounds are invalid");
+            return children;
+        };
+        let composed_text_transform = background_transform * text_transform;
+        if !composed_text_transform.as_coeffs().iter().all(|coefficient| coefficient.is_finite()) {
+            self.warn("connector label was skipped: composed text transform is invalid");
+            return children;
+        }
+
+        let Some(background_style) = connector_record(v, "nodeGenerationData", 2) else {
+            self.warn("connector label background was skipped: style data is missing");
+            self.add_connector_text(&mut children, rest_id, characters, text_size, composed_text_transform, &text_view);
+            return children;
+        };
+        let background_view = View::of(background).with([background_style]);
+        if !background_view.list("fillPaints").is_empty() {
+            if self.count >= self.max_nodes {
+                self.warn(format!("the file has more than {} layers; connector label background was skipped", self.max_nodes));
+            } else {
+                let mut rect = Obj::new();
+                rect.insert("id".into(), json!(format!("{rest_id};label-background")));
+                rect.insert("type".into(), json!("RECTANGLE"));
+                rect.insert("name".into(), json!("connector label background"));
+                self.common(&mut rect, &background_view, "RECTANGLE", Affine::IDENTITY, None);
+                rect.insert("size".into(), json!({"x": background_size.0, "y": background_size.1}));
+                rect.insert("relativeTransform".into(), rows(background_transform));
+                rect.insert("clipsContent".into(), json!(false));
+                children.push(Value::Object(rect));
+                self.count += 1;
+            }
+        }
+        self.add_connector_text(&mut children, rest_id, characters, text_size, composed_text_transform, &text_view);
+        children
+    }
+
+    fn add_connector_text(
+        &mut self,
+        children: &mut Vec<Value>,
+        rest_id: &str,
+        characters: &str,
+        size: (f64, f64),
+        transform: Affine,
+        view: &View<'a>,
+    ) {
+        if self.count >= self.max_nodes {
+            self.warn(format!("the file has more than {} layers; connector label was skipped", self.max_nodes));
+            return;
+        }
+        let mut text = Obj::new();
+        text.insert("id".into(), json!(format!("{rest_id};label-text")));
+        text.insert("type".into(), json!("TEXT"));
+        text.insert("name".into(), json!(characters));
+        text.insert("size".into(), json!({"x": size.0, "y": size.1}));
+        self.common(&mut text, view, "TEXT", Affine::IDENTITY, None);
+        text.insert("relativeTransform".into(), rows(transform));
+        self.text(&mut text, view);
+        children.push(Value::Object(text));
+        self.count += 1;
+    }
+
     /// Fields every layer type shares.
     fn common(&mut self, o: &mut Obj, v: &View<'a>, ty: &str, space: Affine, parent: Option<&View<'a>>) {
         for (from, to) in [("visible", "visible"), ("locked", "locked"), ("mask", "isMask")] {
@@ -650,11 +1334,11 @@ impl<'a> Mapper<'a> {
         let fill_style = self.style(v, "styleIdForFill", "inheritFillStyleID", "fill", &mut styles);
         let fills = own("fillPaints")
             .unwrap_or_else(|| fill_style.map_or_else(|| v.list("fillPaints"), |s| s.get("fillPaints").map(Kv::list).unwrap_or_default()));
-        o.insert("fills".into(), Value::Array(fills.iter().filter_map(paint).collect()));
+        o.insert("fills".into(), Value::Array(fills.iter().filter_map(|p| paint(p, &mut |w| self.warn(w))).collect()));
         let stroke_style = self.style(v, "styleIdForStrokeFill", "inheritFillStyleIDForStroke", "stroke", &mut styles);
         let strokes = own("strokePaints")
             .unwrap_or_else(|| stroke_style.map_or_else(|| v.list("strokePaints"), |s| s.get("fillPaints").map(Kv::list).unwrap_or_default()));
-        o.insert("strokes".into(), Value::Array(strokes.iter().filter_map(paint).collect()));
+        o.insert("strokes".into(), Value::Array(strokes.iter().filter_map(|p| paint(p, &mut |w| self.warn(w))).collect()));
         let effect_style = self.style(v, "styleIdForEffect", "inheritEffectStyleID", "effect", &mut styles);
         let effects = effect_style.map_or_else(|| v.list("effects"), |s| s.get("effects").map(Kv::list).unwrap_or_default());
         if !effects.is_empty() {
@@ -719,7 +1403,7 @@ impl<'a> Mapper<'a> {
     /// The style node a layer links in `key` (or the older `legacy` field), recorded for the REST
     /// `styles` map under `slot`.
     fn style(&mut self, v: &View<'a>, key: &str, legacy: &str, slot: &str, out: &mut Obj) -> Option<&'a Kv<'a>> {
-        let id = v.get(key).and_then(ref_guid).or_else(|| v.get(legacy).and_then(guid).filter(|g| g != NO_STYLE))?;
+        let id = style_link(v, key, legacy)?;
         let node = *self.nodes.get(&id)?;
         node.get("styleType").and_then(Kv::str)?;
         out.insert(slot.into(), json!(id));
@@ -750,7 +1434,10 @@ impl<'a> Mapper<'a> {
         let main = match v.str("stackPrimaryAlignItems").or_else(|| v.str("stackJustify")) {
             Some("CENTER") => "CENTER",
             Some("MAX") => "MAX",
-            Some("SPACE_BETWEEN" | "SPACE_EVENLY" | "SPACE_AROUND" | "SPACE_EVENLY_CSS") => "SPACE_BETWEEN",
+            Some("SPACE_AROUND") => "SPACE_AROUND",
+            // `SPACE_EVENLY` is the format's older name for equal gaps without edge space.
+            Some("SPACE_EVENLY_CSS") => "SPACE_EVENLY",
+            Some("SPACE_BETWEEN" | "SPACE_EVENLY") => "SPACE_BETWEEN",
             _ => "MIN",
         };
         o.insert("primaryAxisAlignItems".into(), json!(main));
@@ -762,7 +1449,10 @@ impl<'a> Mapper<'a> {
         };
         o.insert("counterAxisAlignItems".into(), json!(cross));
         let sizing = |k: &str| if v.str(k).is_some_and(|s| s.starts_with("RESIZE_TO_FIT")) { "AUTO" } else { "FIXED" };
-        o.insert("primaryAxisSizingMode".into(), json!(sizing("stackPrimarySizing")));
+        // A flow that records no sizing for its primary axis sizes it by its content: auto layout
+        // did before that axis could be fixed.
+        let primary = if v.get("stackPrimarySizing").is_none() && mode != "GRID" { "AUTO" } else { sizing("stackPrimarySizing") };
+        o.insert("primaryAxisSizingMode".into(), json!(primary));
         o.insert("counterAxisSizingMode".into(), json!(sizing("stackCounterSizing")));
         if let Some(b) = v.flag("bordersTakeSpace") {
             o.insert("strokesIncludedInLayout".into(), json!(b));
@@ -775,35 +1465,104 @@ impl<'a> Mapper<'a> {
             copy_num(o, v, "gridRowGap", "gridRowGap");
             o.insert("gridColumnCount".into(), json!(tracks(v, "gridColumns").len()));
             o.insert("gridRowCount".into(), json!(tracks(v, "gridRows").len()));
-            let sizes = ["gridColumnsSizing", "gridRowsSizing"]
-                .iter()
-                .flat_map(|k| v.get(k).and_then(|m| m.get("entries")).map(Kv::list).unwrap_or_default());
-            let flexible = sizes.into_iter().all(|e| {
-                let t = e.get("trackSize");
-                ["minSizing", "maxSizing"]
-                    .iter()
-                    .all(|s| t.and_then(|t| t.get(s)).and_then(|s| s.get("type")).and_then(Kv::str).is_none_or(|x| x == "FLEX"))
-            });
-            if !flexible {
-                self.warn("grid tracks of fixed or content size import as equal tracks");
+            let track_data = [("columnTracks", "gridColumns", "gridColumnsSizing"), ("rowTracks", "gridRows", "gridRowsSizing")]
+                .into_iter()
+                .filter_map(|(out_key, order_key, sizing_key)| {
+                    self.map_grid_tracks(v, order_key, sizing_key).map(|mapped| (out_key.to_string(), mapped))
+                })
+                .collect::<Obj>();
+            if !track_data.is_empty() {
+                let source = o.entry(crate::rest::FIG_SOURCE_FIELD).or_insert_with(|| json!({}));
+                if let Some(source) = source.as_object_mut() {
+                    source.insert("gridTracks".into(), Value::Object(track_data));
+                }
             }
         }
     }
 
+    /// Track sizing maps are keyed by GUID; their order comes from the separate track list.
+    fn map_grid_tracks(&mut self, v: &View<'a>, order_key: &str, sizing_key: &str) -> Option<Value> {
+        let track_entries = v.get(order_key).and_then(|m| m.get("entries")).map(Kv::list).unwrap_or_default();
+        let sizes = v.get(sizing_key).and_then(|m| m.get("entries")).map(Kv::list).unwrap_or_default();
+        if track_entries.len() > MAX_GRID_TRACKS {
+            self.warn("grid track list exceeds 1000 entries; the tracks use the default equal sizing");
+            return None;
+        }
+        if sizes.is_empty() {
+            return None;
+        }
+        if sizes.len() > MAX_GRID_TRACKS {
+            self.warn("grid track sizing list exceeds 1000 entries; the tracks use the default equal sizing");
+            return None;
+        }
+        let ordered = tracks(v, order_key);
+        let ordered_ids: BTreeSet<&str> = ordered.iter().map(String::as_str).collect();
+        let mut size_by_id: BTreeMap<String, Option<&Kv<'a>>> = BTreeMap::new();
+        for entry in sizes {
+            let Some(id) = entry.get("id").and_then(guid) else {
+                self.warn("stale or invalid grid track sizing entries were ignored");
+                continue;
+            };
+            if !ordered_ids.contains(id.as_str()) {
+                self.warn("stale or invalid grid track sizing entries were ignored");
+                continue;
+            }
+            match size_by_id.entry(id) {
+                std::collections::btree_map::Entry::Vacant(slot) => {
+                    slot.insert(Some(entry));
+                }
+                std::collections::btree_map::Entry::Occupied(mut slot) => {
+                    slot.insert(None);
+                    self.warn("duplicate grid track sizing entries use equal tracks");
+                }
+            }
+        }
+        let mut mapped = Vec::with_capacity(ordered.len());
+        for id in ordered {
+            if let Some(Some(entry)) = size_by_id.get(&id) {
+                match grid_track_sizing(entry.get("trackSize")) {
+                    Some(track) => mapped.push(track),
+                    None => {
+                        self.warn("grid track sizing is unsupported or malformed; affected tracks use equal sizing");
+                        mapped.push(json!({"sizing": "fill", "value": 1.0}));
+                    }
+                }
+            } else {
+                mapped.push(json!({"sizing": "fill", "value": 1.0}));
+            }
+        }
+        Some(Value::Array(mapped))
+    }
+
     fn text(&mut self, o: &mut Obj, v: &View<'a>) {
-        let style_node = v
-            .get("styleIdForText")
-            .and_then(ref_guid)
-            .or_else(|| v.get("inheritTextStyleID").and_then(guid))
-            .and_then(|s| self.nodes.get(&s).copied());
-        let sv = v.with(style_node.filter(|s| s.get("styleType").and_then(Kv::str) == Some("TEXT")));
+        let style_node = style_link(v, "styleIdForText", "inheritTextStyleID").and_then(|s| self.nodes.get(&s).copied());
+        // Instance overrides beat the shared style; the style beats the layer's own copy.
+        let sv = v.styled(style_node.filter(|s| s.get("styleType").and_then(Kv::str) == Some("TEXT")));
         let td = v.get("textData");
         let chars = td.and_then(|t| t.get("characters")).and_then(Kv::str).unwrap_or("");
         o.insert("characters".into(), json!(chars));
         let mut style = text_style(&sv, None);
+        // The style's typography beats the layer's own copy of it (the copy is stale when the style
+        // changed). The file cannot tell a stale copy of these four values from a deliberate local
+        // one, and "original", "none" and 0 could never be set locally if the style always won, so
+        // a value the layer or an override sets itself is taken as deliberate.
+        if let Some(decoration @ ("NONE" | "UNDERLINE" | "STRIKETHROUGH")) = v.str("textDecoration") {
+            style.insert("textDecoration".into(), json!(decoration));
+        }
+        if let Some(skip_ink) = v.flag("textDecorationSkipInk") {
+            style.insert("textDecorationSkipInk".into(), json!(skip_ink));
+        }
+        if let Some(case @ ("ORIGINAL" | "UPPER" | "LOWER" | "TITLE" | "SMALL_CAPS" | "SMALL_CAPS_FORCED")) = v.str("textCase") {
+            style.insert("textCase".into(), json!(case));
+        }
         for k in ["textAlignHorizontal", "textAlignVertical", "textAutoResize", "textTruncation"] {
             copy_str(&mut style, v, k, k);
         }
+        // Paragraph settings belong to the effective text layer, including explicit zero clears.
+        for k in ["paragraphSpacing", "paragraphIndent"] {
+            copy_num(&mut style, v, k, k);
+        }
+        insert_text_options(&mut style, v);
         if let Some(n) = v.num("maxLines").filter(|n| *n >= 1.0) {
             style.insert("maxLines".into(), json!(n));
         }
@@ -813,24 +1572,9 @@ impl<'a> Mapper<'a> {
         }
         o.insert("style".into(), Value::Object(style));
         let Some(td) = td else { return };
-        let ids: Vec<u64> = td.get("characterStyleIDs").map(Kv::list).unwrap_or_default().iter().filter_map(Kv::f64).map(|i| i as u64).collect();
-        if ids.iter().any(|i| *i != 0) {
-            let mut table = Obj::new();
-            for e in td.get("styleOverrideTable").map(Kv::list).unwrap_or_default() {
-                let Some(sid) = num(e, "styleID") else { continue };
-                let mut s = text_style(&View::of(e), size);
-                if let Some(fills) = e.get("fillPaints") {
-                    s.insert("fills".into(), Value::Array(fills.list().iter().filter_map(paint).collect()));
-                }
-                table.insert((sid as u64).to_string(), Value::Object(s));
-            }
-            o.insert("characterStyleOverrides".into(), json!(ids));
-            o.insert("styleOverrideTable".into(), Value::Object(table));
-        }
-        let lines: Vec<&str> = td
-            .get("lines")
-            .map(Kv::list)
-            .unwrap_or_default()
+        char_styles(o, td, size, &mut |w| self.warn(w));
+        let raw = td.get("lines").map(Kv::list).unwrap_or_default();
+        let lines: Vec<&str> = raw
             .iter()
             .map(|l| match l.get("lineType").and_then(Kv::str) {
                 Some("ORDERED_LIST") => "ORDERED",
@@ -841,6 +1585,98 @@ impl<'a> Mapper<'a> {
         if lines.iter().any(|l| *l != "NONE") {
             o.insert("lineTypes".into(), json!(lines));
         }
+        // Where a numbered list starts counting, less one (not a REST field).
+        let starts: Vec<u32> =
+            raw.iter().map(|l| num(l, "listStartOffset").filter(|n| n.is_finite()).map_or(0, |n| n.clamp(0.0, f64::from(u32::MAX)) as u32)).collect();
+        if starts.iter().any(|n| *n > 0) {
+            o.insert("listStartOffsets".into(), json!(starts));
+        }
+    }
+
+    /// Carry supported text-path data through the private .fig REST ingress only.
+    fn text_path(&mut self, o: &mut Obj, v: &View<'a>) {
+        let fail = |this: &mut Self, reason: &str| {
+            this.warn(format!("text path {reason}; text imports off its path"));
+        };
+        let Some(start) = v.get("textPathStart") else {
+            fail(self, "has no start data");
+            return;
+        };
+        let (Some(t), Some(forward)) = (num(start, "tValue"), start.get("forward").and_then(Kv::bool)) else {
+            fail(self, "has invalid start data");
+            return;
+        };
+        let Some(vd) = v.get("vectorData") else {
+            fail(self, "has no vector data");
+            return;
+        };
+        let Some(blob) = num(vd, "vectorNetworkBlob")
+            .filter(|i| i.is_finite() && *i >= 0.0 && i.fract() == 0.0)
+            .and_then(|i| usize::try_from(i as u64).ok())
+            .and_then(|i| self.blobs.get(i))
+            .copied()
+        else {
+            fail(self, "has no vector network");
+            return;
+        };
+        let Some(net) = network::decode(blob) else {
+            fail(self, "has damaged vector data");
+            return;
+        };
+        let Some(norm) = vd.get("normalizedSize") else {
+            fail(self, "has invalid normalized size");
+            return;
+        };
+        let Some(size) = v.get("size") else {
+            fail(self, "has invalid dimensions");
+            return;
+        };
+        let (Some(nx), Some(ny), Some(w), Some(h)) = (num(norm, "x"), num(norm, "y"), num(size, "x"), num(size, "y")) else {
+            fail(self, "has invalid dimensions");
+            return;
+        };
+        let axis_scale = |size: f64, normalized: f64, values: &[f64]| -> Option<f64> {
+            if !size.is_finite() || size < 0.0 || !normalized.is_finite() || normalized < 0.0 {
+                return None;
+            }
+            if normalized > 1e-9 {
+                if size <= 0.0 {
+                    return None;
+                }
+                return Some(size / normalized);
+            }
+            (size == 0.0 && values.iter().all(|v| *v == 0.0)).then_some(1.0)
+        };
+        let xs: Vec<f64> = net.vertices.iter().map(|p| p.x).chain(net.segments.iter().flat_map(|s| [s.ta.0, s.tb.0])).collect();
+        let ys: Vec<f64> = net.vertices.iter().map(|p| p.y).chain(net.segments.iter().flat_map(|s| [s.ta.1, s.tb.1])).collect();
+        let sx = axis_scale(w, nx, &xs);
+        let sy = axis_scale(h, ny, &ys);
+        let (Some(sx), Some(sy)) = (sx, sy) else {
+            fail(self, "has invalid path scale");
+            return;
+        };
+        if v.str("textAlignVertical").is_some_and(|x| x != "TOP") {
+            fail(self, "uses unsupported vertical placement");
+            return;
+        }
+        if v.get("textData").and_then(|td| td.get("characters")).and_then(Kv::str).is_some_and(|s| s.chars().any(|c| matches!(c, '\n' | '\r'))) {
+            fail(self, "contains multiple lines");
+            return;
+        }
+        let path = match super::text_path::from_network(&net, sx, sy, t, forward) {
+            Ok(path) => path,
+            Err(reason) => {
+                fail(self, reason);
+                return;
+            }
+        };
+        let has_decoration = |style: &Value| style.get("textDecoration").and_then(Value::as_str).is_some_and(|x| x != "NONE");
+        let decorated = o.get("style").is_some_and(has_decoration)
+            || o.get("styleOverrideTable").and_then(Value::as_object).into_iter().flat_map(|styles| styles.values()).any(has_decoration);
+        if decorated {
+            self.warn("text path underline or strikethrough decoration is not rendered");
+        }
+        o.insert("_figTextPath".into(), json!({"d": path.d, "start": path.start, "flip": path.flip}));
     }
 
     /// `fillGeometry` / `strokeGeometry` as SVG path data, and star/polygon parameters.
@@ -879,19 +1715,38 @@ impl<'a> Mapper<'a> {
     /// False when there's none or it's damaged (the outlines stand in).
     fn network(&mut self, o: &mut Obj, v: &View<'a>) -> bool {
         let Some(vd) = v.get("vectorData") else { return false };
-        let Some(blob) = num(vd, "vectorNetworkBlob").and_then(|i| self.blobs.get(i as usize)).copied() else { return false };
+        let Some(blob_id) = num(vd, "vectorNetworkBlob").map(|i| i as usize) else { return false };
+        let Some(blob) = self.blobs.get(blob_id).copied() else { return false };
         let Some(net) = network::decode(blob) else {
             self.warn("damaged vector networks import as outlines");
             return false;
         };
+        let styles: BTreeMap<u64, &Kv> =
+            vd.get("styleOverrideTable").map(Kv::list).unwrap_or_default().iter().filter_map(|s| Some((num(s, "styleID")? as u64, s))).collect();
+        let mut has_uninterpreted = false;
+        let mut has_missing = false;
+        for segment in &net.segments {
+            if segment.style == 0 {
+                continue;
+            }
+            if styles.contains_key(&u64::from(segment.style)) {
+                has_uninterpreted = true;
+            } else {
+                has_missing = true;
+            }
+        }
+        if has_uninterpreted {
+            self.warn("style settings of some vector segments aren't supported; those segments use the layer's stroke");
+        }
+        if has_missing {
+            self.warn("some vector segments refer to style settings missing from the file; they use the layer's stroke");
+        }
         // An open path shows its fill, which regions can't hold: the outline keeps the look.
         let fills_shown =
             o.get("fills").and_then(Value::as_array).is_some_and(|f| f.iter().any(|p| p.get("visible").and_then(Value::as_bool) != Some(false)));
         if net.segments.is_empty() || (net.regions.is_empty() && fills_shown && o.contains_key("fillGeometry")) {
             return false;
         }
-        let styles: BTreeMap<u64, &Kv> =
-            vd.get("styleOverrideTable").map(Kv::list).unwrap_or_default().iter().filter_map(|s| Some((num(s, "styleID")? as u64, s))).collect();
         let style = |id: u32| styles.get(&u64::from(id)).copied().filter(|_| id != 0);
         let scale = |k: &str| {
             let size = v.size().map(|s| if k == "x" { s.0 } else { s.1 });
@@ -899,34 +1754,24 @@ impl<'a> Mapper<'a> {
             size.zip(norm).filter(|(s, n)| s.is_finite() && *n > 1e-9).map_or(1.0, |(s, n)| s / n)
         };
         let (sx, sy) = (scale("x"), scale("y"));
-        let vertices: Vec<Value> = net
-            .vertices
-            .iter()
-            .map(|p| {
-                let mut out = json!({"x": p.x * sx, "y": p.y * sy});
-                let st = style(p.style);
-                if let Some(r) = st.and_then(|s| num(s, "cornerRadius")).filter(|r| *r > 0.0) {
-                    out["radius"] = json!(r);
-                }
-                match st.and_then(|s| s.get("handleMirroring")).and_then(Kv::str) {
-                    Some("ANGLE") => out["mirror"] = json!("angle"),
-                    Some("ANGLE_AND_LENGTH") => out["mirror"] = json!("angleAndLength"),
-                    Some("NONE") => out["mirror"] = json!("none"),
-                    _ => {}
-                }
-                out
-            })
-            .collect();
-        let segments: Vec<Value> =
-            net.segments.iter().map(|s| json!({"a": s.a, "b": s.b, "ta": [s.ta.0 * sx, s.ta.1 * sy], "tb": [s.tb.0 * sx, s.tb.1 * sy]})).collect();
-        let regions: Vec<Value> =
-            net.regions.iter().map(|r| json!({"loops": r.loops, "winding": if r.non_zero { "nonZero" } else { "evenOdd" }})).collect();
+        // An absent layer join is the source default.
+        let layer_join = v.str("strokeJoin").unwrap_or("MITER");
+        let point_join = |p: &network::Vertex| style(p.style).and_then(|s| s.get("strokeJoin"));
+        let known = |j: &str| matches!(j, "MITER" | "BEVEL" | "ROUND");
+        let unresolved_style = net.vertices.iter().any(|p| p.style != 0 && style(p.style).is_none());
+        let unknown_join = net.vertices.iter().any(|p| point_join(p).is_some_and(|j| !j.str().is_some_and(known)));
+        let unsupported_join = net.vertices.iter().any(|p| point_join(p).and_then(Kv::str).is_some_and(|j| known(j) && j != layer_join));
         if net.regions.iter().any(|r| style(r.style).is_some_and(|s| s.get("fillPaints").is_some())) {
             self.warn("filled areas of a vector with their own fill use the layer's fill");
         }
-        let join = v.str("strokeJoin");
-        if net.vertices.iter().any(|p| style(p.style).and_then(|s| s.get("strokeJoin")).and_then(Kv::str).is_some_and(|j| Some(j) != join)) {
-            self.warn("points with their own stroke join use the layer's");
+        if unresolved_style {
+            self.warn("some vector points refer to point settings missing from the file; they use the layer's joins and plain corners");
+        }
+        if unknown_join {
+            self.warn("vector points with unknown stroke joins use the layer join");
+        }
+        if unsupported_join && (o.contains_key("strokeDashes") || o.contains_key("strokeWidthProfile")) {
+            self.warn("point stroke joins were preserved; dashed or variable-width strokes render with the layer join");
         }
         // The stroke starts at the first end point and stops at the last (as the editor draws it).
         let mut degree = vec![0usize; net.vertices.len()];
@@ -946,7 +1791,49 @@ impl<'a> Mapper<'a> {
             o.insert("strokeCapStart".into(), json!(cap_name(first.unwrap_or(node))));
             o.insert("strokeCapEnd".into(), json!(cap_name(last.unwrap_or(node))));
         }
-        o.insert("vectorNetwork".into(), json!({"vertices": vertices, "segments": segments, "regions": regions}));
+        // Every instance of a main shows the same network: it is written once and shared.
+        let key = (blob_id, sx.to_bits(), sy.to_bits(), std::ptr::from_ref(vd) as usize);
+        let id = match self.network_ids.get(&key) {
+            Some(id) => *id,
+            None => {
+                let vertices: Vec<Value> = net
+                    .vertices
+                    .iter()
+                    .map(|p| {
+                        let mut out = json!({"x": p.x * sx, "y": p.y * sy});
+                        let st = style(p.style);
+                        if let Some(r) = st.and_then(|s| num(s, "cornerRadius")).filter(|r| *r > 0.0) {
+                            out["radius"] = json!(r);
+                        }
+                        match st.and_then(|s| s.get("handleMirroring")).and_then(Kv::str) {
+                            Some("ANGLE") => out["mirror"] = json!("angle"),
+                            Some("ANGLE_AND_LENGTH") => out["mirror"] = json!("angleAndLength"),
+                            Some("NONE") => out["mirror"] = json!("none"),
+                            _ => {}
+                        }
+                        if let Some(join @ ("MITER" | "BEVEL" | "ROUND")) = st.and_then(|s| s.get("strokeJoin")).and_then(Kv::str) {
+                            out["join"] = json!(join.to_ascii_lowercase());
+                        }
+                        out
+                    })
+                    .collect();
+                let segments: Vec<Value> = net
+                    .segments
+                    .iter()
+                    .map(|s| json!({"a": s.a, "b": s.b, "ta": [s.ta.0 * sx, s.ta.1 * sy], "tb": [s.tb.0 * sx, s.tb.1 * sy]}))
+                    .collect();
+                let regions: Vec<Value> =
+                    net.regions.iter().map(|r| json!({"loops": r.loops, "winding": if r.non_zero { "nonZero" } else { "evenOdd" }})).collect();
+                let mut entry = json!({});
+                entry["vertices"] = Value::Array(vertices);
+                entry["segments"] = Value::Array(segments);
+                entry["regions"] = Value::Array(regions);
+                self.networks.push(crate::rest::network(&entry));
+                self.network_ids.insert(key, self.networks.len() - 1);
+                self.networks.len() - 1
+            }
+        };
+        o.insert("vectorNetworkRef".into(), json!(id));
         true
     }
 
@@ -967,6 +1854,11 @@ impl<'a> Mapper<'a> {
                     None => continue,
                 },
                 "VARIANT" => json!({"type": "VARIANT"}),
+                "SLOT" => {
+                    self.warn_non_default_slot_config(d);
+                    self.warn_dropped_slot_preferred_values(d);
+                    json!({"type": "SLOT"})
+                }
                 _ => {
                     self.warn(format!("{} component properties are not supported and were skipped", ty.to_ascii_lowercase()));
                     continue;
@@ -983,6 +1875,34 @@ impl<'a> Mapper<'a> {
         }
     }
 
+    /// Preferred slot values are source component keys, but this mapper has no proven way to map
+    /// those keys to file GUIDs. They are dropped instead of guessing native NodeIds.
+    fn warn_dropped_slot_preferred_values(&mut self, def: &Kv<'a>) {
+        let entries = def.get("preferredValues").and_then(|v| v.get("instanceSwapValues")).map(Kv::list).unwrap_or_default();
+        if !entries.is_empty() {
+            self.warn("preferred slot component keys cannot be resolved to file nodes and were skipped");
+        }
+    }
+
+    fn warn_non_default_slot_config(&mut self, def: &Kv<'a>) {
+        let Some(config) = def.get("slotPropConfig") else { return };
+        let non_default = [
+            ("stretchChildOnInsert", Some(false)),
+            ("displayByDefault", Some(false)),
+            ("minChildren", None),
+            ("maxChildren", None),
+            ("allowPreferredValuesOnly", Some(false)),
+        ]
+        .into_iter()
+        .any(|(field, bool_default)| {
+            let Some(value) = config.get(field) else { return false };
+            if let Some(default) = bool_default { value.bool() != Some(default) } else { value.f64() != Some(0.0) }
+        });
+        if non_default {
+            self.warn("non-default slot settings are not represented and were skipped");
+        }
+    }
+
     /// A layer's component property references, and inside an instance the values they take.
     fn prop_refs(&mut self, o: &mut Obj, v: &View<'a>, inst: Option<&Inst<'a>>) {
         let mut refs = Obj::new();
@@ -991,6 +1911,7 @@ impl<'a> Mapper<'a> {
                 Some("VISIBLE") => "visible",
                 Some("TEXT_DATA") => "characters",
                 Some("OVERRIDDEN_SYMBOL_ID") => "mainComponent",
+                Some("SLOT_CONTENT_ID") => "slot",
                 _ => continue,
             };
             let Some(def) =
@@ -998,10 +1919,14 @@ impl<'a> Mapper<'a> {
             else {
                 continue;
             };
-            if let Some((name, _)) = self.prop_defs.get(&def) {
+            // Expanded frames must follow their main frame's source link. A direct slot reference
+            // makes the engine resolve ownership against the instance, where the property is not defined.
+            if !(field == "slot" && inst.is_some())
+                && let Some((name, _)) = self.prop_def(&def)
+            {
                 refs.insert(field.into(), json!(name));
             }
-            let Some(val) = inst.and_then(|i| i.props.get(&def)) else { continue };
+            let Some(val) = inst.and_then(|i| i.props.get(&self.prop_root(&def))) else { continue };
             match field {
                 "visible" => {
                     if let Some(b) = val.get("boolValue").and_then(Kv::bool) {
@@ -1011,6 +1936,16 @@ impl<'a> Mapper<'a> {
                 "characters" => {
                     if let Some(t) = prop_text(val) {
                         o.insert("characters".into(), json!(t));
+                        // Run styles count the chars they were made for: for other chars only
+                        // the value's own apply.
+                        if own_text(v) != Some(t) {
+                            o.remove("characterStyleOverrides");
+                            o.remove("styleOverrideTable");
+                            if let Some(tv) = prop_text_data(val) {
+                                let size = o.get("style").and_then(|s| s.get("fontSize")).and_then(Value::as_f64);
+                                char_styles(o, tv, size, &mut |w| self.warn(w));
+                            }
+                        }
                     }
                 }
                 _ => {}
@@ -1028,7 +1963,7 @@ impl<'a> Mapper<'a> {
         // An instance swap property value picks the main.
         if let Some(i) = outer
             && let Some(def) = prop_ref(v, "OVERRIDDEN_SYMBOL_ID")
-            && let Some(g) = i.props.get(&def).and_then(|p| p.get("guidValue")).and_then(guid)
+            && let Some(g) = i.props.get(&self.prop_root(&def)).and_then(|p| prop_guid(p))
         {
             sym = Some(g);
         }
@@ -1040,12 +1975,12 @@ impl<'a> Mapper<'a> {
         let assignments = v.list("componentPropAssignments");
         let mut props = Obj::new();
         for a in assignments {
-            let Some((name, ty)) = a.get("defID").and_then(guid).and_then(|d| self.prop_defs.get(&d).cloned()) else { continue };
-            let val = a.get("value");
+            let Some((name, ty)) = a.get("defID").and_then(guid).and_then(|d| self.prop_def(&d).cloned()) else { continue };
+            let val = assigned(a);
             let p = match ty {
                 "BOOL" => val.and_then(|x| x.get("boolValue")).and_then(Kv::bool).map(|b| json!({"type": "BOOLEAN", "value": b})),
                 "TEXT" => val.and_then(prop_text).map(|t| json!({"type": "TEXT", "value": t})),
-                "INSTANCE_SWAP" => val.and_then(|x| x.get("guidValue")).and_then(guid).map(|g| json!({"type": "INSTANCE_SWAP", "value": g})),
+                "INSTANCE_SWAP" => val.and_then(prop_guid).map(|g| json!({"type": "INSTANCE_SWAP", "value": g})),
                 _ => None,
             };
             if let Some(p) = p {
@@ -1064,7 +1999,18 @@ impl<'a> Mapper<'a> {
         }
         // Overrides by id path below this instance (the instance itself is addressed by its main's id).
         let own_path: Vec<String> = outer.map(|i| [i.path.as_slice(), &[id.to_string()]].concat()).unwrap_or_default();
-        let mut overrides: Overrides<'a> = outer.map(|i| (*i.overrides).clone()).unwrap_or_default();
+        let scope = self.override_scope(&sym);
+        let mut overrides: Overrides<'a> = BTreeMap::new();
+        if let Some(inherited) = outer {
+            for (path, rows) in inherited.overrides.iter() {
+                let mut path = path.clone();
+                // Rows an outer instance wrote for this instance's layers may use their old keys.
+                if path.starts_with(&own_path) && path.len() > own_path.len() {
+                    normalize_override_segment(&mut path, own_path.len(), &scope);
+                }
+                overrides.entry(path).or_default().extend(rows.iter().cloned());
+            }
+        }
         // A nested instance's derived layout is for the size it has in its main: resized here, the
         // sizes and places in it no longer hold and its layers follow their constraints instead.
         let differs = |a: f64, b: f64| (a - b).abs() > 1e-6 * a.abs().max(b.abs()).max(1.0);
@@ -1073,40 +2019,86 @@ impl<'a> Mapper<'a> {
                 (Some(a), Some(b)) => differs(a.0, b.0) || differs(a.1, b.1),
                 (a, b) => a.is_some() != b.is_some(),
             };
+        let mut local: Overrides<'a> = BTreeMap::new();
         let lists = [sd.and_then(|s| s.get("symbolOverrides")).map(Kv::list).unwrap_or_default(), v.list("derivedSymbolData")];
+        let source_depth = outer.map_or(0, |i| i.symbols.len());
+        let mut ordinal = 0;
         for (layer, list) in lists.into_iter().enumerate() {
             for ov in list {
-                let rel: Vec<String> =
+                let row_ordinal = ordinal;
+                ordinal += 1;
+                let mut rel: Vec<String> =
                     ov.get("guidPath").and_then(|g| g.get("guids")).map(Kv::list).unwrap_or_default().iter().filter_map(guid).collect();
                 if rel.is_empty() || rel == [sym.clone()] {
                     continue;
                 }
-                let e = overrides.entry([own_path.as_slice(), &rel].concat()).or_default();
-                // The outer instance's overrides win over this one's own; derived layout comes last.
-                if layer == 0 && outer.is_some() {
-                    e.insert(0, (Entry::Override, ov));
-                } else {
-                    e.push((
-                        match (layer, resized) {
-                            (0, _) => Entry::Override,
-                            (_, false) => Entry::Derived,
-                            (_, true) => Entry::Stale,
-                        },
-                        ov,
-                    ));
-                }
+                normalize_override_segment(&mut rel, 0, &scope);
+                // Explicit overrides, then derived layout (stale once the instance is resized).
+                let entry = match (layer, resized) {
+                    (0, _) => Entry::Override,
+                    (_, false) => Entry::Derived,
+                    (_, true) => Entry::Stale,
+                };
+                local.entry([own_path.as_slice(), &rel].concat()).or_default().push(OverrideRow {
+                    row: ov,
+                    entry,
+                    source_depth,
+                    ordinal: row_ordinal,
+                });
             }
         }
+        for (path, rows) in local {
+            overrides.entry(path).or_default().extend(rows);
+        }
+        for rows in overrides.values_mut() {
+            // Deeper source rows apply first; outer rows win, with wire order preserved per source.
+            rows.sort_by_key(|row| (std::cmp::Reverse(row.source_depth), row.ordinal));
+        }
         let mut all_props: BTreeMap<String, &'a Kv<'a>> = outer.map(|i| (*i.props).clone()).unwrap_or_default();
+        let mut slot_contents: BTreeMap<String, String> = outer.map(|i| (*i.slot_contents).clone()).unwrap_or_default();
         for a in assignments {
-            if let (Some(d), Some(val)) = (a.get("defID").and_then(guid), a.get("value")) {
-                all_props.entry(d).or_insert(val);
+            if let (Some(d), Some(val)) = (a.get("defID").and_then(guid), assigned(a)) {
+                all_props.entry(self.prop_root(&d)).or_insert(val);
             }
+            let Some(def) = a.get("defID").and_then(guid) else { continue };
+            if self.prop_def(&def).is_none_or(|(_, ty)| *ty != "SLOT") {
+                continue;
+            }
+            let var_value = a.get("varValue");
+            if var_value.and_then(|v| v.get("dataType")).and_then(Kv::str) != Some("SLOT_CONTENT_ID") {
+                self.warn("malformed slot content assignment was skipped");
+                continue;
+            }
+            let target = var_value.and_then(|v| v.get("value")).and_then(|v| v.get("slotContentIdValue")).and_then(|v| v.get("guid")).and_then(guid);
+            let Some(target) = target else {
+                self.warn("malformed slot content assignment was skipped");
+                continue;
+            };
+            if target == "4294967295:4294967295" {
+                self.warn("slot content assignment uses the empty GUID sentinel and was skipped");
+                continue;
+            }
+            if self.nodes.get(&target).is_none_or(|n| n.get("isSlotContent").and_then(Kv::bool) != Some(true)) {
+                self.warn("slot content assignment target is missing or is not slot content");
+                continue;
+            }
+            slot_contents.entry(self.prop_root(&def)).or_insert(target);
         }
         let mut symbols = outer.map(|i| i.symbols.clone()).unwrap_or_default();
         symbols.push(sym.clone());
         let root = outer.map_or_else(|| rest_id.to_string(), |i| i.root.clone());
-        Some((Inst { root, path: own_path, overrides: Rc::new(overrides), props: Rc::new(all_props), symbols }, sym))
+        Some((
+            Inst {
+                root,
+                path: own_path,
+                overrides: Rc::new(overrides),
+                props: Rc::new(all_props),
+                slot_contents: Rc::new(slot_contents),
+                slot_content: false,
+                symbols,
+            },
+            sym,
+        ))
     }
 
     fn prototype(&mut self, o: &mut Obj, v: &View<'a>) {
@@ -1505,6 +2497,30 @@ fn own_text<'a>(v: &View<'a>) -> Option<&'a str> {
     v.get("textData").and_then(|t| t.get("characters")).and_then(Kv::str).filter(|c| !c.trim().is_empty())
 }
 
+/// A generated connector child is identified by one exact template GUID, not its array position.
+fn connector_record<'a>(v: &View<'a>, field: &str, local_id: u32) -> Option<&'a Kv<'a>> {
+    v.get(field)?.get("overrides")?.list().iter().find(|row| {
+        row.get("guidPath").and_then(|path| path.get("guids")).map(Kv::list).is_some_and(|guids| {
+            guids.len() == 1 && num(&guids[0], "sessionID") == Some(40_000_000.0) && num(&guids[0], "localID") == Some(f64::from(local_id))
+        })
+    })
+}
+
+fn connector_has_saved_label(v: &View<'_>) -> bool {
+    own_text(v).is_some()
+        || connector_record(v, "nodeGenerationData", 1)
+            .and_then(|r| r.get("textData"))
+            .and_then(|d| d.get("characters"))
+            .and_then(Kv::str)
+            .is_some_and(|s| !s.trim().is_empty())
+}
+
+fn valid_size(value: Option<&Kv<'_>>) -> Option<(f64, f64)> {
+    let x = num(value?, "x")?;
+    let y = num(value?, "y")?;
+    (x.is_finite() && y.is_finite() && x >= 0.0 && y >= 0.0).then_some((x, y))
+}
+
 /// The REST name of a stroke cap.
 fn cap_name(cap: &str) -> &str {
     match cap {
@@ -1573,7 +2589,7 @@ fn paint_bound(p: &Kv) -> bool {
     alias(p.get("colorVar")).is_some() || p.get("stopsVar").map(Kv::list).unwrap_or_default().iter().any(|s| alias(s.get("colorVar")).is_some())
 }
 
-fn paint(p: &Kv) -> Option<Value> {
+fn paint(p: &Kv, warn: &mut dyn FnMut(String)) -> Option<Value> {
     let ty = p.get("type").and_then(Kv::str)?;
     let mut o = Obj::new();
     o.insert("type".into(), json!(ty));
@@ -1642,6 +2658,52 @@ fn paint(p: &Kv) -> Option<Value> {
             if let Some(r) = num(p, "rotation") {
                 o.insert("rotation".into(), json!(r));
             }
+            match (p.get("filterColorAdjust"), p.get("paintFilter")) {
+                (Some(_), Some(_)) => {
+                    warn("image filters are ambiguous because both filter containers are present; filter conversion was skipped".into())
+                }
+                (Some(_), None) => warn("legacy image filter container is unsupported; filter conversion was skipped".into()),
+                (None, Some(filters)) => {
+                    let mut mapped = Obj::new();
+                    let fields = [
+                        ("exposure", "exposure"),
+                        ("contrast", "contrast"),
+                        ("vibrance", "saturation"),
+                        ("temperature", "temperature"),
+                        ("tint", "tint"),
+                        ("highlights", "highlights"),
+                        ("shadows", "shadows"),
+                    ];
+                    if let Kv::Object(values) = filters {
+                        for (source, target) in fields {
+                            if let Some(value) = filters.get(source) {
+                                match filter_number(value) {
+                                    Some(value) => {
+                                        mapped.insert(target.into(), json!(value));
+                                    }
+                                    None => warn(format!("malformed image filter `{source}` was skipped")),
+                                }
+                            }
+                        }
+                        for (name, value) in values {
+                            if fields.iter().any(|(known, _)| *known == *name) {
+                                continue;
+                            }
+                            match filter_number(value) {
+                                Some(0.0) => {}
+                                Some(_) => warn(format!("nonzero unsupported image filter `{}` was skipped", crate::rest::props::clip_str(name))),
+                                None => warn(format!("malformed unsupported image filter `{}` was skipped", crate::rest::props::clip_str(name))),
+                            }
+                        }
+                    } else {
+                        warn("malformed image paintFilter container was skipped".into());
+                    }
+                    if !mapped.is_empty() {
+                        o.insert("filters".into(), Value::Object(mapped));
+                    }
+                }
+                (None, None) => {}
+            }
         }
         _ => {}
     }
@@ -1671,6 +2733,32 @@ fn tracks(v: &View, key: &str) -> Vec<String> {
     t.into_iter().map(|e| e.1).collect()
 }
 
+/// Convert only unconstrained tracks, whose min and max sizing functions agree.
+fn grid_track_sizing(size: Option<&Kv<'_>>) -> Option<Value> {
+    let size = size?;
+    let min = size.get("minSizing")?;
+    let max = size.get("maxSizing")?;
+    let min_type = min.get("type").and_then(Kv::str)?;
+    let max_type = max.get("type").and_then(Kv::str)?;
+    if min_type != max_type {
+        return None;
+    }
+    match min_type {
+        "FIXED" => {
+            let px = num(min, "value")?;
+            let max_px = num(max, "value")?;
+            (px == max_px && px.is_finite() && (0.0..=MAX_GRID_TRACK_VALUE).contains(&px)).then(|| json!({"sizing": "fixed", "value": px}))
+        }
+        "FLEX" => {
+            let fr = num(min, "value")?;
+            let max_fr = num(max, "value")?;
+            (fr == max_fr && fr.is_finite() && fr > 0.0 && fr <= MAX_GRID_TRACK_VALUE).then(|| json!({"sizing": "fill", "value": fr}))
+        }
+        "HUG" => Some(json!({"sizing": "hug", "value": 0.0})),
+        _ => None,
+    }
+}
+
 /// The variable an `ALIAS` variable data points at.
 fn alias(d: Option<&Kv>) -> Option<String> {
     let d = d?;
@@ -1697,9 +2785,45 @@ fn variable_value(d: &Kv) -> Option<Value> {
     v.get("textValue").and_then(Kv::str).map(|s| json!(s))
 }
 
+/// Per-character styles of text data `td` (`characterStyleIDs` + `styleOverrideTable`) as REST
+/// `characterStyleOverrides` + `styleOverrideTable`; `size`: the base font size.
+fn char_styles(o: &mut Obj, td: &Kv, size: Option<f64>, warn: &mut dyn FnMut(String)) {
+    let ids: Vec<u64> = td.get("characterStyleIDs").map(Kv::list).unwrap_or_default().iter().filter_map(Kv::f64).map(|i| i as u64).collect();
+    if ids.iter().all(|i| *i == 0) {
+        return;
+    }
+    let mut table = Obj::new();
+    for e in td.get("styleOverrideTable").map(Kv::list).unwrap_or_default() {
+        let Some(sid) = num(e, "styleID") else { continue };
+        let mut s = text_style(&View::of(e), size);
+        if let Some(fills) = e.get("fillPaints") {
+            s.insert("fills".into(), Value::Array(fills.list().iter().filter_map(|p| paint(p, warn)).collect()));
+        }
+        table.insert((sid as u64).to_string(), Value::Object(s));
+    }
+    o.insert("characterStyleOverrides".into(), json!(ids));
+    o.insert("styleOverrideTable".into(), Value::Object(table));
+}
+
 /// The text of a component property value.
 fn prop_text<'k>(v: &'k Kv) -> Option<&'k str> {
-    v.get("textValue").and_then(|t| t.get("characters")).and_then(Kv::str)
+    prop_text_data(v).and_then(|t| t.get("characters")).and_then(Kv::str)
+}
+
+/// The text data of a component property value: `textValue`, or `textDataValue` in the variable form.
+fn prop_text_data<'k, 's>(v: &'k Kv<'s>) -> Option<&'k Kv<'s>> {
+    v.get("textValue").or_else(|| v.get("textDataValue"))
+}
+
+/// The main an instance swap value names: `guidValue`, or `symbolIdValue` in the variable form.
+fn prop_guid(v: &Kv) -> Option<String> {
+    v.get("guidValue").and_then(guid).or_else(|| v.get("symbolIdValue")?.get("guid").and_then(guid))
+}
+
+/// The value a component property assignment sets: `value`, or the variable form `varValue` holds
+/// when `value` is empty, as current files write many booleans and instance swaps.
+fn assigned<'k, 's>(assignment: &'k Kv<'s>) -> Option<&'k Kv<'s>> {
+    assignment.get("value").filter(|v| !matches!(v, Kv::Object(fields) if fields.is_empty())).or_else(|| assignment.get("varValue")?.get("value"))
 }
 
 /// The property a layer's `field` is bound to (`parameterConsumptionMap`).
@@ -1727,14 +2851,23 @@ fn text_style(v: &View, size: Option<f64>) -> Obj {
     copy_num(&mut s, v, "fontSize", "fontSize");
     copy_num(&mut s, v, "paragraphSpacing", "paragraphSpacing");
     copy_num(&mut s, v, "paragraphIndent", "paragraphIndent");
+    insert_text_options(&mut s, v);
     copy_str(&mut s, v, "textCase", "textCase");
     copy_str(&mut s, v, "textDecoration", "textDecoration");
+    if let Some(skip_ink) = v.flag("textDecorationSkipInk") {
+        s.insert("textDecorationSkipInk".into(), json!(skip_ink));
+    }
+    copy_str(&mut s, v, "leadingTrim", "leadingTrim");
     let font_size = v.num("fontSize").or(size).unwrap_or(12.0);
     if let Some(ls) = v.get("letterSpacing") {
         let val = num(ls, "value").unwrap_or(0.0);
         let px = match ls.get("units").and_then(Kv::str) {
             Some("PIXELS") => val,
-            Some("PERCENT") => val / 100.0 * font_size,
+            Some("PERCENT") => {
+                // Private (read by `rest/text.rs`): REST spacing is in pixels; keep the percent.
+                s.insert("_letterSpacingPercent".into(), json!(val));
+                val / 100.0 * font_size
+            }
             _ => val * font_size,
         };
         s.insert("letterSpacing".into(), json!(px));
diff --git a/crates/format/src/fig/map_connector_snapshot_budget_tests.rs b/crates/format/src/fig/map_connector_snapshot_budget_tests.rs
new file mode 100644
index 000000000..ca47578da
--- /dev/null
+++ b/crates/format/src/fig/map_connector_snapshot_budget_tests.rs
@@ -0,0 +1,146 @@
+//! Connector snapshot flattening stays within the node and depth budgets.
+
+use super::{MAX_DEPTH, Mapper, View};
+use crate::fig::kiwi::Kv;
+use crate::rest::MAX_NODES;
+use figcraft_doc::geom::Affine;
+
+fn obj(fields: Vec<(&'static str, Kv<'static>)>) -> Kv<'static> {
+    Kv::Object(fields)
+}
+
+fn guid(local_id: u64) -> Kv<'static> {
+    obj(vec![("sessionID", Kv::Uint(40_000_000)), ("localID", Kv::Uint(local_id))])
+}
+
+fn path_blob() -> Vec<u8> {
+    let mut bytes = vec![1];
+    bytes.extend(0.0f32.to_le_bytes());
+    bytes.extend(0.0f32.to_le_bytes());
+    bytes.push(2);
+    bytes.extend(20.0f32.to_le_bytes());
+    bytes.extend(10.0f32.to_le_bytes());
+    bytes
+}
+
+fn record(local_id: u64, mut fields: Vec<(&'static str, Kv<'static>)>) -> Kv<'static> {
+    fields.push(("guidPath", obj(vec![("guids", Kv::Array(vec![guid(local_id)]))])));
+    obj(fields)
+}
+
+fn message() -> Kv<'static> {
+    let line = record(
+        0,
+        vec![
+            (
+                "transform",
+                obj(vec![
+                    ("m00", Kv::Float(1.0)),
+                    ("m01", Kv::Float(0.0)),
+                    ("m02", Kv::Float(0.0)),
+                    ("m10", Kv::Float(0.0)),
+                    ("m11", Kv::Float(1.0)),
+                    ("m12", Kv::Float(0.0)),
+                ]),
+            ),
+            ("size", obj(vec![("x", Kv::Float(20.0)), ("y", Kv::Float(10.0))])),
+            ("fillGeometry", Kv::Array(vec![obj(vec![("commandsBlob", Kv::Uint(0))])])),
+        ],
+    );
+    let text = record(
+        1,
+        vec![
+            (
+                "transform",
+                obj(vec![
+                    ("m00", Kv::Float(1.0)),
+                    ("m01", Kv::Float(0.0)),
+                    ("m02", Kv::Float(0.0)),
+                    ("m10", Kv::Float(0.0)),
+                    ("m11", Kv::Float(1.0)),
+                    ("m12", Kv::Float(0.0)),
+                ]),
+            ),
+            ("size", obj(vec![("x", Kv::Float(50.0)), ("y", Kv::Float(20.0))])),
+        ],
+    );
+    let background = record(
+        2,
+        vec![
+            (
+                "transform",
+                obj(vec![
+                    ("m00", Kv::Float(1.0)),
+                    ("m01", Kv::Float(0.0)),
+                    ("m02", Kv::Float(0.0)),
+                    ("m10", Kv::Float(0.0)),
+                    ("m11", Kv::Float(1.0)),
+                    ("m12", Kv::Float(0.0)),
+                ]),
+            ),
+            ("size", obj(vec![("x", Kv::Float(60.0)), ("y", Kv::Float(30.0))])),
+        ],
+    );
+    let line_style = record(0, vec![]);
+    let text_style = record(1, vec![("textData", obj(vec![("characters", Kv::Str("budget label".into()))]))]);
+    let background_style = record(2, vec![("fillPaints", Kv::Array(vec![]))]);
+    obj(vec![
+        (
+            "nodeChanges",
+            Kv::Array(vec![obj(vec![
+                ("guid", obj(vec![("sessionID", Kv::Uint(1)), ("localID", Kv::Uint(123))])),
+                ("type", Kv::Enum("CONNECTOR")),
+                ("name", Kv::Str("budget connector".into())),
+                ("connectorType", Kv::Enum("MANUAL")),
+                ("connectorVersion", Kv::Float(1.0)),
+                ("connectorLineStyle", Kv::Enum("STRAIGHT")),
+                ("derivedImmutableFrameData", obj(vec![("version", Kv::Float(1.0)), ("overrides", Kv::Array(vec![line, text, background]))])),
+                ("nodeGenerationData", obj(vec![("overrides", Kv::Array(vec![line_style, text_style, background_style]))])),
+            ])]),
+        ),
+        ("blobs", Kv::Array(vec![obj(vec![("bytes", Kv::Bytes(path_blob()))])])),
+    ])
+}
+
+#[test]
+fn connector_snapshot_respects_last_and_zero_child_slots() {
+    let message = message();
+    let node = message.get("nodeChanges").unwrap().list().first().unwrap();
+    let view = View::of(node);
+    let mut mapper = Mapper::new(&message, MAX_NODES);
+    mapper.count = MAX_NODES - 1;
+    let children = mapper.connector_snapshot_children(&view, "1:123");
+    assert_eq!(children.len(), 1, "the final available slot preserves the saved vector");
+    assert_eq!(children[0]["type"], "VECTOR");
+    assert!(!children[0]["fillGeometry"].as_array().unwrap().is_empty(), "saved outline survives the budget limit");
+    assert_eq!(children[0]["fillGeometry"][0]["path"], "M 0 0 L 20 10");
+    assert_eq!(mapper.count, MAX_NODES);
+    assert!(mapper.warnings.iter().any(|warning| warning == &format!("the file has more than {MAX_NODES} layers; connector label was skipped")));
+
+    let mut mapper = Mapper::new(&message, MAX_NODES);
+    mapper.count = MAX_NODES;
+    let children = mapper.connector_snapshot_children(&view, "1:123");
+    assert!(children.is_empty());
+    assert_eq!(mapper.count, MAX_NODES, "the node budget is never exceeded");
+    assert!(mapper.warnings.iter().any(|warning| warning.contains("connector snapshot children were skipped")));
+}
+
+#[test]
+fn connector_snapshot_flattens_vector_at_depth_and_node_limits() {
+    let message = message();
+    let mut mapper = Mapper::new(&message, MAX_NODES);
+    let depth_limited = mapper.layer("1:123", None, Affine::IDENTITY, None, None, MAX_DEPTH).expect("terminal connector");
+    assert_eq!(depth_limited["type"], "VECTOR");
+    assert!(!depth_limited["fillGeometry"].as_array().unwrap().is_empty());
+    assert!(depth_limited.get("children").is_none());
+    assert!(mapper.warnings.iter().any(|warning| warning == "connector label was skipped: depth limit prevents nested snapshot children"));
+
+    let mut mapper = Mapper::new(&message, MAX_NODES);
+    mapper.count = MAX_NODES - 1;
+    let budget_limited = mapper.layer("1:123", None, Affine::IDENTITY, None, None, 0).expect("last allowed connector");
+    assert_eq!(budget_limited["type"], "VECTOR");
+    assert!(!budget_limited["fillGeometry"].as_array().unwrap().is_empty());
+    assert!(budget_limited.get("children").is_none());
+    assert_eq!(mapper.count, MAX_NODES);
+    assert!(mapper.warnings.iter().any(|warning| warning == "connector label was skipped: node budget prevents nested snapshot children"));
+}
diff --git a/crates/format/src/fig/map_image_filter_tests.rs b/crates/format/src/fig/map_image_filter_tests.rs
new file mode 100644
index 000000000..a8db39a77
--- /dev/null
+++ b/crates/format/src/fig/map_image_filter_tests.rs
@@ -0,0 +1,27 @@
+//! Malformed image paint filters are skipped with a warning.
+
+use super::*;
+
+#[test]
+fn malformed_non_finite_filter_is_skipped_with_warning() {
+    let paint = Kv::Object(vec![("type", Kv::Enum("IMAGE")), ("paintFilter", Kv::Object(vec![("exposure", Kv::Float(f32::NAN))]))]);
+    let mut warnings = Vec::new();
+    let value = super::paint(&paint, &mut |warning| warnings.push(warning)).unwrap();
+    assert!(value.get("filters").is_none(), "{value}");
+    assert!(warnings.iter().any(|warning| warning.contains("malformed image filter `exposure`")), "{warnings:?}");
+}
+
+#[test]
+fn boolean_filter_values_are_malformed_even_when_false() {
+    for (field, value, expected_warning) in [
+        ("exposure", Kv::Bool(true), "malformed image filter `exposure`"),
+        ("exposure", Kv::Bool(false), "malformed image filter `exposure`"),
+        ("mystery", Kv::Bool(false), "malformed unsupported image filter `mystery`"),
+    ] {
+        let paint = Kv::Object(vec![("type", Kv::Enum("IMAGE")), ("paintFilter", Kv::Object(vec![(field, value)]))]);
+        let mut warnings = Vec::new();
+        let value = super::paint(&paint, &mut |warning| warnings.push(warning)).unwrap();
+        assert!(value.get("filters").is_none(), "{value}");
+        assert!(warnings.iter().any(|warning| warning.contains(expected_warning)), "{warnings:?}");
+    }
+}
diff --git a/crates/format/src/fig/mod.rs b/crates/format/src/fig/mod.rs
index ec2a0e23a..4c103d088 100644
--- a/crates/format/src/fig/mod.rs
+++ b/crates/format/src/fig/mod.rs
@@ -6,12 +6,17 @@
 //! zstd: a binary schema in the kiwi format ([`kiwi`]), then a message encoded with it. Every file
 //! carries its own schema, so the message is decoded generically and read by field name: a list
 //! of node changes (each with its id, parent id and position among its siblings) that make up the
-//! layer tree, plus blobs (vector outlines and editable vector networks, [`network`]). [`map`]
+//! layer tree, plus blobs (vector outlines and editable vector networks, [`network`], and the bytes
+//! of images that travel inside the message, [`embedded_images`]). [`map`]
 //! turns that into the REST API file JSON shape and the REST importer builds the document, so both
 //! imports share one mapping. Layer kinds the editor doesn't have (sticky notes, connectors,
 //! tables, …) come in as the closest frames, text and vectors. Anything not understood is skipped
 //! with a warning; malformed input never panics.
 
+#[cfg(test)]
+mod auto_layout_sizing_tests;
+#[cfg(test)]
+mod connector_label_tests;
 mod export;
 #[cfg(test)]
 mod export_tests;
@@ -21,8 +26,24 @@ pub mod kiwi;
 mod map;
 mod network;
 #[cfg(test)]
+mod prop_value_tests;
+#[cfg(test)]
+mod slot_tests;
+#[cfg(test)]
+mod source_identity_tests;
+#[cfg(test)]
 mod tests;
+#[cfg(test)]
+mod text_paragraph_tests;
+mod text_path;
+#[cfg(test)]
+mod text_path_tests;
+#[cfg(test)]
+mod text_skip_ink_tests;
+#[cfg(test)]
+mod text_style_tests;
 
+use std::collections::BTreeMap;
 use std::io::Read;
 
 use figcraft_doc::Document;
@@ -30,7 +51,7 @@ use figcraft_doc::Document;
 pub use export::export;
 
 use crate::FormatError;
-use kiwi::Schema;
+use kiwi::{Kv, Schema};
 
 /// Largest `canvas.fig` member read, and largest decompressed chunk.
 const MAX_CANVAS: u64 = 256 * 1024 * 1024;
@@ -39,6 +60,18 @@ const MAX_CHUNK: u64 = 512 * 1024 * 1024;
 const MAX_IMAGE: u64 = 256 * 1024 * 1024;
 /// Most chunks read from `canvas.fig`.
 const MAX_CHUNKS: usize = 16;
+/// Most layers imported from a `.fig` file: one per [`PACKED_BYTES_PER_LAYER`] bytes of its
+/// compressed canvas, at least the REST import's cap and at most [`MAX_FIG_NODES`]. Instances
+/// expand into a layer per layer of their component, and chunks inflate up to [`MAX_CHUNK`], so the
+/// budget follows what the file takes, not what it unpacks to: a small file can't claim a large
+/// count, however it's built; a large one gets room.
+const PACKED_BYTES_PER_LAYER: usize = 32;
+const MAX_FIG_NODES: usize = 2_000_000;
+
+/// Most layers imported from a `.fig` file whose compressed canvas is `packed` bytes.
+pub(crate) fn layer_budget(packed: usize) -> usize {
+    (packed / PACKED_BYTES_PER_LAYER).clamp(crate::rest::MAX_NODES, MAX_FIG_NODES)
+}
 
 /// Whether `bytes` look like a `.fig` file: a zip holding `canvas.fig`, or a bare canvas.
 pub fn is_fig(bytes: &[u8]) -> bool {
@@ -57,14 +90,24 @@ pub fn try_import(bytes: &[u8], name: &str) -> Option<Result<(Document, Vec<Stri
 /// Build a document from a `.fig` file. Returns it with the warnings about what was skipped or
 /// approximated. `name`: the document name when the file doesn't carry one.
 pub fn import(bytes: &[u8], name: &str) -> Result<(Document, Vec<String>), FormatError> {
-    let archive = Archive::open(bytes)?;
-    let (schema, message) = decode_canvas(&archive.canvas)?;
+    let mut archive = Archive::open(bytes)?;
+    // The budgets follow the compressed canvas, which the file itself bounds (its zip member may
+    // inflate too).
+    let packed = archive.canvas.len().min(bytes.len());
+    // Each stage's input is dropped as soon as the next one is built: in a large file every one
+    // of them takes gigabytes, and holding them all at once runs out of memory.
+    let (schema, message) = decode_canvas(&std::mem::take(&mut archive.canvas))?;
     let root = schema.find("Message").ok_or_else(|| corrupt("the schema has no Message definition"))?;
-    let msg = schema.decode_message(root, &message).map_err(|e| corrupt(e.to_string()))?;
+    let msg = schema.decode_message_within(root, &message, kiwi::value_budget(packed)).map_err(|e| corrupt(e.to_string()))?;
+    let max_nodes = layer_budget(packed);
+    drop(message);
     let file_name = archive.file_name.as_deref().filter(|n| !n.trim().is_empty()).unwrap_or(name);
-    let (json, mut warnings) = map::to_rest(&msg, file_name);
-    let images = |r: &str| archive.image(r);
-    let (doc, more) = crate::rest::import(&json, &images)?;
+    let (json, mut warnings, networks) = map::to_rest(&msg, file_name, max_nodes);
+    // The message goes before the layers are built, so the images it carries are copied out first.
+    let embedded: BTreeMap<String, Vec<u8>> = embedded_images(&msg).into_iter().map(|(hash, bytes)| (hash, bytes.to_vec())).collect();
+    drop(msg);
+    let images = |r: &str| archive.image(r).or_else(|| embedded.get(r).cloned());
+    let (doc, more) = crate::rest::import_with_networks(&json, &images, networks, max_nodes)?;
     warnings.extend(more.into_iter().filter_map(map::adapt_warning));
     Ok((doc, warnings))
 }
@@ -94,6 +137,41 @@ fn corrupt(msg: impl Into<String>) -> FormatError {
     FormatError::Corrupt(format!(".fig file: {}", msg.into()))
 }
 
+/// Image bytes that travel inside the message, by image hash (lowercase hex): a paint's
+/// `image.dataBlob` indexes the message's `blobs`. Copies written by plugins and other tools embed
+/// their images this way, and a bare canvas (what the clipboard carries) has no `images/`. The
+/// walk is iterative (no recursion on nested data) and skips blobs larger than [`MAX_IMAGE`]. The
+/// bytes stay borrowed from the message.
+fn embedded_images<'m>(msg: &'m Kv) -> BTreeMap<String, &'m [u8]> {
+    let blobs = msg.get("blobs").map(Kv::list).unwrap_or_default();
+    let mut found = BTreeMap::new();
+    let mut pending = vec![msg];
+    while let Some(value) = pending.pop() {
+        match value {
+            Kv::Object(fields) => {
+                if let Some((hash, bytes)) = value.get("image").and_then(|image| embedded_image(image, blobs)) {
+                    found.entry(hash).or_insert(bytes);
+                }
+                pending.extend(fields.iter().filter(|(name, _)| *name != "blobs").map(|(_, field)| field));
+            }
+            Kv::Array(items) => pending.extend(items),
+            _ => {}
+        }
+    }
+    found
+}
+
+/// The hash and bytes of an `Image` value whose `dataBlob` points at a usable blob.
+fn embedded_image<'k>(image: &Kv, blobs: &'k [Kv]) -> Option<(String, &'k [u8])> {
+    let hash = image.get("hash").and_then(Kv::bytes).filter(|h| !h.is_empty() && h.len() <= 64)?;
+    let Some(Kv::Uint(index)) = image.get("dataBlob") else { return None };
+    let bytes = blobs.get(usize::try_from(*index).ok()?)?.get("bytes").and_then(Kv::bytes)?;
+    if bytes.is_empty() || bytes.len() as u64 > MAX_IMAGE {
+        return None;
+    }
+    Some((hash.iter().map(|b| format!("{b:02x}")).collect(), bytes))
+}
+
 /// The parts of a `.fig` archive the import reads.
 struct Archive<'b> {
     canvas: Vec<u8>,
diff --git a/crates/format/src/fig/network.rs b/crates/format/src/fig/network.rs
index 112a767a4..ccb5c2913 100644
--- a/crates/format/src/fig/network.rs
+++ b/crates/format/src/fig/network.rs
@@ -17,6 +17,7 @@ pub(super) struct Vertex {
 }
 
 pub(super) struct Segment {
+    pub style: u32,
     pub a: usize,
     pub ta: (f64, f64),
     pub b: usize,
@@ -76,8 +77,8 @@ pub(super) fn decode(b: &[u8]) -> Option<Network> {
         net.vertices.push(Vertex { style: r.u32()?, x: r.f32()?, y: r.f32()? });
     }
     for _ in 0..ns {
-        r.u32()?;
-        net.segments.push(Segment { a: r.index(nv)?, ta: (r.f32()?, r.f32()?), b: r.index(nv)?, tb: (r.f32()?, r.f32()?) });
+        let style = r.u32()?;
+        net.segments.push(Segment { style, a: r.index(nv)?, ta: (r.f32()?, r.f32()?), b: r.index(nv)?, tb: (r.f32()?, r.f32()?) });
     }
     let mut entries = 0usize;
     for _ in 0..nr {
@@ -110,7 +111,7 @@ pub(super) fn encode(net: &Network) -> Vec<u8> {
         fl(v.y, &mut out);
     }
     for s in &net.segments {
-        u(0, &mut out);
+        u(s.style, &mut out);
         u(s.a as u32, &mut out);
         fl(s.ta.0, &mut out);
         fl(s.ta.1, &mut out);
diff --git a/crates/format/src/fig/prop_value_tests.rs b/crates/format/src/fig/prop_value_tests.rs
new file mode 100644
index 000000000..24248d32a
--- /dev/null
+++ b/crates/format/src/fig/prop_value_tests.rs
@@ -0,0 +1,188 @@
+//! Component properties as current `.fig` files write them, on synthetic messages: the copy of a
+//! set's definitions each variant keeps (`parentPropDefId`, no name or type of its own), and
+//! assignments that carry their value only in the variable form (`varValue`).
+
+use figcraft_doc::NodeKind;
+use serde_json::Value;
+
+use super::kiwi::Kv;
+use super::map::to_rest;
+
+fn g(local: u32) -> Kv<'static> {
+    Kv::Object(vec![("sessionID", Kv::Uint(9)), ("localID", Kv::Uint(u64::from(local)))])
+}
+
+fn o(fields: Vec<(&'static str, Kv<'static>)>) -> Kv<'static> {
+    Kv::Object(fields)
+}
+
+fn s(text: &str) -> Kv<'static> {
+    Kv::Str(text.into())
+}
+
+fn node(local: u32, kind: &'static str, name: &str, parent: Option<u32>, mut fields: Vec<(&'static str, Kv<'static>)>) -> Kv<'static> {
+    let mut all = vec![("guid", g(local)), ("type", Kv::Enum(kind)), ("name", s(name))];
+    if let Some(parent) = parent {
+        all.push(("parentIndex", o(vec![("guid", g(parent)), ("position", s("!"))])));
+    }
+    all.append(&mut fields);
+    o(all)
+}
+
+/// A layer's `field` bound to property definition `def`.
+fn bound(field: &'static str, def: u32) -> (&'static str, Kv<'static>) {
+    let entry = o(vec![
+        ("variableField", Kv::Enum(field)),
+        ("variableData", o(vec![("value", o(vec![("propRefValue", o(vec![("defId", g(def))]))])), ("dataType", Kv::Enum("PROP_REF"))])),
+    ]);
+    ("parameterConsumptionMap", o(vec![("entries", Kv::Array(vec![entry]))]))
+}
+
+fn definition(id: u32, name: &str, kind: &'static str, initial: Kv<'static>) -> Kv<'static> {
+    o(vec![("id", g(id)), ("name", s(name)), ("type", Kv::Enum(kind)), ("initialValue", initial)])
+}
+
+/// An assignment of `def` that leaves `value` empty and says it in `varValue` only.
+fn variable_assignment(def: u32, data_type: &'static str, value: Kv<'static>) -> Kv<'static> {
+    o(vec![
+        ("defID", g(def)),
+        ("value", o(vec![])),
+        ("varValue", o(vec![("value", value), ("dataType", Kv::Enum(data_type)), ("resolvedDataType", Kv::Enum(data_type))])),
+    ])
+}
+
+fn message(nodes: Vec<Kv<'static>>) -> Kv<'static> {
+    let mut all = vec![node(1, "DOCUMENT", "Document", None, vec![]), node(2, "CANVAS", "Page", Some(1), vec![])];
+    all.extend(nodes);
+    o(vec![("nodeChanges", Kv::Array(all))])
+}
+
+fn by_id<'v>(v: &'v Value, id: &str) -> &'v Value {
+    fn find<'v>(v: &'v Value, id: &str) -> Option<&'v Value> {
+        if v.get("id").and_then(Value::as_str) == Some(id) {
+            return Some(v);
+        }
+        v.get("children").and_then(Value::as_array).into_iter().flatten().find_map(|v| find(v, id))
+    }
+    find(v, id).unwrap_or_else(|| panic!("no layer {id}"))
+}
+
+fn instance_props(doc: &figcraft_doc::Document) -> &std::collections::BTreeMap<String, Value> {
+    let instance = doc.ids().filter_map(|id| doc.node(id)).find(|n| n.name == "Instance").unwrap();
+    let NodeKind::Instance { props, .. } = &instance.kind else { panic!("not an instance") };
+    props
+}
+
+/// A "Field" set with a BOOL definition (9:70), a variant whose "Hint text" reads its copy (9:71),
+/// and an instance of the variant that sets the property false through definition `assigned`.
+fn field_set(assigned: u32) -> Kv<'static> {
+    message(vec![
+        node(
+            9,
+            "FRAME",
+            "Field",
+            Some(2),
+            vec![
+                ("isStateGroup", Kv::Bool(true)),
+                ("componentPropDefs", Kv::Array(vec![definition(70, "Hint", "BOOL", o(vec![("boolValue", Kv::Bool(true))]))])),
+            ],
+        ),
+        node(
+            10,
+            "SYMBOL",
+            "State=Default",
+            Some(9),
+            vec![("componentPropDefs", Kv::Array(vec![o(vec![("id", g(71)), ("parentPropDefId", g(70))])]))],
+        ),
+        node(11, "TEXT", "Hint text", Some(10), vec![bound("VISIBLE", 71)]),
+        node(
+            20,
+            "INSTANCE",
+            "Instance",
+            Some(2),
+            vec![
+                ("symbolData", o(vec![("symbolID", g(10))])),
+                ("componentPropAssignments", Kv::Array(vec![o(vec![("defID", g(assigned)), ("value", o(vec![("boolValue", Kv::Bool(false))]))])])),
+            ],
+        ),
+    ])
+}
+
+#[test]
+fn variant_layers_bind_to_the_set_properties_their_copies_name() {
+    let msg = field_set(71);
+    let (rest, _, _) = to_rest(&msg, "Synthetic", crate::rest::MAX_NODES);
+    assert_eq!(by_id(&rest["document"], "9:9")["componentPropertyDefinitions"]["Hint#9:70"]["type"], "BOOLEAN");
+    assert_eq!(by_id(&rest["document"], "9:11")["componentPropertyReferences"]["visible"], "Hint#9:70");
+    assert_eq!(by_id(&rest["document"], "9:20")["componentProperties"]["Hint#9:70"]["value"], false);
+
+    let (doc, _) = crate::rest::import_fig(&rest, &crate::rest::no_images).unwrap();
+    let hint = doc.ids().filter_map(|id| doc.node(id)).find(|n| n.name == "Hint text" && n.source.is_none()).unwrap();
+    assert_eq!(hint.prop_refs.get("visible").map(String::as_str), Some("Hint"));
+    assert_eq!(instance_props(&doc).get("Hint"), Some(&Value::Bool(false)));
+}
+
+/// An assignment reaches layers that read another copy of its definition: here the instance sets
+/// the set's own definition while the variant's layer reads the variant's copy.
+#[test]
+fn assignments_reach_layers_that_read_another_copy_of_their_definition() {
+    let (rest, _, _) = to_rest(&field_set(70), "Synthetic", crate::rest::MAX_NODES);
+    let instance = by_id(&rest["document"], "9:20");
+    assert_eq!(instance["componentProperties"]["Hint#9:70"]["value"], false);
+    assert_eq!(by_id(instance, "I9:20;9:11")["visible"], false);
+}
+
+#[test]
+fn property_values_written_only_as_variables_are_applied() {
+    let msg = message(vec![
+        node(
+            10,
+            "SYMBOL",
+            "Field",
+            Some(2),
+            vec![(
+                "componentPropDefs",
+                Kv::Array(vec![
+                    definition(70, "Hint", "BOOL", o(vec![("boolValue", Kv::Bool(true))])),
+                    definition(71, "Label", "TEXT", o(vec![("textValue", o(vec![("characters", s("Label"))]))])),
+                    definition(72, "Icon", "INSTANCE_SWAP", o(vec![("guidValue", g(40))])),
+                ]),
+            )],
+        ),
+        node(11, "TEXT", "Hint text", Some(10), vec![bound("VISIBLE", 70)]),
+        node(12, "TEXT", "Label", Some(10), vec![("textData", o(vec![("characters", s("Label"))])), bound("TEXT_DATA", 71)]),
+        node(13, "INSTANCE", "Icon", Some(10), vec![("symbolData", o(vec![("symbolID", g(40))])), bound("OVERRIDDEN_SYMBOL_ID", 72)]),
+        node(40, "SYMBOL", "Mail", Some(2), vec![]),
+        node(41, "SYMBOL", "Card", Some(2), vec![]),
+        node(
+            20,
+            "INSTANCE",
+            "Instance",
+            Some(2),
+            vec![
+                ("symbolData", o(vec![("symbolID", g(10))])),
+                (
+                    "componentPropAssignments",
+                    Kv::Array(vec![
+                        variable_assignment(70, "BOOLEAN", o(vec![("boolValue", Kv::Bool(false))])),
+                        variable_assignment(71, "TEXT_DATA", o(vec![("textDataValue", o(vec![("characters", s("Name on card"))]))])),
+                        variable_assignment(72, "SYMBOL_ID", o(vec![("symbolIdValue", o(vec![("guid", g(41))]))])),
+                    ]),
+                ),
+            ],
+        ),
+    ]);
+    let (rest, _, _) = to_rest(&msg, "Synthetic", crate::rest::MAX_NODES);
+    let instance = by_id(&rest["document"], "9:20");
+    assert_eq!(instance["componentProperties"]["Hint#9:70"]["value"], false);
+    assert_eq!(instance["componentProperties"]["Label#9:71"]["value"], "Name on card");
+    assert_eq!(instance["componentProperties"]["Icon#9:72"]["value"], "9:41");
+    assert_eq!(by_id(instance, "I9:20;9:11")["visible"], false);
+    assert_eq!(by_id(instance, "I9:20;9:12")["characters"], "Name on card");
+    assert_eq!(by_id(instance, "I9:20;9:13")["componentId"], "9:41");
+
+    let (doc, _) = crate::rest::import_fig(&rest, &crate::rest::no_images).unwrap();
+    let props = instance_props(&doc);
+    assert_eq!(props.get("Hint"), Some(&Value::Bool(false)));
+    assert_eq!(props.get("Label"), Some(&Value::String("Name on card".into())));
+}
diff --git a/crates/format/src/fig/slot_tests.rs b/crates/format/src/fig/slot_tests.rs
new file mode 100644
index 000000000..17c754646
--- /dev/null
+++ b/crates/format/src/fig/slot_tests.rs
@@ -0,0 +1,225 @@
+//! Component slot content from `.fig` files: SLOT definitions, the frames that reference them and
+//! the content subtrees that instances assign, on synthetic messages.
+
+use serde_json::Value;
+
+use super::kiwi::Kv;
+use super::map::to_rest;
+
+fn g(local: u32) -> Kv<'static> {
+    Kv::Object(vec![("sessionID", Kv::Uint(9)), ("localID", Kv::Uint(u64::from(local)))])
+}
+
+fn o(fields: Vec<(&'static str, Kv<'static>)>) -> Kv<'static> {
+    Kv::Object(fields)
+}
+
+fn node(local: u32, kind: &'static str, parent: Option<u32>, mut fields: Vec<(&'static str, Kv<'static>)>) -> Kv<'static> {
+    let mut all = vec![("guid", g(local)), ("type", Kv::Enum(kind)), ("name", Kv::Str("Synthetic".into()))];
+    if let Some(parent) = parent {
+        all.push(("parentIndex", o(vec![("guid", g(parent)), ("position", Kv::Str("!".into()))])));
+    }
+    all.append(&mut fields);
+    o(all)
+}
+
+fn mapped(msg: &Kv<'_>) -> Value {
+    to_rest(msg, "Synthetic resources", crate::rest::MAX_NODES).0
+}
+
+fn named_id<'b>(v: &'b Value, id: &str) -> Option<&'b Value> {
+    if v.get("id").and_then(Value::as_str) == Some(id) {
+        return Some(v);
+    }
+    v.get("children").and_then(Value::as_array).into_iter().flatten().find_map(|v| named_id(v, id))
+}
+
+fn changes<'a>(msg: &'a mut Kv<'static>) -> &'a mut Vec<Kv<'static>> {
+    let Kv::Object(fields) = msg else { panic!() };
+    let (_, Kv::Array(rows)) = fields.iter_mut().find(|(key, _)| *key == "nodeChanges").unwrap() else { panic!() };
+    rows
+}
+
+fn slot_message(content: Option<u32>, preferred: bool) -> Kv<'static> {
+    let slot_ref = o(vec![
+        ("variableField", Kv::Enum("SLOT_CONTENT_ID")),
+        ("variableData", o(vec![("value", o(vec![("propRefValue", o(vec![("defId", g(70))]))]))])),
+    ]);
+    let mut instance_fields = vec![("symbolData", o(vec![("symbolID", g(10))]))];
+    if let Some(content) = content {
+        instance_fields.push((
+            "componentPropAssignments",
+            Kv::Array(vec![o(vec![
+                ("defID", g(70)),
+                ("value", o(vec![])),
+                (
+                    "varValue",
+                    o(vec![
+                        ("value", o(vec![("slotContentIdValue", o(vec![("guid", g(content))]))])),
+                        ("dataType", Kv::Enum("SLOT_CONTENT_ID")),
+                        ("resolvedDataType", Kv::Enum("SLOT_CONTENT_ID")),
+                    ]),
+                ),
+            ])]),
+        ));
+    }
+    let mut definition = vec![("id", g(70)), ("name", Kv::Str("Content".into())), ("type", Kv::Enum("SLOT"))];
+    if preferred {
+        definition.push((
+            "preferredValues",
+            o(vec![("instanceSwapValues", Kv::Array(vec![o(vec![("type", Kv::Enum("COMPONENT")), ("key", Kv::Str("unresolved-key".into()))])]))]),
+        ));
+    }
+    o(vec![(
+        "nodeChanges",
+        Kv::Array(vec![
+            node(1, "DOCUMENT", None, vec![]),
+            node(2, "CANVAS", Some(1), vec![]),
+            node(3, "CANVAS", Some(1), vec![("internalOnly", Kv::Bool(true))]),
+            node(10, "SYMBOL", Some(2), vec![("componentPropDefs", Kv::Array(vec![o(definition)]))]),
+            node(12, "FRAME", Some(10), vec![("parameterConsumptionMap", o(vec![("entries", Kv::Array(vec![slot_ref]))]))]),
+            node(13, "RECTANGLE", Some(12), vec![]),
+            node(20, "INSTANCE", Some(2), instance_fields),
+            node(30, "FRAME", Some(3), vec![("isSlotContent", Kv::Bool(true))]),
+            node(31, "RECTANGLE", Some(30), vec![]),
+            node(32, "ELLIPSE", Some(30), vec![]),
+            node(33, "FRAME", Some(3), vec![("isSlotContent", Kv::Bool(true))]),
+        ]),
+    )])
+}
+#[test]
+fn slot_definition_reference_and_arbitrary_override_children_are_imported() {
+    let rest = mapped(&slot_message(Some(30), false));
+    let main = named_id(&rest["document"], "9:10").unwrap();
+    assert_eq!(main["componentPropertyDefinitions"]["Content#9:70"]["type"], "SLOT");
+    let main_slot = named_id(&rest["document"], "9:12").unwrap();
+    assert_eq!(main_slot["componentPropertyReferences"]["slot"], "Content#9:70");
+    let slot = named_id(&rest["document"], "I9:20;9:12").unwrap();
+    assert!(slot.get("componentPropertyReferences").is_none());
+    assert_eq!(slot[crate::rest::FIG_SOURCE_FIELD]["slotOverride"], true);
+    let kids = slot["children"].as_array().unwrap();
+    assert_eq!(kids.len(), 2);
+    assert_eq!(kids[0]["id"], "I9:20;9:31");
+    assert_eq!(kids[1]["id"], "I9:20;9:32");
+
+    let (doc, warnings) = crate::rest::import_fig(&rest, &crate::rest::no_images).unwrap();
+    assert!(warnings.is_empty(), "{warnings:?}");
+    let main = doc
+        .node(*doc.pages.first().unwrap())
+        .unwrap()
+        .children
+        .iter()
+        .find_map(|id| doc.node(*id).filter(|n| n.name == "Synthetic" && matches!(n.kind, figcraft_doc::NodeKind::Component { .. })))
+        .unwrap();
+    assert!(
+        matches!(&main.kind, figcraft_doc::NodeKind::Component { props, .. } if matches!(props.get("Content"), Some(figcraft_doc::PropDef::Slot { preferred }) if preferred.is_empty()))
+    );
+    let instance = doc.ids().filter_map(|id| doc.node(id)).find(|n| matches!(n.kind, figcraft_doc::NodeKind::Instance { .. })).unwrap();
+    let slot = doc.node(instance.children[0]).unwrap();
+    assert!(!slot.prop_refs.contains_key("slot"));
+    assert_eq!(slot.source, Some(main.children[0]));
+    assert!(slot.overrides.contains("slot"));
+    assert_eq!(slot.children.len(), 2);
+    assert!(slot.children.iter().all(|id| doc.node(*id).is_some_and(|child| child.source.is_none())));
+
+    let (public, _) = crate::rest::import(&rest, &crate::rest::no_images).unwrap();
+    let public_instance = public.ids().filter_map(|id| public.node(id)).find(|n| matches!(n.kind, figcraft_doc::NodeKind::Instance { .. })).unwrap();
+    let public_slot = public.node(public_instance.children[0]).unwrap();
+    assert!(!public_slot.overrides.contains("slot"));
+}
+#[test]
+fn nested_instance_in_own_slot_content_keeps_its_own_source_tree() {
+    let mut msg = slot_message(Some(30), false);
+    let rows = changes(&mut msg);
+    let slot_frame = rows.iter_mut().find(|row| row.get("guid").and_then(|guid| guid.get("localID")).and_then(Kv::f64) == Some(31.0)).unwrap();
+    let Kv::Object(fields) = slot_frame else { panic!() };
+    fields.iter_mut().find(|(key, _)| *key == "type").unwrap().1 = Kv::Enum("FRAME");
+    rows.extend([
+        node(34, "INSTANCE", Some(31), vec![("symbolData", o(vec![("symbolID", g(40))]))]),
+        node(40, "SYMBOL", Some(2), vec![]),
+        node(41, "FRAME", Some(40), vec![]),
+        node(42, "RECTANGLE", Some(41), vec![]),
+    ]);
+
+    let rest = mapped(&msg);
+    let (doc, warnings) = crate::rest::import_fig(&rest, &crate::rest::no_images).unwrap();
+    assert!(warnings.is_empty(), "{warnings:?}");
+    let outer = doc
+        .ids()
+        .filter_map(|id| doc.node(id))
+        .find(|n| {
+            matches!(n.kind, figcraft_doc::NodeKind::Instance { .. })
+                && !doc.ancestors(n.id).iter().any(|a| doc.node(*a).is_some_and(|p| matches!(p.kind, figcraft_doc::NodeKind::Instance { .. })))
+        })
+        .unwrap();
+    let slot = doc.node(outer.children[0]).unwrap();
+    let own_frame = slot.children.iter().filter_map(|id| doc.node(*id)).find(|n| matches!(n.kind, figcraft_doc::NodeKind::Frame)).unwrap();
+    assert!(own_frame.source.is_none());
+
+    let nested = slot
+        .children
+        .iter()
+        .filter_map(|id| doc.node(*id))
+        .flat_map(|n| n.children.iter())
+        .filter_map(|id| doc.node(*id))
+        .find(|n| matches!(n.kind, figcraft_doc::NodeKind::Instance { .. }))
+        .unwrap();
+    let figcraft_doc::NodeKind::Instance { component, .. } = nested.kind else { panic!("not an instance") };
+    assert_eq!(nested.source, Some(component));
+    let main_frame = doc.node(doc.node(component).unwrap().children[0]).unwrap();
+    let expanded_frame = doc.node(nested.children[0]).unwrap();
+    assert_eq!(expanded_frame.source, Some(main_frame.id));
+    assert_eq!(expanded_frame.children.len(), 1);
+    assert_eq!(doc.node(expanded_frame.children[0]).unwrap().source, Some(main_frame.children[0]));
+}
+#[test]
+fn outer_slot_assignment_wins_over_a_nested_instances_own() {
+    let mut msg = slot_message(Some(30), false);
+    let assignment = |content: u32| {
+        Kv::Array(vec![o(vec![
+            ("defID", g(70)),
+            ("value", o(vec![])),
+            (
+                "varValue",
+                o(vec![
+                    ("value", o(vec![("slotContentIdValue", o(vec![("guid", g(content))]))])),
+                    ("dataType", Kv::Enum("SLOT_CONTENT_ID")),
+                    ("resolvedDataType", Kv::Enum("SLOT_CONTENT_ID")),
+                ]),
+            ),
+        ])])
+    };
+    // The nested instance inside the main assigns the empty slot content; the outer instance's content wins.
+    let slot_ref = o(vec![
+        ("variableField", Kv::Enum("SLOT_CONTENT_ID")),
+        ("variableData", o(vec![("value", o(vec![("propRefValue", o(vec![("defId", g(70))]))]))])),
+    ]);
+    changes(&mut msg).extend([
+        node(14, "INSTANCE", Some(10), vec![("symbolData", o(vec![("symbolID", g(40))])), ("componentPropAssignments", assignment(33))]),
+        node(40, "SYMBOL", Some(2), vec![]),
+        node(41, "FRAME", Some(40), vec![("parameterConsumptionMap", o(vec![("entries", Kv::Array(vec![slot_ref]))]))]),
+    ]);
+    let rest = mapped(&msg);
+    let slot = named_id(&rest["document"], "I9:20;9:14;9:41").unwrap();
+    assert_eq!(slot["children"].as_array().map_or(0, Vec::len), 2, "{slot}");
+}
+#[test]
+fn unassigned_slot_keeps_default_and_bad_content_target_warns() {
+    let rest = mapped(&slot_message(None, false));
+    let slot = named_id(&rest["document"], "I9:20;9:12").unwrap();
+    assert_eq!(slot["children"].as_array().unwrap().len(), 1);
+    assert!(slot.get("overrides").is_none());
+
+    let (rest, warnings, _) = to_rest(&slot_message(Some(999), false), "Synthetic", crate::rest::MAX_NODES);
+    assert!(warnings.iter().any(|w| w.contains("slot content assignment target is missing or is not slot content")), "{warnings:?}");
+    let slot = named_id(&rest["document"], "I9:20;9:12").unwrap();
+    assert_eq!(slot["children"].as_array().unwrap().len(), 1);
+
+    let (rest, warnings, _) = to_rest(&slot_message(Some(33), true), "Synthetic", crate::rest::MAX_NODES);
+    let main = named_id(&rest["document"], "9:10").unwrap();
+    assert_eq!(main["componentPropertyDefinitions"]["Content#9:70"]["type"], "SLOT");
+    assert!(warnings.iter().any(|w| w.contains("preferred slot component keys cannot be resolved")), "{warnings:?}");
+    let empty = named_id(&rest["document"], "I9:20;9:12").unwrap();
+    assert_eq!(empty["children"].as_array().map_or(0, Vec::len), 0);
+    assert_eq!(empty[crate::rest::FIG_SOURCE_FIELD]["slotOverride"], true);
+}
diff --git a/crates/format/src/fig/source_identity_tests.rs b/crates/format/src/fig/source_identity_tests.rs
new file mode 100644
index 000000000..927b0227e
--- /dev/null
+++ b/crates/format/src/fig/source_identity_tests.rs
@@ -0,0 +1,1120 @@
+//! Synthetic .fig source identity: cached library components, contextual sources, main switches
+//! and invalid provenance.
+
+use figcraft_doc::color::PaintKind;
+use figcraft_doc::{Document, NodeId, NodeKind, PropDef};
+use serde_json::{Value, json};
+
+use super::kiwi::{Kv, Schema};
+use super::*;
+
+type Fields = Vec<(&'static str, Kv<'static>)>;
+
+fn o(fields: Fields) -> Kv<'static> {
+    Kv::Object(fields)
+}
+
+fn g(id: u64) -> Kv<'static> {
+    o(vec![("sessionID", Kv::Uint(1)), ("localID", Kv::Uint(id))])
+}
+
+fn s(value: &str) -> Kv<'static> {
+    Kv::Str(value.into())
+}
+
+fn matrix(x: f32) -> Kv<'static> {
+    o(vec![
+        ("m00", Kv::Float(1.0)),
+        ("m01", Kv::Float(0.0)),
+        ("m02", Kv::Float(x)),
+        ("m10", Kv::Float(0.0)),
+        ("m11", Kv::Float(1.0)),
+        ("m12", Kv::Float(0.0)),
+    ])
+}
+
+fn node(id: u64, parent: Option<u64>, ty: &'static str, name: &str, more: Fields) -> Kv<'static> {
+    let mut fields = vec![("guid", g(id)), ("phase", Kv::Enum("CREATED")), ("type", Kv::Enum(ty)), ("name", s(name))];
+    if let Some(parent) = parent {
+        fields.push(("parentIndex", o(vec![("guid", g(parent)), ("position", s(&format!("{id:04}")))])));
+    }
+    fields.extend(more);
+    o(fields)
+}
+
+fn symbol(main: u64, overrides: Vec<Kv<'static>>) -> Kv<'static> {
+    o(vec![("symbolID", g(main)), ("symbolOverrides", Kv::Array(overrides))])
+}
+
+fn row(path: &[u64], more: Fields) -> Kv<'static> {
+    let mut fields = vec![("guidPath", o(vec![("guids", Kv::Array(path.iter().map(|id| g(*id)).collect()))]))];
+    fields.extend(more);
+    o(fields)
+}
+
+fn solid(r: f32, g: f32, b: f32) -> Kv<'static> {
+    o(vec![
+        ("type", Kv::Enum("SOLID")),
+        ("color", o(vec![("r", Kv::Float(r)), ("g", Kv::Float(g)), ("b", Kv::Float(b)), ("a", Kv::Float(1.0))])),
+        ("opacity", Kv::Float(1.0)),
+        ("visible", Kv::Bool(true)),
+    ])
+}
+
+fn schema() -> Schema {
+    Schema::parse(export::SCHEMA).unwrap()
+}
+
+fn cached_component_message() -> Kv<'static> {
+    o(vec![(
+        "nodeChanges",
+        Kv::Array(vec![
+            node(1, None, "DOCUMENT", "Document", vec![]),
+            node(2, Some(1), "CANVAS", "Visible page", vec![]),
+            node(
+                3,
+                Some(1),
+                "CANVAS",
+                "Remote library",
+                vec![
+                    ("internalOnly", Kv::Bool(true)),
+                    (
+                        "variableModeBySetMap",
+                        o(vec![("entries", Kv::Array(vec![o(vec![("variableSetID", o(vec![("guid", g(30))])), ("variableModeID", g(52))])]))]),
+                    ),
+                ],
+            ),
+            node(
+                30,
+                Some(3),
+                "VARIABLE_SET",
+                "Remote theme",
+                vec![(
+                    "variableSetModes",
+                    Kv::Array(vec![
+                        o(vec![("id", g(51)), ("name", s("Light")), ("sortPosition", s("!"))]),
+                        o(vec![("id", g(52)), ("name", s("Dark")), ("sortPosition", s("\""))]),
+                    ]),
+                )],
+            ),
+            node(
+                9,
+                Some(3),
+                "FRAME",
+                "Cached component set",
+                vec![("isStateGroup", Kv::Bool(true)), ("size", o(vec![("x", Kv::Float(24.0)), ("y", Kv::Float(24.0))])), ("transform", matrix(0.0))],
+            ),
+            node(
+                10,
+                Some(9),
+                "SYMBOL",
+                "Cached remote icon",
+                vec![("size", o(vec![("x", Kv::Float(24.0)), ("y", Kv::Float(24.0))])), ("transform", matrix(0.0))],
+            ),
+            node(
+                11,
+                Some(10),
+                "ROUNDED_RECTANGLE",
+                "Cached path",
+                vec![("size", o(vec![("x", Kv::Float(24.0)), ("y", Kv::Float(24.0))])), ("transform", matrix(0.0))],
+            ),
+            node(
+                12,
+                Some(10),
+                "INSTANCE",
+                "Nested cached instance",
+                vec![
+                    ("size", o(vec![("x", Kv::Float(12.0)), ("y", Kv::Float(12.0))])),
+                    ("transform", matrix(0.0)),
+                    ("symbolData", symbol(22, vec![row(&[23], vec![("fillPaints", Kv::Array(vec![solid(0.2, 0.7, 0.1)]))])])),
+                ],
+            ),
+            node(
+                13,
+                Some(9),
+                "SYMBOL",
+                "Nested cached main",
+                vec![("size", o(vec![("x", Kv::Float(12.0)), ("y", Kv::Float(12.0))])), ("transform", matrix(0.0))],
+            ),
+            node(
+                14,
+                Some(13),
+                "ROUNDED_RECTANGLE",
+                "Nested cached path",
+                vec![("size", o(vec![("x", Kv::Float(12.0)), ("y", Kv::Float(12.0))])), ("transform", matrix(0.0))],
+            ),
+            node(
+                15,
+                Some(10),
+                "INSTANCE",
+                "Nested internal instance",
+                vec![
+                    ("size", o(vec![("x", Kv::Float(12.0)), ("y", Kv::Float(12.0))])),
+                    ("transform", matrix(0.0)),
+                    ("symbolData", symbol(13, vec![])),
+                ],
+            ),
+            node(
+                20,
+                Some(2),
+                "INSTANCE",
+                "Visible icon instance",
+                vec![
+                    ("size", o(vec![("x", Kv::Float(24.0)), ("y", Kv::Float(24.0))])),
+                    ("transform", matrix(0.0)),
+                    ("symbolData", symbol(10, vec![])),
+                ],
+            ),
+            node(
+                22,
+                Some(2),
+                "SYMBOL",
+                "Visible nested main",
+                vec![("size", o(vec![("x", Kv::Float(12.0)), ("y", Kv::Float(12.0))])), ("transform", matrix(0.0))],
+            ),
+            node(
+                23,
+                Some(22),
+                "ROUNDED_RECTANGLE",
+                "Visible nested path",
+                vec![("size", o(vec![("x", Kv::Float(12.0)), ("y", Kv::Float(12.0))])), ("transform", matrix(0.0))],
+            ),
+        ]),
+    )])
+}
+
+fn cached_component_fixture() -> Vec<u8> {
+    let schema = schema();
+    super::tests::canvas(&schema, &cached_component_message())
+}
+
+fn cached_component_override_fixture() -> Vec<u8> {
+    let mut message = cached_component_message();
+    let Kv::Object(fields) = &mut message else { panic!("cached component fixture has an unexpected wire shape") };
+    let changes = &mut fields.iter_mut().find(|(key, _)| *key == "nodeChanges").unwrap().1;
+    let Kv::Array(nodes) = changes else { panic!("cached component fixture has an unexpected wire shape") };
+    let instance = nodes.iter_mut().find(|node| node.get("name").and_then(Kv::str) == Some("Visible icon instance")).unwrap();
+    let Kv::Object(fields) = instance else { panic!("cached component fixture has an unexpected wire shape") };
+    fields.iter_mut().find(|(key, _)| *key == "symbolData").unwrap().1 =
+        symbol(10, vec![row(&[12], vec![("symbolData", symbol(22, vec![row(&[26], vec![("overriddenSymbolID", g(24))])]))])]);
+    nodes.extend([
+        node(
+            24,
+            Some(3),
+            "SYMBOL",
+            "Overridden cached main",
+            vec![("size", o(vec![("x", Kv::Float(12.0)), ("y", Kv::Float(12.0))])), ("transform", matrix(0.0))],
+        ),
+        node(
+            25,
+            Some(24),
+            "ROUNDED_RECTANGLE",
+            "Overridden cached path",
+            vec![("size", o(vec![("x", Kv::Float(12.0)), ("y", Kv::Float(12.0))])), ("transform", matrix(0.0))],
+        ),
+        node(
+            26,
+            Some(22),
+            "INSTANCE",
+            "Deep cached instance",
+            vec![("size", o(vec![("x", Kv::Float(12.0)), ("y", Kv::Float(12.0))])), ("transform", matrix(0.0)), ("symbolData", symbol(27, vec![]))],
+        ),
+        node(
+            27,
+            Some(3),
+            "SYMBOL",
+            "Base deep main",
+            vec![("size", o(vec![("x", Kv::Float(12.0)), ("y", Kv::Float(12.0))])), ("transform", matrix(0.0))],
+        ),
+        node(
+            28,
+            Some(27),
+            "ROUNDED_RECTANGLE",
+            "Base deep path",
+            vec![("size", o(vec![("x", Kv::Float(12.0)), ("y", Kv::Float(12.0))])), ("transform", matrix(0.0))],
+        ),
+    ]);
+    super::tests::canvas(&schema(), &message)
+}
+
+fn cached_component_default_swap_fixture() -> Vec<u8> {
+    let mut message = cached_component_message();
+    let Kv::Object(fields) = &mut message else { panic!("cached component fixture has an unexpected wire shape") };
+    let changes = &mut fields.iter_mut().find(|(key, _)| *key == "nodeChanges").unwrap().1;
+    let Kv::Array(nodes) = changes else { panic!("cached component fixture has an unexpected wire shape") };
+    let owner = nodes.iter_mut().find(|node| node.get("name").and_then(Kv::str) == Some("Visible nested main")).unwrap();
+    let Kv::Object(fields) = owner else { panic!("cached component fixture has an unexpected wire shape") };
+    fields.push((
+        "componentPropDefs",
+        Kv::Array(vec![o(vec![
+            ("id", g(90)),
+            ("name", s("Icon")),
+            ("type", Kv::Enum("INSTANCE_SWAP")),
+            ("initialValue", o(vec![("guidValue", g(24))])),
+        ])]),
+    ));
+    nodes.extend([
+        node(
+            24,
+            Some(3),
+            "SYMBOL",
+            "Default cached main",
+            vec![("size", o(vec![("x", Kv::Float(12.0)), ("y", Kv::Float(12.0))])), ("transform", matrix(0.0))],
+        ),
+        node(
+            25,
+            Some(24),
+            "ROUNDED_RECTANGLE",
+            "Default cached path",
+            vec![("size", o(vec![("x", Kv::Float(12.0)), ("y", Kv::Float(12.0))])), ("transform", matrix(0.0))],
+        ),
+    ]);
+    super::tests::canvas(&schema(), &message)
+}
+
+fn assert_default_swap(doc: &Document) {
+    let owner = named_node(doc, "Visible nested main");
+    let target = named_node(doc, "Default cached main");
+    let NodeKind::Component { props, .. } = &doc.node(owner).unwrap().kind else { panic!("visible component lost its property definition") };
+    assert_eq!(props.get("Icon"), Some(&PropDef::InstanceSwap { default: target, preferred: Vec::new() }), "{props:?}");
+    assert!(doc.is_remote(target));
+}
+
+fn named_node(doc: &Document, name: &str) -> NodeId {
+    doc.nodes().find(|node| node.name == name).unwrap().id
+}
+
+fn assert_dark_remote_mode(doc: &Document, node: NodeId) {
+    let collection = doc.variables.collections.iter().find(|collection| collection.name == "Remote theme").unwrap();
+    let dark = collection.modes.iter().find(|mode| mode.name == "Dark").unwrap();
+    assert_eq!(doc.modes_for(node).get(&collection.id), Some(&dark.id));
+}
+
+fn assert_no_linked_library_records(doc: &Document) {
+    assert!(doc.libraries.enabled.is_empty());
+    assert!(doc.libraries.components.is_empty());
+    assert!(doc.libraries.styles.is_empty());
+    assert!(doc.libraries.collections.is_empty());
+    assert!(doc.libraries.variables.is_empty());
+}
+
+#[test]
+fn hidden_cached_component_is_retained_and_linked() {
+    let (doc, warnings) = import(&cached_component_fixture(), "Cached library.fig").unwrap();
+    assert!(warnings.is_empty(), "{warnings:?}");
+    assert_eq!(doc.pages.len(), 1, "hidden cache must not become a visible page");
+    let check = |doc: &Document| {
+        let store = doc.library_store().expect("private .fig cache is retained");
+        let component = named_node(doc, "Cached remote icon");
+        let path = doc.node(component).unwrap().children[0];
+        let set = doc.node(component).unwrap().parent.unwrap();
+        assert!(matches!(doc.node(set).unwrap().kind, NodeKind::ComponentSet { .. }));
+        assert_eq!(doc.node(doc.node(set).unwrap().parent.unwrap()).unwrap().parent, Some(store));
+        assert!(doc.is_remote(component) && doc.is_remote(path));
+        assert!(matches!(doc.node(component).unwrap().kind, NodeKind::Component { .. }));
+        assert_dark_remote_mode(doc, component);
+        assert_no_linked_library_records(doc);
+        // The visible instance resolves to the cached main, and its layer to the main's layer.
+        let instance = named_node(doc, "Visible icon instance");
+        assert!(matches!(doc.node(instance).unwrap().kind, NodeKind::Instance { component: linked, .. } if linked == component));
+        assert_eq!(doc.node(doc.node(instance).unwrap().children[0]).unwrap().source, Some(path));
+        // A cached main nested in another cached main is kept too, and so is an instance in the
+        // cache of a visible main, with the override its row carries.
+        let nested_main = named_node(doc, "Nested cached main");
+        let nested = named_node(doc, "Nested internal instance");
+        assert!(doc.is_remote(nested_main));
+        assert!(matches!(doc.node(nested).unwrap().kind, NodeKind::Instance { component: linked, .. } if linked == nested_main));
+        let external_main = named_node(doc, "Visible nested main");
+        let external = doc
+            .node(component)
+            .unwrap()
+            .children
+            .iter()
+            .copied()
+            .find(|id| doc.node(*id).is_some_and(|n| n.name == "Nested cached instance"))
+            .unwrap();
+        assert!(matches!(doc.node(external).unwrap().kind, NodeKind::Instance { component: linked, .. } if linked == external_main));
+        let external_child = doc.node(external).unwrap().children[0];
+        assert_eq!(doc.node(external_child).unwrap().source, Some(doc.node(external_main).unwrap().children[0]));
+        assert_eq!(fill_rgb_node(doc, external_child), Some([f64::from(0.2_f32), f64::from(0.7_f32), f64::from(0.1_f32)]));
+    };
+    check(&doc);
+    let (saved, warnings) = crate::load_bytes(&crate::save_bytes(&doc, None).unwrap()).unwrap();
+    assert!(warnings.is_empty(), "{warnings:?}");
+    check(&saved);
+}
+
+#[test]
+fn visible_instance_override_retains_and_links_hidden_cached_main() {
+    let (doc, warnings) = import(&cached_component_override_fixture(), "Cached override.fig").unwrap();
+    assert!(warnings.is_empty(), "{warnings:?}");
+    let nested = named_node(&doc, "Nested cached instance");
+    let deep = named_node(&doc, "Deep cached instance");
+    assert_eq!(doc.node(deep).unwrap().parent, Some(nested));
+    let NodeKind::Instance { component: overridden, .. } = doc.node(deep).unwrap().kind else { panic!("nested-row override lost its instance") };
+    let overridden = doc.node(overridden).unwrap();
+    assert_eq!(overridden.name, "Overridden cached main");
+    assert!(doc.is_remote(overridden.id));
+    assert_eq!(doc.node(doc.node(deep).unwrap().children[0]).unwrap().source, Some(overridden.children[0]));
+}
+
+#[test]
+fn visible_component_default_swap_retains_hidden_cached_main() {
+    let (doc, warnings) = import(&cached_component_default_swap_fixture(), "Cached default swap.fig").unwrap();
+    assert!(warnings.is_empty(), "{warnings:?}");
+    assert_default_swap(&doc);
+    let (saved, _) = crate::load_bytes(&crate::save_bytes(&doc, None).unwrap()).unwrap();
+    assert_default_swap(&saved);
+}
+
+#[test]
+fn public_rest_import_ignores_private_fig_provenance() {
+    let value = json!({
+        "name": "Public REST",
+        "document": {"type": "DOCUMENT", "children": [{"type": "CANVAS", "name": "Page", "children": []}]},
+        "_figLibraryContexts": [{"type": "FRAME", "name": "Private cache", "children": [{"type": "COMPONENT", "name": "Must not import", "children": []}]}]
+    });
+    let (doc, warnings) = crate::rest::import(&value, &|_| None).unwrap();
+    assert!(warnings.is_empty(), "{warnings:?}");
+    assert!(doc.library_store().is_none() && doc.nodes().all(|node| node.name != "Must not import"));
+    // Valid provenance on mapped layers links nothing either.
+    for message in [message(false), external_namespace_message()] {
+        let (json, _, _) = super::map::to_rest(&message, "Identity", crate::rest::MAX_NODES);
+        let (doc, _) = crate::rest::import(&json, &|_| None).unwrap();
+        assert!(doc.nodes().all(|n| n.source.is_none()));
+    }
+}
+
+#[test]
+fn the_last_change_of_a_guid_wins_and_removed_changes_delete() {
+    let moved = node(12, Some(11), "FRAME", "Moved frame", vec![]);
+    let mut removed = node(13, Some(10), "FRAME", "Removed frame", vec![]);
+    let Kv::Object(fields) = &mut removed else { panic!() };
+    fields.iter_mut().find(|(key, _)| *key == "phase").unwrap().1 = Kv::Enum("REMOVED");
+    let message = o(vec![(
+        "nodeChanges",
+        Kv::Array(vec![
+            node(1, None, "DOCUMENT", "Document", vec![]),
+            node(2, Some(1), "CANVAS", "Page", vec![]),
+            node(10, Some(2), "FRAME", "Left", vec![]),
+            node(11, Some(2), "FRAME", "Right", vec![]),
+            node(12, Some(10), "FRAME", "Moved frame", vec![]),
+            node(13, Some(10), "FRAME", "Removed frame", vec![]),
+            moved,
+            removed,
+        ]),
+    )]);
+    let (doc, _) = import(&super::tests::canvas(&schema(), &message), "Changes.fig").unwrap();
+    assert_eq!(doc.node(named_node(&doc, "Moved frame")).unwrap().parent, Some(named_node(&doc, "Right")));
+    assert!(doc.nodes().all(|n| n.name != "Removed frame"));
+    assert!(doc.node(named_node(&doc, "Left")).unwrap().children.is_empty());
+}
+
+#[test]
+fn internal_library_parent_cycles_are_bounded() {
+    let message = o(vec![(
+        "nodeChanges",
+        Kv::Array(vec![
+            node(1, None, "CANVAS", "Visible page", vec![]),
+            node(2, Some(1), "INSTANCE", "Visible cyclic main", vec![("symbolData", symbol(11, vec![]))]),
+            node(3, Some(9), "CANVAS", "Cyclic library", vec![("internalOnly", Kv::Bool(true))]),
+            node(9, Some(11), "FRAME", "Loop frame", vec![]),
+            node(10, Some(3), "SYMBOL", "Unrelated component", vec![]),
+            node(11, Some(3), "SYMBOL", "Loop component", vec![]),
+        ]),
+    )]);
+    let (doc, warnings) = import(&super::tests::canvas(&schema(), &message), "Cyclic library.fig").unwrap();
+    assert!(warnings.iter().any(|warning| warning.contains("deeper than")), "{warnings:?}");
+    assert!(doc.node_count() < 1000, "the loop is cut at the nesting limit");
+}
+
+#[test]
+fn parent_loops_through_the_internal_canvas_end() {
+    // The canvas is a child of a frame inside one of its own symbols, and the used main sits below
+    // that frame: the walk up from the main reaches the canvas again.
+    let message = o(vec![(
+        "nodeChanges",
+        Kv::Array(vec![
+            node(1, None, "CANVAS", "Visible page", vec![]),
+            node(2, Some(1), "INSTANCE", "Uses the main", vec![("symbolData", symbol(12, vec![]))]),
+            node(3, Some(9), "CANVAS", "Loop library", vec![("internalOnly", Kv::Bool(true))]),
+            node(9, Some(11), "FRAME", "Loop frame", vec![]),
+            node(11, Some(3), "SYMBOL", "Loop symbol", vec![]),
+            node(12, Some(9), "SYMBOL", "Used main", vec![]),
+        ]),
+    )]);
+    let (doc, _) = import(&super::tests::canvas(&schema(), &message), "Loop.fig").unwrap();
+    assert!(doc.nodes().any(|n| n.name == "Used main"));
+}
+
+fn fill_rgb_node(doc: &Document, id: NodeId) -> Option<[f64; 3]> {
+    let node = doc.node(id)?;
+    match &node.fills.first()?.kind {
+        PaintKind::Solid { color } => Some([f64::from(color.r), f64::from(color.g), f64::from(color.b)]),
+        _ => None,
+    }
+}
+
+fn alias_schema() -> Schema {
+    let schema = export::SCHEMA.replace("message NodeChange GUID guid=1,", "message NodeChange GUID guid=1, GUID overrideKey=500,");
+    Schema::parse(&schema).unwrap()
+}
+
+fn alias(id: u64) -> Fields {
+    vec![("overrideKey", g(id))]
+}
+
+fn import_alias_message(message: Kv<'static>) -> Document {
+    let schema = alias_schema();
+    let bytes = super::tests::canvas(&schema, &message);
+    let (doc, warnings) = import(&bytes, "Alias.fig").unwrap();
+    assert!(warnings.is_empty(), "{warnings:?}");
+    doc
+}
+
+fn fill_rgb(doc: &Document, name: &str) -> Option<[f64; 3]> {
+    let node = doc.nodes().find(|n| n.name == name)?;
+    fill_rgb_node(doc, node.id)
+}
+
+fn alias_priority_message() -> Kv<'static> {
+    let nested_local = symbol(10, vec![row(&[112], vec![("fillPaints", Kv::Array(vec![solid(0.0, 0.0, 1.0)]))])]);
+    o(vec![(
+        "nodeChanges",
+        Kv::Array(vec![
+            node(1, None, "DOCUMENT", "Document", vec![]),
+            node(2, Some(1), "CANVAS", "Page", vec![]),
+            node(10, Some(2), "SYMBOL", "Inner main", vec![]),
+            node(11, Some(10), "FRAME", "Normal frame", vec![]),
+            node(12, Some(11), "ROUNDED_RECTANGLE", "Alias leaf", alias(112)),
+            node(20, Some(2), "SYMBOL", "Outer main", vec![]),
+            node(
+                21,
+                Some(20),
+                "INSTANCE",
+                "Nested slot",
+                vec![
+                    ("overrideKey", g(221)),
+                    ("symbolData", nested_local),
+                    ("derivedSymbolData", Kv::Array(vec![row(&[112], vec![("opacity", Kv::Float(0.25))])])),
+                ],
+            ),
+            node(
+                30,
+                Some(2),
+                "INSTANCE",
+                "Alias copy",
+                vec![
+                    (
+                        "symbolData",
+                        symbol(
+                            20,
+                            vec![
+                                row(&[221, 112], vec![("fillPaints", Kv::Array(vec![solid(0.0, 1.0, 0.0)]))]),
+                                row(&[21, 12], vec![("fillPaints", Kv::Array(vec![solid(1.0, 0.0, 0.0)]))]),
+                            ],
+                        ),
+                    ),
+                    ("derivedSymbolData", Kv::Array(vec![row(&[221, 112], vec![("fillPaints", Kv::Array(vec![solid(1.0, 0.5, 0.0)]))])])),
+                ],
+            ),
+        ]),
+    )])
+}
+
+#[test]
+fn override_aliases_normalize_lazily_and_keep_outer_wire_order() {
+    let doc = import_alias_message(alias_priority_message());
+    let main = named(&doc, "Inner main");
+    let leaf = child(&doc, child(&doc, main, 0), 0);
+    let outer_main = named(&doc, "Outer main");
+    let main_slot = child(&doc, outer_main, 0);
+    let main_leaf = child(&doc, child(&doc, main_slot, 0), 0);
+    let copy = named(&doc, "Alias copy");
+    let nested = child(&doc, copy, 0);
+    let frame = child(&doc, nested, 0);
+    let expanded_leaf = child(&doc, frame, 0);
+    assert_eq!(doc.node(main_leaf).unwrap().source, Some(leaf));
+    assert_eq!(doc.node(expanded_leaf).unwrap().source, Some(main_leaf));
+    assert_eq!(fill_rgb_node(&doc, expanded_leaf), Some([1.0, 0.5, 0.0]));
+    assert_eq!(doc.node(expanded_leaf).unwrap().opacity, 0.25);
+    assert_eq!(fill_rgb_node(&doc, leaf), None, "source node stays unchanged");
+}
+
+#[test]
+fn selected_swapped_main_owns_alias_resolution_scope() {
+    let message = o(vec![(
+        "nodeChanges",
+        Kv::Array(vec![
+            node(1, None, "DOCUMENT", "Document", vec![]),
+            node(2, Some(1), "CANVAS", "Page", vec![]),
+            node(10, Some(2), "SYMBOL", "Old main", vec![]),
+            node(11, Some(10), "ROUNDED_RECTANGLE", "Old leaf", alias(112)),
+            node(20, Some(2), "SYMBOL", "Swapped main", vec![]),
+            node(21, Some(20), "ROUNDED_RECTANGLE", "Swapped leaf", alias(112)),
+            node(
+                30,
+                Some(2),
+                "INSTANCE",
+                "Swap",
+                vec![
+                    ("overriddenSymbolID", g(20)),
+                    ("symbolData", symbol(10, vec![row(&[112], vec![("fillPaints", Kv::Array(vec![solid(1.0, 0.0, 0.0)]))])])),
+                ],
+            ),
+        ]),
+    )]);
+    let doc = import_alias_message(message);
+    let copy = named(&doc, "Swap");
+    let source = named(&doc, "Swapped leaf");
+    let expanded = child(&doc, copy, 0);
+    assert_eq!(doc.node(expanded).unwrap().source, Some(source));
+    assert_eq!(fill_rgb_node(&doc, expanded), Some([1.0, 0.0, 0.0]));
+    assert_eq!(fill_rgb(&doc, "Old leaf"), None);
+}
+
+#[test]
+fn ambiguous_alias_is_ignored_but_current_guid_still_matches() {
+    let message = o(vec![(
+        "nodeChanges",
+        Kv::Array(vec![
+            node(1, None, "DOCUMENT", "Document", vec![]),
+            node(2, Some(1), "CANVAS", "Page", vec![]),
+            node(10, Some(2), "SYMBOL", "Main", vec![]),
+            node(11, Some(10), "ROUNDED_RECTANGLE", "First", alias(13)),
+            node(12, Some(10), "ROUNDED_RECTANGLE", "Second", alias(112)),
+            node(13, Some(10), "ROUNDED_RECTANGLE", "Current GUID", alias(112)),
+            node(
+                20,
+                Some(2),
+                "INSTANCE",
+                "Copy",
+                vec![(
+                    "symbolData",
+                    symbol(
+                        10,
+                        vec![
+                            row(&[112], vec![("fillPaints", Kv::Array(vec![solid(1.0, 0.0, 0.0)]))]),
+                            row(&[13], vec![("fillPaints", Kv::Array(vec![solid(0.0, 0.0, 1.0)]))]),
+                        ],
+                    ),
+                )],
+            ),
+        ]),
+    )]);
+    let doc = import_alias_message(message);
+    let copy = named(&doc, "Copy");
+    let first = child(&doc, copy, 0);
+    let second = child(&doc, copy, 1);
+    let current = child(&doc, copy, 2);
+    assert_eq!(doc.node(first).unwrap().source, Some(named(&doc, "First")));
+    assert_eq!(fill_rgb_node(&doc, first), None, "ambiguous alias must not be guessed");
+    assert_eq!(doc.node(second).unwrap().source, Some(named(&doc, "Second")));
+    assert_eq!(fill_rgb_node(&doc, second), None, "ambiguous alias must not match either target");
+    assert_eq!(doc.node(current).unwrap().source, Some(named(&doc, "Current GUID")));
+    assert_eq!(fill_rgb_node(&doc, current), Some([0.0, 0.0, 1.0]), "a current GUID outranks an alias with the same key");
+}
+
+fn message(swapped: bool) -> Kv<'static> {
+    let shape = |id, parent, x| node(id, Some(parent), "ROUNDED_RECTANGLE", "Same layer", vec![("transform", matrix(x))]);
+    let mut changes = vec![
+        node(1, None, "DOCUMENT", "Identity", vec![]),
+        node(2, Some(1), "CANVAS", "Page", vec![]),
+        node(10, Some(2), "SYMBOL", "Renamed Left main", vec![]),
+        node(11, Some(10), "FRAME", "Frame", vec![("transform", matrix(2.0))]),
+        shape(12, 11, 2.0),
+        shape(13, 11, 4.0),
+        shape(14, 11, 6.0),
+        node(15, Some(11), "FRAME", "Deep frame", vec![]),
+        node(16, Some(15), "FRAME", "Deeper frame", vec![]),
+        shape(17, 16, 8.0),
+        node(
+            20,
+            Some(2),
+            "SYMBOL",
+            "State=Right, Renamed=Yes",
+            vec![(
+                "componentPropDefs",
+                Kv::Array(vec![o(vec![
+                    ("id", g(200)),
+                    ("name", s("Enabled")),
+                    ("type", Kv::Enum("BOOL")),
+                    ("initialValue", o(vec![("boolValue", Kv::Bool(true))])),
+                ])]),
+            )],
+        ),
+        node(21, Some(20), "FRAME", "Frame", vec![("transform", matrix(if swapped { 23.0 } else { 2.0 }))]),
+        shape(22, 21, 2.0),
+        shape(23, 21, 4.0),
+        shape(24, 21, 6.0),
+        node(30, Some(2), "SYMBOL", "Outer", vec![]),
+        node(40, Some(30), "INSTANCE", "Original wrapper", vec![("symbolData", symbol(50, vec![row(&[60, 21], vec![("transform", matrix(3.0))])]))]),
+        node(50, Some(2), "SYMBOL", "Renamed wrapper main", vec![]),
+        node(
+            60,
+            Some(50),
+            "INSTANCE",
+            "Same nested slot",
+            vec![
+                ("symbolData", symbol(20, vec![])),
+                ("visible", Kv::Bool(false)),
+                ("opacity", Kv::Float(0.3)),
+                ("mask", Kv::Bool(true)),
+                ("componentPropAssignments", Kv::Array(vec![o(vec![("defID", g(200)), ("value", o(vec![("boolValue", Kv::Bool(false))]))])])),
+            ],
+        ),
+        node(61, Some(50), "INSTANCE", "Same nested slot", vec![("symbolData", symbol(20, vec![]))]),
+    ];
+    let mut nested = vec![
+        ("name", s("Renamed nested slot")),
+        ("visible", Kv::Bool(true)),
+        ("opacity", Kv::Float(1.0)),
+        ("mask", Kv::Bool(false)),
+        ("componentPropAssignments", Kv::Array(vec![])),
+    ];
+    if swapped {
+        nested.push(("overriddenSymbolID", g(10)));
+    }
+    changes.push(node(
+        70,
+        Some(2),
+        "INSTANCE",
+        "Copy",
+        vec![(
+            "symbolData",
+            symbol(
+                30,
+                vec![
+                    row(&[40], vec![("name", s("Renamed wrapper"))]),
+                    row(&[40, 60], nested),
+                    row(&[40, 60, if swapped { 11 } else { 21 }], vec![("transform", matrix(2.0))]),
+                ],
+            ),
+        )],
+    ));
+    o(vec![("nodeChanges", Kv::Array(changes))])
+}
+
+fn import_message(swapped: bool) -> Document {
+    let schema = Schema::parse(export::SCHEMA).unwrap();
+    let bytes = super::tests::canvas(&schema, &message(swapped));
+    let (doc, notes) = import(&bytes, "Identity.fig").unwrap();
+    assert!(notes.is_empty(), "{notes:?}");
+    doc
+}
+
+fn named(doc: &Document, name: &str) -> NodeId {
+    doc.nodes().find(|n| n.name == name).unwrap().id
+}
+
+fn child(doc: &Document, id: NodeId, index: usize) -> NodeId {
+    doc.node(id).unwrap().children[index]
+}
+
+fn assert_contextual(doc: &Document) {
+    let outer = named(doc, "Outer");
+    let right = named(doc, "State=Right, Renamed=Yes");
+    let wrapper_main = named(doc, "Renamed wrapper main");
+    let copy = named(doc, "Copy");
+    let main_wrapper = child(doc, outer, 0);
+    let copy_wrapper = child(doc, copy, 0);
+    assert_eq!(doc.node(copy).unwrap().source, Some(outer));
+    assert_eq!(doc.node(copy_wrapper).unwrap().source, Some(main_wrapper));
+    assert!(matches!(&doc.node(copy_wrapper).unwrap().kind, NodeKind::Instance {component, ..} if *component == wrapper_main));
+    for index in 0..2 {
+        let default_slot = child(doc, main_wrapper, index);
+        let copy_slot = child(doc, copy_wrapper, index);
+        assert_eq!(doc.node(copy_slot).unwrap().source, Some(default_slot), "slot {index}");
+        assert!(matches!(&doc.node(default_slot).unwrap().kind, NodeKind::Instance {component, ..} if *component == right));
+        assert!(matches!(&doc.node(copy_slot).unwrap().kind, NodeKind::Instance {component, ..} if *component == right));
+    }
+    let default_slot = child(doc, main_wrapper, 0);
+    let copy_slot = child(doc, copy_wrapper, 0);
+    let inherited = child(doc, default_slot, 0);
+    let copy_frame = child(doc, copy_slot, 0);
+    assert!(matches!(doc.node(copy_frame).unwrap().kind, NodeKind::Frame));
+    assert_eq!(doc.node(inherited).unwrap().transform.translation().x, 3.0);
+    assert_eq!(doc.node(copy_frame).unwrap().transform.translation().x, 2.0);
+    assert_eq!(doc.node(copy_frame).unwrap().source, Some(inherited));
+    for index in 0..3 {
+        assert_eq!(doc.node(child(doc, copy_frame, index)).unwrap().source, Some(child(doc, inherited, index)));
+        assert_eq!(doc.node(child(doc, copy_frame, index)).unwrap().transform.translation().x, 2.0 + 2.0 * index as f64);
+    }
+    let a = doc.node(default_slot).unwrap();
+    let b = doc.node(copy_slot).unwrap();
+    assert!(!a.visible && a.is_mask && a.opacity < 1.0);
+    assert!(b.visible && !b.is_mask && b.opacity == 1.0);
+    assert!(matches!(&a.kind, NodeKind::Instance {props, ..} if props.len() == 1 && props.values().all(|p| p == &json!(false))));
+    assert!(matches!(&b.kind, NodeKind::Instance {props, ..} if props.is_empty()));
+}
+
+#[test]
+fn contextual_sources_preserve_inherited_geometry_and_explicit_clears() {
+    assert_contextual(&import_message(false));
+}
+
+fn assert_swapped(doc: &Document) {
+    let outer = named(doc, "Outer");
+    let right = named(doc, "State=Right, Renamed=Yes");
+    let copy = named(doc, "Copy");
+    let main_wrapper = child(doc, outer, 0);
+    let copy_wrapper = child(doc, copy, 0);
+    let copy_slot = child(doc, copy_wrapper, 0);
+    let default_slot = child(doc, main_wrapper, 0);
+    let left = named(doc, "Renamed Left main");
+    assert_eq!(doc.node(copy).unwrap().source, Some(outer));
+    assert_eq!(doc.node(copy_wrapper).unwrap().source, Some(main_wrapper));
+    assert_eq!(doc.node(copy_slot).unwrap().source, Some(default_slot));
+    assert!(matches!(&doc.node(copy_slot).unwrap().kind, NodeKind::Instance {component, props} if *component == left && props.is_empty()));
+    assert!(matches!(&doc.node(default_slot).unwrap().kind, NodeKind::Instance {component, ..} if *component == right));
+    let current_frame = child(doc, copy_slot, 0);
+    let left_frame = child(doc, left, 0);
+    assert!(matches!(doc.node(current_frame).unwrap().kind, NodeKind::Frame));
+    assert_eq!(doc.node(current_frame).unwrap().source, Some(left_frame));
+    assert_eq!(doc.node(current_frame).unwrap().transform.translation().x, 2.0);
+    assert_eq!(doc.node(child(doc, right, 0)).unwrap().transform.translation().x, 23.0);
+    for index in 0..3 {
+        assert_eq!(doc.node(child(doc, current_frame, index)).unwrap().source, Some(child(doc, left_frame, index)));
+        assert_eq!(doc.node(child(doc, current_frame, index)).unwrap().transform.translation().x, 2.0 + 2.0 * index as f64);
+    }
+    let deep_copy = child(doc, child(doc, child(doc, current_frame, 3), 0), 0);
+    let deep_main = child(doc, child(doc, child(doc, left_frame, 3), 0), 0);
+    assert_eq!(doc.node(deep_copy).unwrap().source, Some(deep_main));
+    assert_eq!(doc.node(deep_copy).unwrap().transform.translation().x, 8.0);
+    let other = child(doc, copy_wrapper, 1);
+    assert_eq!(doc.node(other).unwrap().source, Some(child(doc, main_wrapper, 1)));
+    assert!(matches!(&doc.node(other).unwrap().kind, NodeKind::Instance {component, ..} if *component == right));
+    assert!(doc.node(copy_slot).unwrap().visible && !doc.node(copy_slot).unwrap().is_mask && doc.node(copy_slot).unwrap().opacity == 1.0);
+}
+
+#[test]
+fn swapped_children_use_current_main_through_frames_and_multiple_siblings() {
+    assert_swapped(&import_message(true));
+}
+
+fn edit_node(value: &mut Value, id: &str, edit: &mut dyn FnMut(&mut Value)) {
+    if value.get("id").and_then(Value::as_str) == Some(id) {
+        edit(value);
+    }
+    if let Some(kids) = value.get_mut("children").and_then(Value::as_array_mut) {
+        for child in kids {
+            edit_node(child, id, edit);
+        }
+    }
+}
+
+#[test]
+fn missing_foreign_self_and_wrong_namespace_provenance_is_not_guessed() {
+    for (origin, id) in [("1:99999", "I1:70;1:40"), ("1:12", "I1:70;1:40"), ("1:70", "1:70"), ("1:40", "I1:70;1:40")] {
+        let (mut json, _, _) = super::map::to_rest(&message(false), "Identity", crate::rest::MAX_NODES);
+        edit_node(&mut json["document"]["children"][0], id, &mut |node| {
+            node[crate::rest::FIG_SOURCE_FIELD]["origin"] = json!(origin);
+            if id == "1:70" {
+                node["componentId"] = json!("1:70"); // a root cannot be its own component
+            } else if origin == "1:40" {
+                node["id"] = json!("I1:999;1:40");
+            } else {
+                node["id"] = json!(format!("I1:70;{origin}")); // valid namespace, but missing/foreign target
+            }
+        });
+        let (doc, _) = crate::rest::import_fig(&json, &|_| None).unwrap();
+        let target = if id == "1:70" { named(&doc, "Copy") } else { named(&doc, "Renamed wrapper") };
+        assert!(doc.node(target).unwrap().source.is_none(), "{origin}/{id}");
+    }
+}
+
+#[test]
+fn forward_main_references_and_duplicate_ids_are_conservative() {
+    let (mut json, _, _) = super::map::to_rest(&message(false), "Identity", crate::rest::MAX_NODES);
+    json["document"]["children"][0]["children"].as_array_mut().unwrap().rotate_right(1);
+    let (doc, _) = crate::rest::import_fig(&json, &|_| None).unwrap();
+    assert!(doc.node(named(&doc, "Copy")).unwrap().source.is_some());
+    // 1:40 is nested inside Outer, so duplicate that actual template at page level.
+    let template = json["document"]["children"][0]["children"].as_array().unwrap().iter().find(|n| n["id"] == "1:30").unwrap()["children"][0].clone();
+    json["document"]["children"][0]["children"].as_array_mut().unwrap().push(template);
+    let (doc, _) = crate::rest::import_fig(&json, &|_| None).unwrap();
+    assert!(doc.node(named(&doc, "Renamed wrapper")).unwrap().source.is_none());
+}
+
+#[test]
+fn missing_contextual_targets_do_not_fall_back_to_a_global_slot() {
+    let (mut json, _, _) = super::map::to_rest(&message(false), "Identity", crate::rest::MAX_NODES);
+    edit_node(&mut json["document"]["children"][0], "1:40", &mut |node| {
+        node["children"].as_array_mut().unwrap().retain(|n| n["id"] != "I1:40;1:60");
+    });
+    let (doc, _) = crate::rest::import_fig(&json, &|_| None).unwrap();
+    let copy_slot = child(&doc, child(&doc, named(&doc, "Copy"), 0), 0);
+    assert!(doc.node(copy_slot).unwrap().source.is_none());
+    assert!(doc.nodes().any(|n| n.name == "Same nested slot"), "the raw slot still exists");
+}
+
+#[test]
+fn instance_to_empty_frame_keeps_its_source_identity() {
+    let mut msg = message(false);
+    let Kv::Object(top) = &mut msg else { panic!() };
+    let Kv::Array(nodes) = &mut top.iter_mut().find(|(key, _)| *key == "nodeChanges").unwrap().1 else { panic!() };
+    let copy = nodes.iter_mut().find(|n| n.get("name").and_then(Kv::str) == Some("Copy")).unwrap();
+    let Kv::Object(fields) = copy else { panic!() };
+    let Kv::Object(symbol) = &mut fields.iter_mut().find(|(key, _)| *key == "symbolData").unwrap().1 else { panic!() };
+    let Kv::Array(overrides) = &mut symbol.iter_mut().find(|(key, _)| *key == "symbolOverrides").unwrap().1 else { panic!() };
+    overrides.push(row(&[40, 61], vec![("type", Kv::Enum("FRAME"))]));
+    let (doc, _) = import(&super::tests::canvas(&schema(), &msg), "Identity.fig").unwrap();
+    let main = child(&doc, named(&doc, "Outer"), 0);
+    let copy = child(&doc, named(&doc, "Copy"), 0);
+    let frame = child(&doc, copy, 1);
+    assert!(matches!(doc.node(frame).unwrap().kind, NodeKind::Frame));
+    assert!(doc.node(frame).unwrap().children.is_empty());
+    assert_eq!(doc.node(frame).unwrap().source, Some(child(&doc, main, 1)));
+}
+
+#[test]
+fn explicit_frame_to_instance_resets_children_to_the_resolved_main() {
+    let mut msg = message(false);
+    let Kv::Object(top) = &mut msg else { panic!() };
+    let Kv::Array(nodes) = &mut top.iter_mut().find(|(key, _)| *key == "nodeChanges").unwrap().1 else { panic!() };
+    nodes.push(node(80, Some(30), "FRAME", "Original frame", vec![]));
+    nodes.push(node(81, Some(80), "ROUNDED_RECTANGLE", "Old frame child", vec![]));
+    let copy = nodes.iter_mut().find(|n| n.get("name").and_then(Kv::str) == Some("Copy")).unwrap();
+    let Kv::Object(fields) = copy else { panic!() };
+    let Kv::Object(symbol) = &mut fields.iter_mut().find(|(key, _)| *key == "symbolData").unwrap().1 else { panic!() };
+    let Kv::Array(overrides) = &mut symbol.iter_mut().find(|(key, _)| *key == "symbolOverrides").unwrap().1 else { panic!() };
+    overrides.push(row(&[80], vec![("type", Kv::Enum("INSTANCE")), ("overriddenSymbolID", g(10))]));
+    let (doc, notes) = import(&super::tests::canvas(&schema(), &msg), "Identity.fig").unwrap();
+    assert!(notes.is_empty(), "{notes:?}");
+    let original = child(&doc, named(&doc, "Outer"), 1);
+    let current = child(&doc, named(&doc, "Copy"), 1);
+    let left = named(&doc, "Renamed Left main");
+    assert!(matches!(doc.node(original).unwrap().kind, NodeKind::Frame));
+    assert_eq!(doc.node(current).unwrap().source, Some(original));
+    assert!(matches!(&doc.node(current).unwrap().kind, NodeKind::Instance {component, ..} if *component == left));
+    assert_eq!(doc.node(child(&doc, current, 0)).unwrap().source, Some(child(&doc, left, 0)));
+}
+
+// The orphan symbol is decoded and expanded but is not a layer on any imported page. This
+// matches an external main: its instance becomes a frame while the rendered body survives.
+fn external_namespace_message() -> Kv<'static> {
+    o(vec![(
+        "nodeChanges",
+        Kv::Array(vec![
+            node(1, None, "DOCUMENT", "External namespace", vec![]),
+            node(2, Some(1), "CANVAS", "Page", vec![]),
+            node(
+                10,
+                Some(2),
+                "SYMBOL",
+                "Known main",
+                vec![(
+                    "componentPropDefs",
+                    Kv::Array(vec![o(vec![
+                        ("id", g(200)),
+                        ("name", s("Enabled")),
+                        ("type", Kv::Enum("BOOL")),
+                        ("initialValue", o(vec![("boolValue", Kv::Bool(true))])),
+                    ])]),
+                )],
+            ),
+            node(11, Some(10), "FRAME", "Known frame", vec![("transform", matrix(2.0))]),
+            node(12, Some(11), "ROUNDED_RECTANGLE", "Known leaf", vec![("transform", matrix(4.0))]),
+            node(30, Some(2), "SYMBOL", "Outer external", vec![]),
+            node(
+                90,
+                Some(30),
+                "INSTANCE",
+                "External body",
+                vec![("symbolData", symbol(99, vec![row(&[110, 11], vec![("transform", matrix(3.0))])]))],
+            ),
+            node(99, None, "SYMBOL", "External orphan", vec![]),
+            node(100, Some(99), "FRAME", "Body frame", vec![]),
+            node(101, Some(99), "FRAME", "Other body frame", vec![]),
+            node(
+                110,
+                Some(100),
+                "INSTANCE",
+                "Same slot",
+                vec![
+                    ("symbolData", symbol(10, vec![])),
+                    ("visible", Kv::Bool(false)),
+                    ("opacity", Kv::Float(0.3)),
+                    ("mask", Kv::Bool(true)),
+                    ("componentPropAssignments", Kv::Array(vec![o(vec![("defID", g(200)), ("value", o(vec![("boolValue", Kv::Bool(false))]))])])),
+                ],
+            ),
+            node(111, Some(100), "INSTANCE", "Same slot", vec![("symbolData", symbol(10, vec![]))]),
+            node(
+                70,
+                Some(2),
+                "INSTANCE",
+                "External copy",
+                vec![(
+                    "symbolData",
+                    symbol(
+                        30,
+                        vec![
+                            row(
+                                &[90, 110],
+                                vec![
+                                    ("name", s("Renamed owned slot")),
+                                    ("visible", Kv::Bool(true)),
+                                    ("opacity", Kv::Float(1.0)),
+                                    ("mask", Kv::Bool(false)),
+                                    ("componentPropAssignments", Kv::Array(vec![])),
+                                ],
+                            ),
+                            row(&[90, 110, 11], vec![("transform", matrix(2.0))]),
+                        ],
+                    ),
+                )],
+            ),
+        ]),
+    )])
+}
+
+fn assert_external_namespace(doc: &Document) {
+    let outer = named(doc, "Outer external");
+    let copy = named(doc, "External copy");
+    let main = named(doc, "Known main");
+    let body = child(doc, outer, 0);
+    let copied_body = child(doc, copy, 0);
+    assert!(matches!(doc.node(body).unwrap().kind, NodeKind::Frame));
+    assert!(matches!(doc.node(copied_body).unwrap().kind, NodeKind::Frame));
+    assert_eq!(doc.node(body).unwrap().source, None, "the absent external main must not acquire a guessed native node");
+    assert_eq!(doc.node(copied_body).unwrap().source, Some(body));
+    let frame = child(doc, body, 0);
+    let copied_frame = child(doc, copied_body, 0);
+    assert_eq!(doc.node(frame).unwrap().source, None, "materialized ordinary layers are owned by the frame");
+    assert_eq!(doc.node(copied_frame).unwrap().source, Some(frame));
+    for index in 0..2 {
+        let slot = child(doc, frame, index);
+        let copied_slot = child(doc, copied_frame, index);
+        assert_eq!(doc.node(slot).unwrap().source, Some(main), "known owned instance has its real root main");
+        assert_eq!(doc.node(copied_slot).unwrap().source, Some(slot), "copied slots preserve the contextual owned layer identity");
+        assert!(matches!(&doc.node(slot).unwrap().kind, NodeKind::Instance {component, ..} if *component == main));
+        assert!(matches!(&doc.node(copied_slot).unwrap().kind, NodeKind::Instance {component, ..} if *component == main));
+        let inherited = child(doc, slot, 0);
+        let current = child(doc, copied_slot, 0);
+        assert_eq!(doc.node(inherited).unwrap().source, Some(child(doc, main, 0)));
+        assert_eq!(doc.node(current).unwrap().source, Some(inherited));
+        assert_eq!(doc.node(inherited).unwrap().transform.translation().x, if index == 0 { 3.0 } else { 2.0 });
+        assert_eq!(doc.node(current).unwrap().transform.translation().x, 2.0);
+        assert_eq!(doc.node(child(doc, current, 0)).unwrap().source, Some(child(doc, inherited, 0)));
+        assert_eq!(doc.node(child(doc, current, 0)).unwrap().transform.translation().x, 4.0);
+    }
+    let old = doc.node(child(doc, frame, 0)).unwrap();
+    let current = doc.node(child(doc, copied_frame, 0)).unwrap();
+    assert!(!old.visible && old.is_mask && old.opacity < 1.0);
+    assert!(current.visible && !current.is_mask && current.opacity == 1.0);
+    assert_eq!(current.name, "Renamed owned slot");
+    assert!(matches!(&old.kind, NodeKind::Instance {props, ..} if props.len() == 1));
+    assert!(matches!(&current.kind, NodeKind::Instance {props, ..} if props.is_empty()));
+}
+
+#[test]
+fn absent_external_mains_keep_known_owned_instances_and_contextual_copies() {
+    let (doc, notes) = import(&super::tests::canvas(&schema(), &external_namespace_message()), "External.fig").unwrap();
+    assert!(notes.iter().any(|w| w.contains("components that aren't in the file")), "{notes:?}");
+    assert!(!notes.iter().any(|w| w.contains("source link")), "materialized own layers are not unresolved copies: {notes:?}");
+    assert_external_namespace(&doc);
+}
+
+#[test]
+fn external_namespace_is_private_and_requires_actual_wire_instances() {
+    for mode in 0..3 {
+        let (mut json, _, _) = super::map::to_rest(&external_namespace_message(), "External", crate::rest::MAX_NODES);
+        if mode == 0 {
+            let (doc, _) = crate::rest::import(&json, &|_| None).unwrap();
+            assert!(doc.nodes().all(|n| n.source.is_none()));
+            continue;
+        }
+        edit_node(&mut json["document"]["children"][0], "1:90", &mut |node| {
+            if mode == 1 {
+                node["type"] = json!("FRAME");
+            } else {
+                node[crate::rest::FIG_SOURCE_FIELD]["wireInstance"] = json!(false);
+                node[crate::rest::FIG_SOURCE_FIELD]["wireFrame"] = json!(true);
+            }
+        });
+        let (doc, _) = crate::rest::import_fig(&json, &|_| None).unwrap();
+        let raw_slot = child(&doc, child(&doc, child(&doc, named(&doc, "Outer external"), 0), 0), 0);
+        assert!(doc.node(raw_slot).unwrap().source.is_none(), "ordinary/fake frame mode {mode} must not establish a namespace");
+    }
+}
+
+#[test]
+fn external_namespace_does_not_cover_present_wrong_kind_or_blocked_main() {
+    for mode in 0..3 {
+        let (mut json, _, _) = super::map::to_rest(&external_namespace_message(), "External", crate::rest::MAX_NODES);
+        let page = &mut json["document"]["children"][0];
+        match mode {
+            0 => page["children"].as_array_mut().unwrap().push(json!({"id":"1:99", "type":"FRAME", "name":"Wrong kind",
+                "_figSource":{"origin":"1:99","expanded":false,"wireFrame":true,"wireInstance":false}})),
+            1 => edit_node(page, "1:90", &mut |node| {
+                node["componentId"] = json!("1:30");
+            }),
+            _ => page["children"].as_array_mut().unwrap().push(json!({"id":"1:99", "type":"COMPONENT", "name":"Cycle main",
+                "_figSource":{"origin":"1:99","expanded":false,"wireFrame":false,"wireInstance":false},
+                "children":[{"id":"1:199", "type":"INSTANCE", "name":"Cycle edge", "componentId":"1:30",
+                    "_figSource":{"origin":"1:199","expanded":false,"wireFrame":false,"wireInstance":true}}]})),
+        }
+        let (doc, _) = crate::rest::import_fig(&json, &|_| None).unwrap();
+        let body = child(&doc, named(&doc, "Outer external"), 0);
+        assert!(matches!(doc.node(body).unwrap().kind, NodeKind::Frame));
+        let slot = child(&doc, child(&doc, body, 0), 0);
+        assert!(doc.node(slot).unwrap().source.is_none(), "existing invalid/cycle/self main mode {mode} must not become a materialized namespace");
+    }
+}
+
+#[test]
+fn external_namespace_rejects_foreign_siblings_duplicates_and_bad_paths() {
+    for mode in 0..4 {
+        let (mut json, _, _) = super::map::to_rest(&external_namespace_message(), "External", crate::rest::MAX_NODES);
+        let page = &mut json["document"]["children"][0];
+        match mode {
+            0 => {
+                // Same root namespace and GUID, but physically under a different frame slot.
+                let mut moved = None;
+                edit_node(page, "I1:70;1:90;1:100", &mut |node| {
+                    moved = Some(node["children"].as_array_mut().unwrap().remove(0));
+                });
+                edit_node(page, "I1:70;1:90;1:101", &mut |node| {
+                    node["children"] = json!([moved.take().unwrap()]);
+                });
+            }
+            1 => edit_node(page, "I1:70;1:90;1:110", &mut |node| {
+                node["id"] = json!("I1:70;1:999;1:110");
+            }),
+            2 => {
+                let duplicate = page["children"].as_array().unwrap().iter().find(|n| n["id"] == "1:30").unwrap()["children"][0].clone();
+                page["children"].as_array_mut().unwrap().push(duplicate);
+            }
+            _ => edit_node(page, "I1:90;1:100", &mut |node| {
+                node["id"] = json!("I1:999;1:100");
+            }),
+        }
+        let (doc, warnings) = crate::rest::import_fig(&json, &|_| None).unwrap();
+        let slot = named(&doc, "Renamed owned slot");
+        assert!(doc.node(slot).unwrap().source.is_none(), "invalid frame namespace mode {mode}");
+        assert!(warnings.iter().any(|w| w.contains("source link")), "invalid expanded paths remain reported: {warnings:?}");
+    }
+}
+
+fn no_style() -> Kv<'static> {
+    o(vec![("sessionID", Kv::Uint(4_294_967_295)), ("localID", Kv::Uint(4_294_967_295))])
+}
+
+#[test]
+fn an_explicit_no_style_detaches_and_beats_the_older_style_field() {
+    let message = o(vec![(
+        "nodeChanges",
+        Kv::Array(vec![
+            node(1, None, "DOCUMENT", "Document", vec![]),
+            node(2, Some(1), "CANVAS", "Page", vec![]),
+            node(5, Some(2), "RECTANGLE", "Red", vec![("styleType", Kv::Enum("FILL"))]),
+            node(6, Some(2), "RECTANGLE", "Box", vec![("styleIdForFill", o(vec![("guid", no_style())])), ("inheritFillStyleID", g(5))]),
+            node(7, Some(2), "RECTANGLE", "Linked", vec![("inheritFillStyleID", g(5))]),
+        ]),
+    )]);
+    let (json, _, _) = super::map::to_rest(&message, "Detach", crate::rest::MAX_NODES);
+    let find = |name: &str| json["document"]["children"][0]["children"].as_array().unwrap().iter().find(|n| n["name"] == name).unwrap().clone();
+    assert!(find("Box")["styles"].get("fill").is_none(), "{}", find("Box")["styles"]);
+    assert!(find("Linked")["styles"].get("fill").is_some(), "the older field still links when nothing detaches");
+}
diff --git a/crates/format/src/fig/tail_tests.rs b/crates/format/src/fig/tail_tests.rs
index fc0c58154..abc90d73e 100644
--- a/crates/format/src/fig/tail_tests.rs
+++ b/crates/format/src/fig/tail_tests.rs
@@ -3,13 +3,13 @@
 //! fixtures built in code with the parent module's helpers.
 
 use figcraft_doc::proto::Action;
-use figcraft_doc::{HandleMirroring, StrokeCap, WindingRule};
+use figcraft_doc::{HandleMirroring, StrokeCap, StrokeJoin, WindingRule};
 
 use super::super::network::{self, Network, Region, Segment, Vertex};
 use super::*;
 
 fn seg(a: usize, b: usize, ta: (f64, f64), tb: (f64, f64)) -> Segment {
-    Segment { a, ta, b, tb }
+    Segment { style: 0, a, ta, b, tb }
 }
 
 fn vtx(style: u32, x: f64, y: f64) -> Vertex {
@@ -19,7 +19,7 @@ fn vtx(style: u32, x: f64, y: f64) -> Vertex {
 /// A square with one curved side and a rounded, mirrored corner, filled even-odd.
 fn square_blob() -> Vec<u8> {
     network::encode(&Network {
-        vertices: vec![vtx(0, 0.0, 0.0), vtx(1, 50.0, 0.0), vtx(0, 50.0, 50.0), vtx(0, 0.0, 50.0)],
+        vertices: vec![vtx(0, 0.0, 0.0), vtx(1, 50.0, 0.0), vtx(2, 50.0, 50.0), vtx(3, 0.0, 50.0)],
         segments: vec![
             seg(0, 1, (10.0, 0.0), (-10.0, 0.0)),
             seg(1, 2, (0.0, 0.0), (0.0, 0.0)),
@@ -39,6 +39,15 @@ fn arrow_blob() -> Vec<u8> {
     })
 }
 
+/// An open path with one missing style ID and one unsupported point join.
+fn join_fallback_blob() -> Vec<u8> {
+    network::encode(&Network {
+        vertices: vec![vtx(4, 0.0, 0.0), vtx(5, 50.0, 0.0), vtx(0, 100.0, 0.0)],
+        segments: vec![seg(0, 1, (0.0, 0.0), (0.0, 0.0)), seg(1, 2, (0.0, 0.0), (0.0, 0.0))],
+        regions: vec![],
+    })
+}
+
 fn vector_data(blob: u64, nx: f64, ny: f64, styles: Vec<Kv<'static>>) -> Kv<'static> {
     o(vec![("vectorNetworkBlob", u(blob)), ("normalizedSize", xy(nx, ny)), ("styleOverrideTable", arr(styles))])
 }
@@ -121,13 +130,24 @@ fn tail_message() -> Kv<'static> {
                 ("transform", at(700.0, 0.0)),
                 ("fillPaints", arr(vec![solid(1.0, 0.0, 0.0)])),
                 ("fillGeometry", outline(0)),
+                ("strokeJoin", e("MITER")),
+                ("dashPattern", arr(vec![f(4.0), f(2.0)])),
                 (
                     "vectorData",
                     vector_data(
                         1,
                         100.0,
                         50.0,
-                        vec![o(vec![("styleID", u(1)), ("cornerRadius", f(4.0)), ("handleMirroring", e("ANGLE_AND_LENGTH"))])],
+                        vec![
+                            o(vec![
+                                ("styleID", u(1)),
+                                ("cornerRadius", f(4.0)),
+                                ("handleMirroring", e("ANGLE_AND_LENGTH")),
+                                ("strokeJoin", e("BEVEL")),
+                            ]),
+                            o(vec![("styleID", u(2)), ("strokeJoin", e("MITER"))]),
+                            o(vec![("styleID", u(3)), ("strokeJoin", e("ROUND"))]),
+                        ],
                     ),
                 ),
             ],
@@ -146,6 +166,19 @@ fn tail_message() -> Kv<'static> {
                 ("vectorData", vector_data(2, 100.0, 0.0, vec![o(vec![("styleID", u(2)), ("strokeCap", e("ARROW_LINES"))])])),
             ],
         ),
+        node(
+            42,
+            Some((1, "#")),
+            "VECTOR",
+            "Join Fallbacks",
+            vec![
+                ("size", xy(100.0, 10.0)),
+                ("transform", at(0.0, 330.0)),
+                stroke(),
+                ("strokeJoin", e("MITER")),
+                ("vectorData", vector_data(4, 100.0, 10.0, vec![o(vec![("styleID", u(5)), ("strokeJoin", u(999))])])),
+            ],
+        ),
         node(
             32,
             Some((1, "#")),
@@ -223,7 +256,7 @@ fn tail_message() -> Kv<'static> {
     ];
     let mut broken = square_blob();
     broken.truncate(30);
-    let blobs = [triangle_blob(), square_blob(), arrow_blob(), broken];
+    let blobs = [triangle_blob(), square_blob(), arrow_blob(), broken, join_fallback_blob()];
     o(vec![("nodeChanges", arr(nodes)), ("blobs", arr(blobs.into_iter().map(|b| o(vec![("bytes", Kv::Bytes(b))])).collect()))])
 }
 
@@ -247,6 +280,11 @@ fn vectors_import_as_editable_networks() {
     assert_eq!(pts, [(0.0, 0.0), (100.0, 0.0), (100.0, 100.0), (0.0, 100.0)]);
     assert_eq!((wave.vertices[1].radius, wave.vertices[1].mirror), (4.0, Some(HandleMirroring::AngleAndLength)));
     assert_eq!(wave.vertices[0].mirror, None);
+    assert_eq!(
+        wave.vertices.iter().map(|v| v.join).collect::<Vec<_>>(),
+        [None, Some(StrokeJoin::Bevel), Some(StrokeJoin::Miter), Some(StrokeJoin::Round)]
+    );
+    assert_eq!(named(&doc, "Wave").stroke.join, StrokeJoin::Miter);
     assert_eq!((wave.segments[0].ta, wave.segments[0].tb), ((20.0, 0.0), (-20.0, 0.0)));
     assert_eq!(wave.regions.len(), 1);
     assert_eq!((wave.regions[0].loops.clone(), wave.regions[0].winding), (vec![vec![0, 1, 2, 3]], WindingRule::EvenOdd));
@@ -260,6 +298,48 @@ fn vectors_import_as_editable_networks() {
     // A damaged network falls back to the outline.
     assert_eq!(network_of(&doc, "Broken").regions.len(), 1);
     assert!(warnings.iter().any(|w| w.contains("damaged vector networks import as outlines")), "{warnings:?}");
+    let fallback = network_of(&doc, "Join Fallbacks");
+    assert!(fallback.vertices.iter().all(|v| v.join.is_none()));
+    assert_eq!(named(&doc, "Join Fallbacks").stroke.join, StrokeJoin::Miter);
+    assert!(
+        warnings
+            .iter()
+            .any(|w| w.contains("vector points refer to point settings missing from the file; they use the layer's joins and plain corners")),
+        "{warnings:?}"
+    );
+    assert!(warnings.iter().any(|w| w.contains("unknown stroke joins use the layer join")), "{warnings:?}");
+    assert!(warnings.iter().any(|w| w.contains("dashed or variable-width strokes render with the layer join")), "{warnings:?}");
+}
+
+#[test]
+fn per_segment_stroke_styles_are_reported() {
+    let styled_import = |segment_style: u32| {
+        let mut blob = square_blob();
+        // The first segment's style id follows the counts and the vertices (12 bytes each).
+        blob[12 + 4 * 12..12 + 4 * 12 + 4].copy_from_slice(&segment_style.to_le_bytes());
+        let net = network::decode(&blob).unwrap();
+        assert_eq!((net.segments.len(), net.segments[0].style), (4, segment_style));
+        let mut message = tail_message();
+        let Kv::Object(fields) = &mut message else { panic!() };
+        let Kv::Array(blobs) = &mut fields.iter_mut().find(|(key, _)| *key == "blobs").unwrap().1 else { panic!() };
+        blobs[1] = o(vec![("bytes", Kv::Bytes(blob))]);
+        let (doc, warnings) = import(&canvas(&schema(), &message), "Tail").unwrap();
+        assert_eq!(network_of(&doc, "Wave").segments.len(), 4);
+        warnings
+    };
+    assert!(network::decode(&square_blob()).unwrap().segments.iter().all(|s| s.style == 0));
+    let plain = import(&tail_canvas(), "Tail").unwrap().1;
+    assert!(!plain.iter().any(|w| w.contains("vector segments")), "{plain:?}");
+    let uninterpreted = |w: &String| w.contains("style settings of some vector segments aren't supported; those segments use the layer's stroke");
+    let missing = |w: &String| w.contains("some vector segments refer to style settings missing from the file; they use the layer's stroke");
+    // Style 1 has a row in the layer's override table; its contents are not applied.
+    let known = styled_import(1);
+    assert_eq!(known.iter().filter(|w| uninterpreted(w)).count(), 1, "{known:?}");
+    assert!(!known.iter().any(missing), "{known:?}");
+    // Style 7 names no row at all.
+    let unknown = styled_import(7);
+    assert_eq!(unknown.iter().filter(|w| missing(w)).count(), 1, "{unknown:?}");
+    assert!(!unknown.iter().any(uninterpreted), "{unknown:?}");
 }
 
 #[test]
@@ -366,6 +446,29 @@ fn damaged_network_blobs_never_panic() {
     }
 }
 
+#[test]
+fn segment_styles_round_trip_without_changing_geometry() {
+    let original = Network {
+        vertices: vec![vtx(0, 2.0, 3.0), vtx(0, 10.0, 20.0), vtx(0, 40.0, 50.0), vtx(0, 60.0, 70.0)],
+        segments: vec![
+            seg(0, 1, (1.0, 2.0), (3.0, 4.0)),
+            Segment { style: 17, a: 1, ta: (5.0, 6.0), b: 2, tb: (7.0, 8.0) },
+            Segment { style: 27, a: 2, ta: (9.0, 10.0), b: 3, tb: (11.0, 12.0) },
+        ],
+        regions: vec![],
+    };
+    let bytes = network::encode(&original);
+    let decoded = network::decode(&bytes).unwrap();
+    assert_eq!(decoded.segments.len(), 3);
+    for (got, want) in decoded.segments.iter().zip(&original.segments) {
+        assert_eq!(got.style, want.style);
+        assert_eq!((got.a, got.ta, got.b, got.tb), (want.a, want.ta, want.b, want.tb));
+    }
+    for cut in 0..bytes.len() {
+        assert!(network::decode(&bytes[..cut]).is_none(), "truncated at {cut}");
+    }
+}
+
 #[test]
 fn mangled_tail_files_never_panic() {
     let c = tail_canvas();
@@ -392,8 +495,8 @@ fn mangled_tail_files_never_panic() {
             m[i] = r.next() as u8;
         }
         if let Ok(kv) = sc.decode_message(root, &m) {
-            let (json, _) = map::to_rest(&kv, "x");
-            let _ = crate::rest::import(&json, &crate::rest::no_images);
+            let (json, _, networks) = map::to_rest(&kv, "x", crate::rest::MAX_NODES);
+            let _ = crate::rest::import_with_networks(&json, &crate::rest::no_images, networks, crate::rest::MAX_NODES);
         }
     }
 }
diff --git a/crates/format/src/fig/tests.rs b/crates/format/src/fig/tests.rs
index 19c4fc157..b0c3c5fe9 100644
--- a/crates/format/src/fig/tests.rs
+++ b/crates/format/src/fig/tests.rs
@@ -33,12 +33,13 @@ enum NavigationType NAVIGATE OVERLAY
 enum TransitionType INSTANT_TRANSITION DISSOLVE SMART_ANIMATE
 enum EasingType IN_CUBIC OUT_CUBIC
 enum ConstraintType MIN CENTER MAX STRETCH SCALE
+enum LeadingTrim NONE CAP_HEIGHT
 struct GUID uint sessionID, uint localID
 struct Color float r, float g, float b, float a
 struct Vector float x, float y
 struct Matrix float m00, float m01, float m02, float m10, float m11, float m12
 struct ColorStop Color color, float position
-message Image byte[] hash, string name
+message Image byte[] hash, string name, uint dataBlob
 message AssetRef string key, string version
 message VariableID GUID guid, AssetRef assetRef
 message PropRefValue GUID defId
@@ -72,7 +73,7 @@ message Event InteractionType interactionType
 message Action GUID transitionNodeID, TransitionType transitionType, float transitionDuration, EasingType easingType, ConnectionType connectionType, NavigationType navigationType, VariableTarget targetVariable, VariableData targetVariableData, VariableSetID targetVariableSetID, GUID targetVariableModeID, ConditionalActions[] conditionalActions
 message Interaction Event event, Action[] actions
 message StartingPoint string name, string position
-message NodeChange GUID guid, ParentIndex parentIndex, NodeType type, string name, bool visible, float opacity, Vector size, Matrix transform, Paint[] fillPaints, Paint[] strokePaints, float strokeWeight, float cornerRadius, bool resizeToFit, bool internalOnly, float fontSize, FontName fontName, TextData textData, uint styleID, Path[] fillGeometry, Path[] strokeGeometry, StyleType styleType, StyleId styleIdForFill, SymbolData symbolData, PropDef[] componentPropDefs, PropAssignment[] componentPropAssignments, VariableDataMap parameterConsumptionMap, SetMode[] variableSetModes, VariableID variableSetID, ResolvedType variableResolvedType, Values variableDataValues, ModeMap variableModeBySetMap, Interaction[] prototypeInteractions, StartingPoint prototypeStartingPoint, GUIDPath guidPath, StackMode stackMode, float stackSpacing, float stackHorizontalPadding, float stackVerticalPadding, uint count, float starInnerScale, VectorData vectorData, StrokeCap strokeCap, StrokeJoin strokeJoin, VectorMirror handleMirroring, ShapeWithTextType shapeWithTextType, ConnectorEndpoint connectorStart, ConnectorEndpoint connectorEnd, StrokeCap connectorStartCap, StrokeCap connectorEndCap, ConnectorLineStyle connectorLineStyle, ConstraintType horizontalConstraint, ConstraintType verticalConstraint, NodeChange[] derivedSymbolData, string key, string version
+message NodeChange GUID guid, ParentIndex parentIndex, NodeType type, string name, bool visible, float opacity, Vector size, Matrix transform, Paint[] fillPaints, Paint[] strokePaints, float strokeWeight, float cornerRadius, bool resizeToFit, bool internalOnly, float fontSize, FontName fontName, TextData textData, uint styleID, Path[] fillGeometry, Path[] strokeGeometry, StyleType styleType, StyleId styleIdForFill, SymbolData symbolData, PropDef[] componentPropDefs, PropAssignment[] componentPropAssignments, VariableDataMap parameterConsumptionMap, SetMode[] variableSetModes, VariableID variableSetID, ResolvedType variableResolvedType, Values variableDataValues, ModeMap variableModeBySetMap, Interaction[] prototypeInteractions, StartingPoint prototypeStartingPoint, GUIDPath guidPath, StackMode stackMode, float stackSpacing, float stackHorizontalPadding, float stackVerticalPadding, uint count, float starInnerScale, VectorData vectorData, StrokeCap strokeCap, StrokeJoin strokeJoin, VectorMirror handleMirroring, ShapeWithTextType shapeWithTextType, ConnectorEndpoint connectorStart, ConnectorEndpoint connectorEnd, StrokeCap connectorStartCap, StrokeCap connectorEndCap, ConnectorLineStyle connectorLineStyle, ConstraintType horizontalConstraint, ConstraintType verticalConstraint, NodeChange[] derivedSymbolData, string key, string version, LeadingTrim leadingTrim, float[] dashPattern
 message Blob byte[] bytes
 message Message NodeChange[] nodeChanges, Blob[] blobs
 ";
@@ -283,6 +284,7 @@ fn message() -> Kv<'static> {
                 ("fillPaints", arr(vec![solid(0.0, 0.0, 0.0)])),
                 ("fontSize", f(16.0)),
                 ("fontName", font("Regular")),
+                ("leadingTrim", e("CAP_HEIGHT")),
                 ("textData", text),
             ],
         ),
@@ -390,6 +392,175 @@ fn named<'d>(doc: &'d figcraft_doc::Document, name: &str) -> &'d figcraft_doc::N
     doc.nodes().find(|n| n.name == name).unwrap_or_else(|| panic!("no layer {name}"))
 }
 
+/// The shared schema plus the grid sizing definitions only these tests use.
+fn grid_schema() -> Schema {
+    const NODE_FIELDS: &str = ", GridTrackMap gridColumns, GridTrackMap gridRows, GridTrackSizeMap gridColumnsSizing, GridTrackSizeMap gridRowsSizing, GUID gridColumnAnchor, GUID gridRowAnchor, uint gridColumnSpan, uint gridRowSpan, float gridColumnGap, float gridRowGap";
+    const TYPES: &str = "
+enum GridTrackSizingType FLEX FIXED HUG UNKNOWN
+message GridTrackSizeFunction GridTrackSizingType type, float value
+message GridTrackSize GridTrackSizeFunction minSizing, GridTrackSizeFunction maxSizing
+message GridTrackSizeEntry GUID id, GridTrackSize trackSize
+message GridTrackSizeMap GridTrackSizeEntry[] entries
+message GridTrackEntry GUID id, string position
+message GridTrackMap GridTrackEntry[] entries
+message Blob ";
+    let text = SCHEMA.replace("enum StackMode NONE HORIZONTAL VERTICAL\n", "enum StackMode NONE HORIZONTAL VERTICAL GRID\n").replacen(
+        "\nmessage Blob ",
+        &format!("{NODE_FIELDS}{TYPES}"),
+        1,
+    );
+    Schema::parse(&text).unwrap()
+}
+
+fn track_size(kind: &'static str, value: f64) -> Kv<'static> {
+    let sizing = || o(vec![("type", e(kind)), ("value", f(value))]);
+    o(vec![("minSizing", sizing()), ("maxSizing", sizing())])
+}
+
+fn ranged_track_size(min: Kv<'static>, max: Kv<'static>) -> Kv<'static> {
+    o(vec![("minSizing", min), ("maxSizing", max)])
+}
+
+fn track_map_entry(id: u64, size: Kv<'static>) -> Kv<'static> {
+    o(vec![("id", g(id)), ("trackSize", size)])
+}
+
+fn positioned_track(id: u64, position: &'static str) -> Kv<'static> {
+    o(vec![("id", g(id)), ("position", s(position))])
+}
+
+fn unpositioned_track(id: u64) -> Kv<'static> {
+    o(vec![("id", g(id))])
+}
+
+#[test]
+fn grid_tracks_import_by_guid_and_keep_track_order() {
+    let cols = arr(vec![positioned_track(13, "$"), unpositioned_track(10), positioned_track(12, "#"), unpositioned_track(11)]);
+    let rows = arr(vec![positioned_track(21, "\""), positioned_track(20, "!")]);
+    // Sizing entries intentionally differ from track order. Their GUIDs define the join.
+    let col_sizes = arr(vec![
+        track_map_entry(12, track_size("FLEX", 1.0)),
+        track_map_entry(10, track_size("FIXED", 120.0)),
+        track_map_entry(13, track_size("FLEX", 2.0)),
+        track_map_entry(11, track_size("HUG", 80.0)),
+    ]);
+    let row_sizes = arr(vec![track_map_entry(21, track_size("HUG", 30.0)), track_map_entry(20, track_size("FIXED", 50.0))]);
+    let nodes = vec![
+        node(0, None, "DOCUMENT", "Document", vec![]),
+        node(1, Some((0, "!")), "CANVAS", "Page", vec![]),
+        node(
+            2,
+            Some((1, "!")),
+            "FRAME",
+            "Grid",
+            vec![
+                ("size", xy(600.0, 300.0)),
+                ("transform", at(0.0, 0.0)),
+                ("stackMode", e("GRID")),
+                ("gridColumns", o(vec![("entries", cols)])),
+                ("gridRows", o(vec![("entries", rows)])),
+                ("gridColumnsSizing", o(vec![("entries", col_sizes)])),
+                ("gridRowsSizing", o(vec![("entries", row_sizes)])),
+                ("gridColumnGap", f(10.0)),
+                ("gridRowGap", f(12.0)),
+            ],
+        ),
+        node(
+            3,
+            Some((2, "!")),
+            "RECTANGLE",
+            "Hug child",
+            vec![
+                ("size", xy(80.0, 30.0)),
+                ("transform", at(0.0, 0.0)),
+                ("gridColumnAnchor", g(11)),
+                ("gridRowAnchor", g(21)),
+                ("gridColumnSpan", u(2)),
+                ("gridRowSpan", u(1)),
+            ],
+        ),
+    ];
+    let bytes = canvas(&grid_schema(), &o(vec![("nodeChanges", arr(nodes))]));
+    let (doc, warnings) = import(&bytes, "Grid tracks").unwrap();
+    let grid = named(&doc, "Grid").layout.as_ref().unwrap();
+    assert_eq!((grid.mode, grid.grid_columns, grid.grid_rows, grid.gap, grid.cross_gap), (figcraft_doc::LayoutMode::Grid, 4, 2, 10.0, 12.0));
+    assert_eq!(
+        grid.column_tracks,
+        vec![
+            figcraft_doc::GridTrack::fixed(120.0),
+            figcraft_doc::GridTrack::hug(),
+            figcraft_doc::GridTrack::fill(1.0),
+            figcraft_doc::GridTrack::fill(2.0),
+        ]
+    );
+    assert_eq!(grid.row_tracks, vec![figcraft_doc::GridTrack::fixed(50.0), figcraft_doc::GridTrack::hug()]);
+    let child = &named(&doc, "Hug child").child_layout;
+    assert_eq!((child.grid_column, child.grid_row, child.grid_column_span, child.grid_row_span), (Some(1), Some(1), 2, 1));
+    assert!(!warnings.iter().any(|w| w.contains("grid track")), "{warnings:?}");
+}
+
+#[test]
+fn malformed_grid_tracks_warn_and_keep_equal_track_fallbacks() {
+    let tracks = arr(vec![positioned_track(30, "!"), positioned_track(31, "\""), positioned_track(32, "#"), positioned_track(33, "$")]);
+    let sizing = arr(vec![
+        track_map_entry(30, track_size("FIXED", -1.0)),
+        track_map_entry(31, ranged_track_size(o(vec![("type", e("FLEX")), ("value", f(1.0))]), o(vec![("type", e("FLEX")), ("value", f(2.0))]))),
+        track_map_entry(33, track_size("UNKNOWN", 5.0)),
+        track_map_entry(34, track_size("FLEX", 3.0)),
+    ]);
+    let nodes = vec![
+        node(0, None, "DOCUMENT", "Document", vec![]),
+        node(1, Some((0, "!")), "CANVAS", "Page", vec![]),
+        node(
+            2,
+            Some((1, "!")),
+            "FRAME",
+            "Grid",
+            vec![
+                ("size", xy(100.0, 100.0)),
+                ("transform", at(0.0, 0.0)),
+                ("stackMode", e("GRID")),
+                ("gridColumns", o(vec![("entries", tracks)])),
+                ("gridColumnsSizing", o(vec![("entries", sizing)])),
+            ],
+        ),
+    ];
+    let bytes = canvas(&grid_schema(), &o(vec![("nodeChanges", arr(nodes))]));
+    let (doc, warnings) = import(&bytes, "Malformed grid tracks").unwrap();
+    let layout = named(&doc, "Grid").layout.as_ref().unwrap();
+    assert_eq!(layout.column_tracks, vec![figcraft_doc::GridTrack::default(); 4]);
+    assert!(warnings.iter().any(|w| w.contains("grid track sizing is unsupported or malformed")), "{warnings:?}");
+    assert!(warnings.iter().any(|w| w.contains("stale or invalid grid track sizing entries")), "{warnings:?}");
+}
+
+#[test]
+fn oversized_grid_track_lists_warn_and_use_default_tracks() {
+    let oversized: Vec<Kv<'static>> = (0..1_001).map(|i| unpositioned_track(100 + i)).collect();
+    let sizing = vec![track_map_entry(100, track_size("FIXED", 40.0))];
+    let nodes = vec![
+        node(0, None, "DOCUMENT", "Document", vec![]),
+        node(1, Some((0, "!")), "CANVAS", "Page", vec![]),
+        node(
+            2,
+            Some((1, "!")),
+            "FRAME",
+            "Grid",
+            vec![
+                ("size", xy(100.0, 100.0)),
+                ("transform", at(0.0, 0.0)),
+                ("stackMode", e("GRID")),
+                ("gridColumns", o(vec![("entries", arr(oversized))])),
+                ("gridColumnsSizing", o(vec![("entries", arr(sizing))])),
+            ],
+        ),
+    ];
+    let bytes = canvas(&grid_schema(), &o(vec![("nodeChanges", arr(nodes))]));
+    let (doc, warnings) = import(&bytes, "Oversized grid tracks").unwrap();
+    let layout = named(&doc, "Grid").layout.as_ref().unwrap();
+    assert!(layout.column_tracks.is_empty(), "{:?}", layout.column_tracks.len());
+    assert!(warnings.iter().any(|w| w.contains("grid track list exceeds 1000 entries")), "{warnings:?}");
+}
+
 #[test]
 fn kiwi_round_trip() {
     let sc = schema();
@@ -477,6 +648,7 @@ fn imports_the_fixture() {
     let NodeKind::Text(t) = &named(&doc, "Title").kind else { panic!("not text") };
     assert_eq!(t.characters, "Hi there");
     assert_eq!(t.style.font_size, 16.0);
+    assert_eq!(t.leading_trim, figcraft_doc::LeadingTrim::CapHeight, "vertical trim (#466)");
     assert_eq!(t.runs.len(), 1);
     assert_eq!((t.runs[0].start, t.runs[0].end, t.runs[0].style.font_style.as_str()), (3, 6, "Bold"));
     // The group's children keep their place on the page (group at 100, 100).
@@ -539,6 +711,53 @@ fn bare_canvas_and_zlib_chunks_open() {
     assert!(import(&out, "Z").is_ok());
 }
 
+/// The fixture message with the photo's image bytes in its own blobs, as copies written by plugins
+/// and tools carry them: the PNG goes at the end of `blobs` and `image.dataBlob` points `shift`
+/// places past it (0 is the PNG itself).
+fn message_with_image_in_blobs(shift: u64) -> Kv<'static> {
+    fn point_images_at(value: &mut Kv<'static>, blob: u64) {
+        match value {
+            Kv::Object(fields) => {
+                for (name, field) in fields.iter_mut() {
+                    match field {
+                        Kv::Object(image) if *name == "image" => image.push(("dataBlob", u(blob))),
+                        _ => point_images_at(field, blob),
+                    }
+                }
+            }
+            Kv::Array(items) => items.iter_mut().for_each(|item| point_images_at(item, blob)),
+            _ => {}
+        }
+    }
+    let mut msg = message();
+    let index = {
+        let Kv::Object(fields) = &mut msg else { panic!("the message is an object") };
+        let Some((_, Kv::Array(blobs))) = fields.iter_mut().find(|(name, _)| *name == "blobs") else { panic!("no blobs") };
+        blobs.push(o(vec![("bytes", Kv::Bytes(png()))]));
+        blobs.len() as u64 - 1
+    };
+    point_images_at(&mut msg, index + shift);
+    msg
+}
+
+#[test]
+fn a_bare_canvas_reads_images_carried_in_its_blobs() {
+    // The clipboard holds a bare canvas (no `images/`); the image comes from `image.dataBlob`.
+    let c = canvas(&schema(), &message_with_image_in_blobs(0));
+    let (doc, warnings) = import(&c, "Pasted").unwrap();
+    let photo = named(&doc, "Photo");
+    let figcraft_doc::color::PaintKind::Image(img) = &photo.fills[0].kind else { panic!("not an image fill") };
+    assert_eq!(doc.images.get(&img.image).map(|i| (i.width, i.height)), Some((2, 1)));
+    assert!(!warnings.iter().any(|w| w.contains("isn't in the file")), "{warnings:?}");
+}
+
+#[test]
+fn a_data_blob_past_the_blobs_stays_a_placeholder() {
+    let c = canvas(&schema(), &message_with_image_in_blobs(5));
+    let (_, warnings) = import(&c, "Pasted").unwrap();
+    assert!(warnings.iter().any(|w| w.contains("isn't in the file")), "{warnings:?}");
+}
+
 #[test]
 fn other_files_are_not_fig() {
     assert!(try_import(b"{\"document\": {}}", "x").is_none());
@@ -588,7 +807,7 @@ fn mangled_kiwi_never_panics() {
     }
     for cut in (0..msg.len()).step_by(3) {
         if let Ok(kv) = sc.decode_message(root, &msg[..cut]) {
-            let _ = map::to_rest(&kv, "x");
+            let _ = map::to_rest(&kv, "x", crate::rest::MAX_NODES);
         }
     }
     for _ in 0..2000 {
@@ -598,8 +817,8 @@ fn mangled_kiwi_never_panics() {
             m[i] = r.next() as u8;
         }
         if let Ok(kv) = sc.decode_message(root, &m) {
-            let (json, _) = map::to_rest(&kv, "x");
-            let _ = crate::rest::import(&json, &crate::rest::no_images);
+            let (json, _, networks) = map::to_rest(&kv, "x", crate::rest::MAX_NODES);
+            let _ = crate::rest::import_with_networks(&json, &crate::rest::no_images, networks, crate::rest::MAX_NODES);
         }
         let mut sbytes = schema_bytes.clone();
         let i = (r.next() as usize) % sbytes.len();
@@ -621,6 +840,61 @@ fn mangled_kiwi_never_panics() {
     }
 }
 
+#[test]
+fn large_files_get_a_larger_value_budget() {
+    // Small files keep the fixed floor: a few bytes can't expand into a huge tree.
+    assert_eq!(kiwi::value_budget(0), 20_000_000);
+    assert_eq!(kiwi::value_budget(1 << 20), 20_000_000);
+    // A real 400 000-layer file: an 83.5 MB canvas whose message unpacks to 334 MB and holds
+    // 30.5 million values was refused as "too many values".
+    assert!(kiwi::value_budget(83_491_232) > 30_514_899);
+    // A real 194 MB design-system file (UX4G): a 39.5 MB canvas holding 29.7 million values.
+    assert!(kiwi::value_budget(39_528_420) > 29_703_730);
+    // Still bounded by the largest canvas read.
+    assert!(kiwi::value_budget(MAX_CANVAS as usize) <= 128 << 20);
+}
+
+#[test]
+fn the_layer_cap_follows_the_file_size() {
+    // A small (or broken) file keeps the REST import's cap: instances expand into a layer per
+    // layer of their component, and a few bytes mustn't claim millions of layers.
+    assert_eq!(layer_budget(0), crate::rest::MAX_NODES);
+    assert_eq!(layer_budget(1 << 20), crate::rest::MAX_NODES);
+    // A real 894 004-layer file (an 83.5 MB canvas) stopped at 200 000 and came in with 27 of
+    // its 30 pages empty.
+    assert!(layer_budget(83_491_232) > 894_004);
+    // No file gets more than the ceiling.
+    assert_eq!(layer_budget(MAX_CANVAS as usize), MAX_FIG_NODES);
+}
+
+#[test]
+fn a_small_file_that_unpacks_large_gets_no_larger_budgets() {
+    // 40 MB of zeros in a blob pack into a few KB. Keyed to the unpacked message, they lifted the
+    // layer cap above the 231 231 layers its instances expand into; keyed to the file, the cap
+    // stays at the REST import's.
+    let mut nodes = vec![node(0, None, "DOCUMENT", "D", vec![]), node(1, Some((0, "!")), "CANVAS", "P", vec![])];
+    nodes.push(node(5, Some((1, "!")), "SYMBOL", "Main", vec![("size", xy(10.0, 10.0))]));
+    nodes.extend((10..1010).map(|i| node(i, Some((5, "!")), "RECTANGLE", "R", vec![("size", xy(1.0, 1.0))])));
+    nodes.extend((2000..2230).map(|i| node(i, Some((1, "!")), "INSTANCE", "I", vec![("symbolData", o(vec![("symbolID", g(5))]))])));
+    let blob = o(vec![("bytes", Kv::Bytes(vec![0; 40 << 20]))]);
+    let file = canvas(&schema(), &o(vec![("nodeChanges", arr(nodes)), ("blobs", arr(vec![blob]))]));
+    assert!(file.len() < 1 << 20, "{} bytes", file.len());
+    let (doc, warnings) = import(&file, "x").unwrap();
+    assert!(warnings.iter().any(|w| w.contains("more than 200000 layers")), "{warnings:?}");
+    assert!(doc.node_count() <= crate::rest::MAX_NODES + 10);
+}
+
+#[test]
+fn the_mapper_stops_at_the_layer_cap_it_is_given() {
+    let mut nodes = vec![node(0, None, "DOCUMENT", "D", vec![]), node(1, Some((0, "!")), "CANVAS", "P", vec![])];
+    nodes.extend((2..12).map(|i| node(i, Some((1, "!")), "RECTANGLE", "R", vec![("size", xy(1.0, 1.0))])));
+    let msg = o(vec![("nodeChanges", arr(nodes))]);
+    let (_, warnings, _) = map::to_rest(&msg, "x", 5);
+    assert!(warnings.iter().any(|w| w.contains("more than 5 layers")), "{warnings:?}");
+    let (_, warnings, _) = map::to_rest(&msg, "x", crate::rest::MAX_NODES);
+    assert!(!warnings.iter().any(|w| w.contains("more than")), "{warnings:?}");
+}
+
 #[test]
 fn hostile_input_is_refused() {
     // A message that contains itself, nested past the depth cap.
@@ -873,6 +1147,12 @@ fn nested_instances_resized_again_drop_the_layout_derived_for_their_old_size() {
 #[path = "tail_tests.rs"]
 mod tail;
 
+#[path = "image_filter_tests.rs"]
+mod image_filters;
+
+#[path = "text_list_tests.rs"]
+mod text_list;
+
 /// `.fig` files in the folder `FIGCRAFT_FIG_SAMPLES` names (none when it's unset).
 pub(super) fn samples() -> Vec<std::path::PathBuf> {
     let Some(dir) = std::env::var_os("FIGCRAFT_FIG_SAMPLES") else { return Vec::new() };
@@ -916,7 +1196,7 @@ fn dump_samples() {
         std::fs::write(format!("{out}/{stem}.schema.txt"), txt).unwrap();
         let msg = schema.decode_message(schema.find("Message").unwrap(), &message).unwrap();
         std::fs::write(format!("{out}/{stem}.json"), serde_json::to_string_pretty(&debug_json(&msg)).unwrap()).unwrap();
-        let (rest, _) = map::to_rest(&msg, &stem);
+        let (rest, ..) = map::to_rest(&msg, &stem, super::layer_budget(message.len()));
         std::fs::write(format!("{out}/{stem}.rest.json"), serde_json::to_string_pretty(&rest).unwrap()).unwrap();
     }
 }
diff --git a/crates/format/src/fig/text_list_tests.rs b/crates/format/src/fig/text_list_tests.rs
new file mode 100644
index 000000000..eca7b0dc5
--- /dev/null
+++ b/crates/format/src/fig/text_list_tests.rs
@@ -0,0 +1,93 @@
+//! Numbered lists that start past 1 (#686): each text line says where its list starts counting,
+//! less one (`listStartOffset`). Fixtures built in code with the parent module's helpers.
+
+use figcraft_doc::{ListStyle, NodeKind, ParaList};
+
+use super::*;
+
+const LIST_SCHEMA: &str = "
+enum NodeType NONE DOCUMENT CANVAS TEXT
+enum LineType PLAIN ORDERED_LIST UNORDERED_LIST
+struct GUID uint sessionID, uint localID
+struct Vector float x, float y
+struct Matrix float m00, float m01, float m02, float m10, float m11, float m12
+message ParentIndex GUID guid, string position
+message TextLineData LineType lineType, int indentationLevel, int listStartOffset, bool isFirstLineOfList
+message TextData string characters, TextLineData[] lines
+message NodeChange GUID guid, ParentIndex parentIndex, NodeType type, string name, Vector size, Matrix transform, float fontSize, TextData textData
+message Message NodeChange[] nodeChanges
+";
+
+/// A list line: type, start offset, first of its list.
+fn line(ty: &'static str, offset: i64, first: bool) -> Kv<'static> {
+    let level = i64::from(ty != "PLAIN");
+    o(vec![("lineType", e(ty)), ("indentationLevel", Kv::Int(level)), ("listStartOffset", Kv::Int(offset)), ("isFirstLineOfList", Kv::Bool(first))])
+}
+
+fn text_node(id: u64, name: &str, chars: &str, lines: Vec<Kv<'static>>) -> Kv<'static> {
+    let pos = ["!", "\"", "#", "$", "%", "&"][id as usize % 6];
+    node(
+        id,
+        Some((1, pos)),
+        "TEXT",
+        name,
+        vec![
+            ("size", xy(200.0, 60.0)),
+            ("transform", at(0.0, 0.0)),
+            ("fontSize", f(16.0)),
+            ("textData", o(vec![("characters", s(chars)), ("lines", arr(lines))])),
+        ],
+    )
+}
+
+fn starts(doc: &figcraft_doc::Document, name: &str) -> Vec<(ListStyle, u32)> {
+    let NodeKind::Text(t) = &named(doc, name).kind else { panic!("{name} is no text") };
+    (0..t.paragraph_count()).map(|p| t.para_list(p)).map(|p: ParaList| (p.list, p.start_offset)).collect()
+}
+
+#[test]
+fn numbered_lists_keep_their_start() {
+    use ListStyle::{Bulleted as B, None as P, Numbered as N};
+    let nodes = vec![
+        node(0, None, "DOCUMENT", "Document", vec![]),
+        node(1, Some((0, "!")), "CANVAS", "Page", vec![]),
+        text_node(2, "From 1", "Start here", vec![line("ORDERED_LIST", 0, true)]),
+        text_node(3, "From 2", "Next try this", vec![line("ORDERED_LIST", 1, true)]),
+        text_node(4, "First only", "a\nb\nc", vec![line("ORDERED_LIST", 3, true), line("ORDERED_LIST", 0, false), line("ORDERED_LIST", 0, false)]),
+        text_node(5, "Every line", "a\nb\nc", vec![line("ORDERED_LIST", 3, true), line("ORDERED_LIST", 3, false), line("ORDERED_LIST", 3, false)]),
+        text_node(6, "Mixed", "x\na\nb", vec![line("PLAIN", 0, false), line("ORDERED_LIST", 4, true), line("UNORDERED_LIST", 2, true)]),
+        text_node(7, "Junk", "a", vec![line("ORDERED_LIST", -5, true)]),
+    ];
+    let sc = Schema::parse(LIST_SCHEMA).unwrap();
+    let (doc, warnings) = import(&canvas(&sc, &o(vec![("nodeChanges", arr(nodes))])), "x").unwrap();
+    assert!(warnings.is_empty(), "{warnings:?}");
+    assert_eq!(starts(&doc, "From 1"), [(N, 0)]);
+    assert_eq!(starts(&doc, "From 2"), [(N, 1)], "shows 2.");
+    assert_eq!(starts(&doc, "First only"), [(N, 3), (N, 0), (N, 0)]);
+    assert_eq!(starts(&doc, "Every line"), [(N, 3), (N, 3), (N, 3)]);
+    assert_eq!(starts(&doc, "Mixed"), [(P, 0), (N, 4), (B, 0)], "bullets have no number, so no start");
+    assert_eq!(starts(&doc, "Junk"), [(N, 0)], "a negative offset counts from 1");
+}
+
+#[test]
+fn the_export_writes_where_a_list_starts() {
+    let mut doc = figcraft_doc::Document::new("Lists");
+    let page = doc.first_page().unwrap();
+    use ListStyle::{Bulleted as B, None as P, Numbered as N};
+    let mut td = figcraft_doc::TextData::new("two\nthree\nplain\nsix\ndot");
+    let pl = |list, start_offset| ParaList { list, indent: 0, start_offset };
+    td.paragraphs = vec![pl(N, 1), pl(N, 0), pl(P, 0), pl(N, 5), pl(B, 4)];
+    doc.create(page, NodeKind::Text(td), "List", 0.0, 0.0, 200.0, 80.0).unwrap();
+    let (bytes, _) = super::super::export(&doc, None).unwrap();
+    let a = Archive::open(&bytes).unwrap();
+    let (schema, message) = decode_canvas(&a.canvas).unwrap();
+    let msg = schema.decode_message(schema.find("Message").unwrap(), &message).unwrap();
+    let text = msg.get("nodeChanges").unwrap().list().iter().find(|n| n.get("name").and_then(Kv::str) == Some("List")).unwrap();
+    let lines = text.get("textData").and_then(|d| d.get("lines")).map(Kv::list).unwrap();
+    let offsets: Vec<f64> = lines.iter().map(|l| l.get("listStartOffset").and_then(Kv::f64).unwrap()).collect();
+    // Every line of a numbered list carries its first item's start (a reader that takes it per
+    // line or per list counts the same); bullets and plain lines carry none.
+    assert_eq!(offsets, [1.0, 1.0, 0.0, 5.0, 0.0]);
+    let (back, _) = import(&bytes, "x").unwrap();
+    assert_eq!(starts(&back, "List"), [(N, 1), (N, 1), (P, 0), (N, 5), (B, 0)]);
+}
diff --git a/crates/format/src/fig/text_paragraph_tests.rs b/crates/format/src/fig/text_paragraph_tests.rs
new file mode 100644
index 000000000..b3f05b055
--- /dev/null
+++ b/crates/format/src/fig/text_paragraph_tests.rs
@@ -0,0 +1,288 @@
+//! Paragraph options (list spacing, hanging list and punctuation, leading trim) in encoded `.fig`
+//! files: the highest valid value wins, invalid instance rows fall through, native saves keep them.
+
+use super::kiwi::Kv;
+use super::{export, import};
+
+fn paragraph_fig(shared: Vec<(&'static str, Kv<'static>)>, local: Vec<(&'static str, Kv<'static>)>) -> Vec<u8> {
+    use super::kiwi::{Schema, encode};
+
+    let schema = Schema::parse(
+        "enum NodeType NONE DOCUMENT CANVAS TEXT\n\
+         enum StyleType NONE FILL TEXT\n\
+         enum LeadingTrim NONE CAP_HEIGHT\n\
+         struct GUID uint sessionID, uint localID\n\
+         struct ParentIndex GUID guid, string position\n\
+         struct FontName string family, string style, string postscript\n\
+         struct StyleId GUID guid\n\
+         message TextData string characters\n\
+         message NodeChange GUID guid, ParentIndex parentIndex, NodeType type, string name, StyleType styleType, FontName fontName, float fontSize, StyleId styleIdForText, TextData textData, float paragraphSpacing, float paragraphIndent, float listSpacing, bool hangingList, bool hangingPunctuation, LeadingTrim leadingTrim\n\
+         message Message NodeChange[] nodeChanges",
+    )
+    .unwrap();
+    fn object(fields: Vec<(&'static str, Kv<'static>)>) -> Kv<'static> {
+        Kv::Object(fields)
+    }
+    fn guid(id: u64) -> Kv<'static> {
+        object(vec![("sessionID", Kv::Uint(7)), ("localID", Kv::Uint(id))])
+    }
+    fn node(id: u64, ty: &'static str, name: &str, parent: Option<u64>, fields: Vec<(&'static str, Kv<'static>)>) -> Kv<'static> {
+        let mut out = vec![("guid", guid(id)), ("type", Kv::Enum(ty)), ("name", Kv::Str(name.into()))];
+        if let Some(parent) = parent {
+            out.push(("parentIndex", object(vec![("guid", guid(parent)), ("position", Kv::Str("a".into()))])));
+        }
+        out.extend(fields);
+        object(out)
+    }
+    fn font(family: &str) -> Kv<'static> {
+        object(vec![("family", Kv::Str(family.into())), ("style", Kv::Str("Regular".into())), ("postscript", Kv::Str(String::new()))])
+    }
+    let mut base = vec![("styleType", Kv::Enum("TEXT")), ("fontName", font("Inter")), ("fontSize", Kv::Float(20.0))];
+    base.extend(shared);
+    let mut layer = vec![
+        ("fontName", font("Stale")),
+        ("fontSize", Kv::Float(40.0)),
+        ("styleIdForText", object(vec![("guid", guid(10))])),
+        ("textData", object(vec![("characters", Kv::Str("a\nb".into()))])),
+    ];
+    layer.extend(local);
+    let msg = object(vec![(
+        "nodeChanges",
+        Kv::Array(vec![
+            node(1, "DOCUMENT", "Document", None, vec![]),
+            node(2, "CANVAS", "Page", Some(1), vec![]),
+            node(10, "TEXT", "Shared", Some(2), base),
+            node(11, "TEXT", "Label", Some(2), layer),
+        ]),
+    )]);
+    let root = schema.find("Message").unwrap();
+    let mut deflated = flate2::write::DeflateEncoder::new(Vec::new(), flate2::Compression::default());
+    use std::io::Write;
+    deflated.write_all(&encode::schema(&schema)).unwrap();
+    let schema_chunk = deflated.finish().unwrap();
+    let message = encode::message(&schema, root, &msg).unwrap();
+    let message_chunk = ruzstd::encoding::compress_to_vec(message.as_slice(), ruzstd::encoding::CompressionLevel::Fastest);
+    let mut bytes = b"fig-kiwi".to_vec();
+    bytes.extend_from_slice(&101u32.to_le_bytes());
+    for chunk in [schema_chunk, message_chunk] {
+        bytes.extend_from_slice(&(chunk.len() as u32).to_le_bytes());
+        bytes.extend_from_slice(&chunk);
+    }
+    bytes
+}
+
+#[test]
+fn encoded_fig_maps_paragraph_list_fields_through_native_round_trip() {
+    let shared = vec![
+        ("listSpacing", Kv::Float(18.0)),
+        ("hangingList", Kv::Bool(false)),
+        ("hangingPunctuation", Kv::Bool(false)),
+        ("leadingTrim", Kv::Enum("CAP_HEIGHT")),
+    ];
+    let (inherited, warnings) = import(&paragraph_fig(shared.clone(), vec![]), "Synthetic paragraph options").unwrap();
+    assert!(warnings.is_empty(), "{warnings:?}");
+    let text = inherited.nodes().find(|node| node.name == "Label").unwrap().kind.text().unwrap();
+    assert_eq!(text.list_spacing, 18.0);
+    assert!(!text.hanging_list);
+    assert!(!text.hanging_punctuation);
+    assert_eq!(text.leading_trim, figcraft_doc::LeadingTrim::CapHeight);
+    assert_eq!(text.style.font_family, "Inter");
+
+    let reset = vec![
+        ("listSpacing", Kv::Float(0.0)),
+        ("hangingList", Kv::Bool(false)),
+        ("hangingPunctuation", Kv::Bool(false)),
+        ("leadingTrim", Kv::Enum("NONE")),
+    ];
+    let (cleared, warnings) = import(&paragraph_fig(shared, reset), "Synthetic paragraph resets").unwrap();
+    assert!(warnings.is_empty(), "{warnings:?}");
+    let text = cleared.nodes().find(|node| node.name == "Label").unwrap().kind.text().unwrap();
+    assert_eq!(text.list_spacing, 0.0);
+    assert!(!text.hanging_list);
+    assert!(!text.hanging_punctuation);
+    assert_eq!(text.leading_trim, figcraft_doc::LeadingTrim::None);
+    assert_eq!(text.style.font_family, "Inter");
+
+    let bytes = crate::save_bytes(&inherited, None).unwrap();
+    let (back, warnings) = crate::load_bytes(&bytes).unwrap();
+    assert!(warnings.is_empty(), "native round trip: {warnings:?}");
+    let text = back.nodes().find(|node| node.name == "Label").unwrap().kind.text().unwrap();
+    assert_eq!(text.list_spacing, 18.0);
+    assert!(!text.hanging_list);
+    assert!(!text.hanging_punctuation);
+    assert_eq!(text.leading_trim, figcraft_doc::LeadingTrim::CapHeight);
+
+    let (_, export_warnings) = export(&inherited, None).unwrap();
+    assert!(
+        export_warnings.iter().any(|warning| warning.contains("list spacing, hanging punctuation, leading trim")),
+        "existing .fig export loss must remain visible: {export_warnings:?}"
+    );
+}
+
+fn instance_paragraph_fig(overrides: Vec<(&'static str, Kv<'static>)>, nonfinite_spacing: bool) -> Vec<u8> {
+    use super::kiwi::{Schema, encode};
+
+    let schema = Schema::parse(
+        "enum NodeType NONE DOCUMENT CANVAS TEXT SYMBOL INSTANCE\n\
+         enum StyleType NONE FILL TEXT\n\
+         enum LeadingTrim NONE CAP_HEIGHT\n\
+         struct GUID uint sessionID, uint localID\n\
+         struct ParentIndex GUID guid, string position\n\
+         struct FontName string family, string style, string postscript\n\
+         struct StyleId GUID guid\n\
+         struct GUIDPath GUID[] guids\n\
+         struct SymbolOverride GUIDPath guidPath, float listSpacing, bool hangingList, bool hangingPunctuation, LeadingTrim leadingTrim\n\
+         struct SymbolData GUID symbolID, SymbolOverride[] symbolOverrides\n\
+         message TextData string characters\n\
+         message NodeChange GUID guid, ParentIndex parentIndex, NodeType type, string name, StyleType styleType, FontName fontName, float fontSize, StyleId styleIdForText, TextData textData, float listSpacing, bool hangingList, bool hangingPunctuation, LeadingTrim leadingTrim, SymbolData symbolData\n\
+         message Message NodeChange[] nodeChanges",
+    )
+    .unwrap();
+    fn object(fields: Vec<(&'static str, Kv<'static>)>) -> Kv<'static> {
+        Kv::Object(fields)
+    }
+    fn guid(id: u64) -> Kv<'static> {
+        object(vec![("sessionID", Kv::Uint(7)), ("localID", Kv::Uint(id))])
+    }
+    fn node(id: u64, ty: &'static str, name: &str, parent: Option<u64>, fields: Vec<(&'static str, Kv<'static>)>) -> Kv<'static> {
+        let mut out = vec![("guid", guid(id)), ("type", Kv::Enum(ty)), ("name", Kv::Str(name.into()))];
+        if let Some(parent) = parent {
+            out.push(("parentIndex", object(vec![("guid", guid(parent)), ("position", Kv::Str("a".into()))])));
+        }
+        out.extend(fields);
+        object(out)
+    }
+    fn font() -> Kv<'static> {
+        object(vec![("family", Kv::Str("Inter".into())), ("style", Kv::Str("Regular".into())), ("postscript", Kv::Str(String::new()))])
+    }
+    let main_text = node(
+        21,
+        "TEXT",
+        "Label",
+        Some(20),
+        vec![
+            ("fontName", font()),
+            ("fontSize", Kv::Float(20.0)),
+            ("styleIdForText", object(vec![("guid", guid(10))])),
+            ("textData", object(vec![("characters", Kv::Str("a\nb".into()))])),
+        ],
+    );
+    let mut override_fields = vec![("guidPath", object(vec![("guids", Kv::Array(vec![guid(21)]))]))];
+    override_fields.extend(overrides);
+    let instance = node(
+        30,
+        "INSTANCE",
+        "Copy",
+        Some(2),
+        vec![("symbolData", object(vec![("symbolID", guid(20)), ("symbolOverrides", Kv::Array(vec![object(override_fields)]))]))],
+    );
+    let message = object(vec![(
+        "nodeChanges",
+        Kv::Array(vec![
+            node(1, "DOCUMENT", "Document", None, vec![]),
+            node(2, "CANVAS", "Page", Some(1), vec![]),
+            node(
+                10,
+                "TEXT",
+                "Shared",
+                Some(2),
+                vec![
+                    ("styleType", Kv::Enum("TEXT")),
+                    ("fontName", font()),
+                    ("fontSize", Kv::Float(20.0)),
+                    ("listSpacing", Kv::Float(18.0)),
+                    ("hangingList", Kv::Bool(true)),
+                    ("hangingPunctuation", Kv::Bool(true)),
+                    ("leadingTrim", Kv::Enum("CAP_HEIGHT")),
+                ],
+            ),
+            node(20, "SYMBOL", "Main", Some(2), vec![]),
+            main_text,
+            instance,
+        ]),
+    )]);
+    let root = schema.find("Message").unwrap();
+    let mut deflated = flate2::write::DeflateEncoder::new(Vec::new(), flate2::Compression::default());
+    use std::io::Write;
+    deflated.write_all(&encode::schema(&schema)).unwrap();
+    let schema_chunk = deflated.finish().unwrap();
+    let mut message = encode::message(&schema, root, &message).unwrap();
+    if nonfinite_spacing {
+        let finite = 37.0_f32.to_bits().rotate_right(23).to_le_bytes();
+        let nan = f32::NAN.to_bits().rotate_right(23).to_le_bytes();
+        let matches: Vec<usize> = message.windows(finite.len()).enumerate().filter_map(|(i, w)| (w == finite).then_some(i)).collect();
+        assert_eq!(matches.len(), 1, "finite test token must identify the instance listSpacing field");
+        let offset = matches[0];
+        message[offset..offset + nan.len()].copy_from_slice(&nan);
+    }
+    let message_chunk = ruzstd::encoding::compress_to_vec(message.as_slice(), ruzstd::encoding::CompressionLevel::Fastest);
+    let mut bytes = b"fig-kiwi".to_vec();
+    bytes.extend_from_slice(&101u32.to_le_bytes());
+    for chunk in [schema_chunk, message_chunk] {
+        bytes.extend_from_slice(&(chunk.len() as u32).to_le_bytes());
+        bytes.extend_from_slice(&chunk);
+    }
+    bytes
+}
+
+#[test]
+fn encoded_instance_paragraph_overrides_fall_back_only_when_invalid() {
+    let valid = vec![
+        ("listSpacing", Kv::Float(24.0)),
+        ("hangingList", Kv::Bool(false)),
+        ("hangingPunctuation", Kv::Bool(false)),
+        ("leadingTrim", Kv::Enum("NONE")),
+    ];
+    let (doc, warnings) = import(&instance_paragraph_fig(valid, false), "Synthetic instance paragraph values").unwrap();
+    assert!(warnings.is_empty(), "{warnings:?}");
+    let copy = doc.nodes().find(|node| node.name == "Copy").unwrap();
+    let label = doc.node(*copy.children.first().unwrap()).unwrap();
+    let text = label.kind.text().unwrap();
+    assert_eq!(text.list_spacing, 24.0);
+    assert!(!text.hanging_list);
+    assert!(!text.hanging_punctuation);
+    assert_eq!(text.leading_trim, figcraft_doc::LeadingTrim::None);
+
+    let reset = vec![
+        ("listSpacing", Kv::Float(0.0)),
+        ("hangingList", Kv::Bool(false)),
+        ("hangingPunctuation", Kv::Bool(false)),
+        ("leadingTrim", Kv::Enum("NONE")),
+    ];
+    let (doc, warnings) = import(&instance_paragraph_fig(reset, false), "Synthetic instance paragraph resets").unwrap();
+    assert!(warnings.is_empty(), "{warnings:?}");
+    let copy = doc.nodes().find(|node| node.name == "Copy").unwrap();
+    let label = doc.node(*copy.children.first().unwrap()).unwrap();
+    let text = label.kind.text().unwrap();
+    assert_eq!(text.list_spacing, 0.0);
+    assert!(!text.hanging_list);
+    assert!(!text.hanging_punctuation);
+    assert_eq!(text.leading_trim, figcraft_doc::LeadingTrim::None);
+
+    let invalid = vec![
+        ("listSpacing", Kv::Float(37.0)),
+        ("hangingList", Kv::Bool(false)),
+        ("hangingPunctuation", Kv::Bool(false)),
+        ("leadingTrim", Kv::Uint(77)),
+    ];
+    let (doc, warnings) = import(&instance_paragraph_fig(invalid, true), "Synthetic malformed instance paragraph values").unwrap();
+    assert!(warnings.is_empty(), "{warnings:?}");
+    let copy = doc.nodes().find(|node| node.name == "Copy").unwrap();
+    let label = doc.node(*copy.children.first().unwrap()).unwrap();
+    let text = label.kind.text().unwrap();
+    assert_eq!(text.list_spacing, 18.0);
+    assert!(!text.hanging_list);
+    assert!(!text.hanging_punctuation);
+    assert_eq!(text.leading_trim, figcraft_doc::LeadingTrim::CapHeight);
+
+    let bytes = crate::save_bytes(&doc, None).unwrap();
+    let (back, warnings) = crate::load_bytes(&bytes).unwrap();
+    assert!(warnings.is_empty(), "native round trip: {warnings:?}");
+    let copy = back.nodes().find(|node| node.name == "Copy").unwrap();
+    let label = back.node(*copy.children.first().unwrap()).unwrap();
+    let text = label.kind.text().unwrap();
+    assert_eq!(text.list_spacing, 18.0);
+    assert!(!text.hanging_list);
+    assert!(!text.hanging_punctuation);
+    assert_eq!(text.leading_trim, figcraft_doc::LeadingTrim::CapHeight);
+}
diff --git a/crates/format/src/fig/text_path.rs b/crates/format/src/fig/text_path.rs
new file mode 100644
index 000000000..8a93f7e49
--- /dev/null
+++ b/crates/format/src/fig/text_path.rs
@@ -0,0 +1,315 @@
+//! Convert the simple vector network used by text-on-path layers in `.fig` files into a native text path.
+
+use figcraft_doc::{
+    TextPath,
+    geom::{
+        BezPath,
+        kurbo::{CubicBez, Line, ParamCurve, ParamCurveArclen, Point},
+    },
+};
+
+use super::network::{Network, Segment};
+
+const START_SEGMENT_STYLE: u32 = 0x01ff_ffff;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+struct Use {
+    segment: usize,
+    forward: bool,
+}
+
+/// Build a native path from a validated connected chain or cycle. The marked source segment is
+/// oriented a→b; `t` is local to that line/cubic. Coordinates are scaled into layer space.
+pub(super) fn from_network(net: &Network, sx: f64, sy: f64, t: f64, forward: bool) -> Result<TextPath, &'static str> {
+    if !t.is_finite() || !(0.0..=1.0).contains(&t) {
+        return Err("invalid start parameter");
+    }
+    if !sx.is_finite() || !sy.is_finite() || sx <= 0.0 || sy <= 0.0 {
+        return Err("invalid path scale");
+    }
+    let markers: Vec<usize> = net.segments.iter().enumerate().filter_map(|(i, s)| (s.style == START_SEGMENT_STYLE).then_some(i)).collect();
+    let [marked] = markers.as_slice() else {
+        return Err("missing or ambiguous start segment marker");
+    };
+
+    let (uses, closed) = ordered_chain(net, *marked)?;
+    let mut d = BezPath::new();
+    let mut total = 0.0;
+    let mut prefix = 0.0;
+    let mut start_segment_length = 0.0;
+    for use_ in &uses {
+        let (p0, p1, p2, p3) = cubic(net, *use_, sx, sy)?;
+        if d.elements().is_empty() {
+            d.move_to((p0.0, p0.1));
+        }
+        let line = p1 == p0 && p2 == p3;
+        let (length, partial) = if line {
+            d.line_to((p3.0, p3.1));
+            let line = Line::new(Point::new(p0.0, p0.1), Point::new(p3.0, p3.1));
+            (line.arclen(1e-9), line.arclen(1e-9) * t)
+        } else {
+            d.curve_to((p1.0, p1.1), (p2.0, p2.1), (p3.0, p3.1));
+            let curve = CubicBez::new((p0.0, p0.1), (p1.0, p1.1), (p2.0, p2.1), (p3.0, p3.1));
+            let partial = if t <= 0.0 { 0.0 } else { curve.subsegment(0.0..t).arclen(1e-9) };
+            (curve.arclen(1e-9), partial)
+        };
+        if !length.is_finite() || length <= 1e-10 {
+            return Err("zero-length path segment");
+        }
+        if use_.segment == *marked {
+            start_segment_length = partial;
+            if !start_segment_length.is_finite() {
+                return Err("invalid path length");
+            }
+            prefix = total;
+        }
+        total += length;
+    }
+    if closed {
+        d.close_path();
+    }
+    if !total.is_finite() || total <= 1e-10 {
+        return Err("zero-length path");
+    }
+    let mut start = ((prefix + start_segment_length) / total).clamp(0.0, 1.0);
+    let flip = !forward;
+    if flip {
+        start = 1.0 - start;
+    }
+    let path = TextPath { d: d.to_svg(), start, flip };
+    let lines = figcraft_doc::geom::measure::polylines(&path.path()).ok_or("cannot be measured by text renderer")?;
+    if lines.first().is_none_or(|line| line.length() <= 1e-9) {
+        return Err("cannot be measured by text renderer");
+    }
+    Ok(path)
+}
+
+/// Return every segment in chain order. Open chains are oriented so the marked segment runs a→b;
+/// cycles start at the marked segment's a vertex and traverse it first.
+fn ordered_chain(net: &Network, marked: usize) -> Result<(Vec<Use>, bool), &'static str> {
+    let marker = net.segments.get(marked).ok_or("invalid start segment index")?;
+    let mut adjacency = vec![Vec::<usize>::new(); net.vertices.len()];
+    for (i, s) in net.segments.iter().enumerate() {
+        if s.a >= adjacency.len() || s.b >= adjacency.len() {
+            return Err("invalid path vertex index");
+        }
+        if s.a == s.b {
+            return Err("path contains a segment that starts and ends at the same vertex");
+        }
+        adjacency[s.a].push(i);
+        adjacency[s.b].push(i);
+    }
+    let mut endpoints = Vec::new();
+    for edges in &adjacency {
+        if edges.len() > 2 {
+            return Err("branched path network");
+        }
+        if edges.len() == 1 {
+            endpoints.push(edges[0]);
+        }
+    }
+    if !endpoints.is_empty() && endpoints.len() != 2 {
+        return Err("disconnected or malformed path network");
+    }
+    let cycle = endpoints.is_empty();
+    let mut used = vec![false; net.segments.len()];
+    let mut out = Vec::with_capacity(net.segments.len());
+    if cycle {
+        out.push(Use { segment: marked, forward: true });
+        used[marked] = true;
+        let mut at = marker.b;
+        let mut visited = vec![false; net.vertices.len()];
+        visited[marker.a] = true;
+        visited[marker.b] = true;
+        while at != marker.a {
+            let next = adjacency[at].iter().copied().find(|i| !used[*i]).ok_or("disconnected path cycle")?;
+            used[next] = true;
+            let s = &net.segments[next];
+            let is_forward = s.a == at;
+            at = if is_forward { s.b } else { s.a };
+            if at != marker.a && std::mem::replace(&mut visited[at], true) {
+                return Err("path cycle is not simple");
+            }
+            out.push(Use { segment: next, forward: is_forward });
+            if out.len() > net.segments.len() {
+                return Err("invalid path cycle");
+            }
+        }
+    } else {
+        let endpoint = adjacency.iter().position(|e| e.len() == 1).ok_or("missing path endpoint")?;
+        let mut at = endpoint;
+        while let Some(next) = adjacency[at].iter().copied().find(|i| !used[*i]) {
+            used[next] = true;
+            let s = &net.segments[next];
+            let is_forward = s.a == at;
+            at = if is_forward { s.b } else { s.a };
+            out.push(Use { segment: next, forward: is_forward });
+        }
+        let Some(marker_use) = out.iter().find(|u| u.segment == marked) else { return Err("disconnected start segment") };
+        if !marker_use.forward {
+            out.reverse();
+            for u in &mut out {
+                u.forward = !u.forward;
+            }
+        }
+    }
+    if !used.iter().all(|x| *x) {
+        return Err("disconnected path network");
+    }
+    Ok((out, cycle))
+}
+
+type P = (f64, f64);
+
+fn cubic(net: &Network, use_: Use, sx: f64, sy: f64) -> Result<(P, P, P, P), &'static str> {
+    let s: &Segment = net.segments.get(use_.segment).ok_or("invalid path segment index")?;
+    let a = net.vertices.get(s.a).ok_or("invalid path vertex index")?;
+    let b = net.vertices.get(s.b).ok_or("invalid path vertex index")?;
+    let p0 = (a.x * sx, a.y * sy);
+    let p3 = (b.x * sx, b.y * sy);
+    let ta = (s.ta.0 * sx, s.ta.1 * sy);
+    let tb = (s.tb.0 * sx, s.tb.1 * sy);
+    if [p0.0, p0.1, p3.0, p3.1, ta.0, ta.1, tb.0, tb.1].iter().any(|x| !x.is_finite()) {
+        return Err("invalid path coordinates");
+    }
+    let (p0, p1, p2, p3) =
+        if ta == (0.0, 0.0) && tb == (0.0, 0.0) { (p0, p0, p3, p3) } else { (p0, (p0.0 + ta.0, p0.1 + ta.1), (p3.0 + tb.0, p3.1 + tb.1), p3) };
+    if use_.forward { Ok((p0, p1, p2, p3)) } else { Ok((p3, p2, p1, p0)) }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::fig::network::{Segment, Vertex};
+    use figcraft_doc::geom::kurbo::PathEl;
+
+    fn vertex(x: f64, y: f64) -> Vertex {
+        Vertex { style: 0, x, y }
+    }
+
+    fn segment(style: u32, a: usize, b: usize, ta: (f64, f64), tb: (f64, f64)) -> Segment {
+        Segment { style, a, ta, b, tb }
+    }
+
+    fn curved() -> Network {
+        Network {
+            vertices: vec![vertex(0.0, 82.5), vertex(300.0, 82.5), vertex(600.0, 82.5)],
+            segments: vec![segment(START_SEGMENT_STYLE, 0, 1, (70.0, -110.0), (-70.0, -110.0)), segment(0, 1, 2, (70.0, 110.0), (-70.0, 110.0))],
+            ..Network::default()
+        }
+    }
+
+    #[test]
+    fn local_cubic_parameter_converts_to_path_distance() {
+        let path = from_network(&curved(), 1.0, 1.0, 0.0086954795, true).unwrap();
+        assert!((path.start - 0.004744078).abs() < 0.00001);
+        // Cubic t is not its fraction of total path length.
+        assert!((path.start - 0.0086954795).abs() > 0.003);
+        let elements = path.path().elements().to_vec();
+        assert!(matches!(elements.first(), Some(PathEl::MoveTo(p)) if p.x == 0.0 && p.y == 82.5));
+        assert!(matches!(elements.get(1), Some(PathEl::CurveTo(..))));
+    }
+
+    #[test]
+    fn second_segment_marker_and_t_are_respected() {
+        let mut net = curved();
+        net.segments[0].style = 0;
+        net.segments[1].style = START_SEGMENT_STYLE;
+        let path = from_network(&net, 1.0, 1.0, 0.49800667, true).unwrap();
+        assert!((path.start - 0.7490379757).abs() < 0.00002);
+    }
+
+    #[test]
+    fn reverse_direction_inverts_normalized_start() {
+        let net = Network {
+            vertices: vec![vertex(0.0, 0.0), vertex(600.0, 0.0)],
+            segments: vec![segment(START_SEGMENT_STYLE, 0, 1, (0.0, 0.0), (0.0, 0.0))],
+            ..Network::default()
+        };
+        let path = from_network(&net, 1.0, 1.0, 0.83986014, false).unwrap();
+        assert!(path.flip);
+        assert!((path.start - 0.16013986).abs() < 1e-8);
+        assert!(matches!(path.path().elements().get(1), Some(PathEl::LineTo(p)) if p.x == 600.0 && p.y == 0.0));
+    }
+
+    #[test]
+    fn rejects_missing_duplicate_and_zero_length_segments() {
+        let mut net = curved();
+        net.segments[0].style = 0;
+        assert_eq!(from_network(&net, 1.0, 1.0, 0.5, true), Err("missing or ambiguous start segment marker"));
+        net.segments[1].style = START_SEGMENT_STYLE;
+        net.segments[0].style = START_SEGMENT_STYLE;
+        assert_eq!(from_network(&net, 1.0, 1.0, 0.5, true), Err("missing or ambiguous start segment marker"));
+        let zero = Network {
+            vertices: vec![vertex(0.0, 0.0), vertex(0.0, 0.0)],
+            segments: vec![segment(START_SEGMENT_STYLE, 0, 1, (0.0, 0.0), (0.0, 0.0))],
+            ..Network::default()
+        };
+        assert_eq!(from_network(&zero, 1.0, 1.0, 0.5, true), Err("zero-length path segment"));
+    }
+
+    #[test]
+    fn rejects_branching_and_disconnected_segments() {
+        let branch = Network {
+            vertices: vec![vertex(0.0, 0.0), vertex(1.0, 0.0), vertex(2.0, 0.0), vertex(1.0, 1.0)],
+            segments: vec![
+                segment(START_SEGMENT_STYLE, 0, 1, (0.0, 0.0), (0.0, 0.0)),
+                segment(0, 1, 2, (0.0, 0.0), (0.0, 0.0)),
+                segment(0, 1, 3, (0.0, 0.0), (0.0, 0.0)),
+            ],
+            ..Network::default()
+        };
+        assert_eq!(from_network(&branch, 1.0, 1.0, 0.5, true), Err("branched path network"));
+        let disconnected = Network {
+            vertices: vec![vertex(0.0, 0.0), vertex(1.0, 0.0), vertex(2.0, 0.0), vertex(3.0, 0.0)],
+            segments: vec![segment(START_SEGMENT_STYLE, 0, 1, (0.0, 0.0), (0.0, 0.0)), segment(0, 2, 3, (0.0, 0.0), (0.0, 0.0))],
+            ..Network::default()
+        };
+        assert_eq!(from_network(&disconnected, 1.0, 1.0, 0.5, true), Err("disconnected or malformed path network"));
+    }
+
+    #[test]
+    fn scales_geometry_and_accepts_closed_cycles() {
+        let cycle = Network {
+            vertices: vec![vertex(0.0, 0.0), vertex(100.0, 0.0), vertex(100.0, 100.0)],
+            segments: vec![
+                segment(START_SEGMENT_STYLE, 0, 1, (0.0, 0.0), (0.0, 0.0)),
+                segment(0, 1, 2, (0.0, 0.0), (0.0, 0.0)),
+                segment(0, 2, 0, (0.0, 0.0), (0.0, 0.0)),
+            ],
+            ..Network::default()
+        };
+        let path = from_network(&cycle, 2.0, 3.0, 0.5, true).unwrap();
+        let elements = path.path().elements().to_vec();
+        assert!(matches!(elements.first(), Some(PathEl::MoveTo(p)) if p.x == 0.0 && p.y == 0.0));
+        assert!(matches!(elements.get(1), Some(PathEl::LineTo(p)) if p.x == 200.0 && p.y == 0.0));
+        let total = 200.0 + 300.0 + 130_000.0_f64.sqrt();
+        assert!((path.start - 100.0 / total).abs() < 1e-8);
+        assert!(matches!(elements.last(), Some(PathEl::ClosePath)));
+    }
+
+    #[test]
+    fn rejects_paths_the_native_renderer_cannot_measure() {
+        let count = 40_000usize;
+        let many_lines = Network {
+            vertices: (0..=count).map(|i| vertex(i as f64, 0.0)).collect(),
+            segments: (0..count).map(|i| segment(if i == 0 { START_SEGMENT_STYLE } else { 0 }, i, i + 1, (0.0, 0.0), (0.0, 0.0))).collect(),
+            ..Network::default()
+        };
+        assert_eq!(from_network(&many_lines, 1.0, 1.0, 0.5, true), Err("cannot be measured by text renderer"));
+
+        let huge = Network {
+            vertices: vec![vertex(0.0, 0.0), vertex(1e9, 0.0)],
+            segments: vec![segment(START_SEGMENT_STYLE, 0, 1, (0.0, 0.0), (0.0, 0.0))],
+            ..Network::default()
+        };
+        assert_eq!(from_network(&huge, 1.0, 1.0, 0.5, true), Err("cannot be measured by text renderer"));
+
+        let tiny = Network {
+            vertices: vec![vertex(0.0, 0.0), vertex(5e-10, 0.0)],
+            segments: vec![segment(START_SEGMENT_STYLE, 0, 1, (0.0, 0.0), (0.0, 0.0))],
+            ..Network::default()
+        };
+        assert_eq!(from_network(&tiny, 1.0, 1.0, 0.5, true), Err("cannot be measured by text renderer"));
+    }
+}
diff --git a/crates/format/src/fig/text_path_tests.rs b/crates/format/src/fig/text_path_tests.rs
new file mode 100644
index 000000000..c94c6aa3d
--- /dev/null
+++ b/crates/format/src/fig/text_path_tests.rs
@@ -0,0 +1,211 @@
+//! Mapper → private REST ingress tests for source text-path fields.
+
+use super::kiwi::Kv;
+
+const SCHEMA: &str = "
+enum NodeType DOCUMENT CANVAS TEXT TEXT_PATH
+enum StyleType NONE TEXT
+enum TextDecoration NONE UNDERLINE STRIKETHROUGH
+struct GUID uint sessionID, uint localID
+struct StyleId GUID guid
+struct ParentIndex GUID guid, string position
+struct Vector float x, float y
+struct Matrix float m00, float m01, float m02, float m10, float m11, float m12
+struct FontName string family, string style
+message TextOverride uint styleID, FontName fontName, float fontSize
+message TextData string characters, uint[] characterStyleIDs, TextOverride[] styleOverrideTable
+message TextPathStart float tValue, bool forward
+message VectorData uint vectorNetworkBlob, Vector normalizedSize
+message Blob byte[] bytes
+message NodeChange GUID guid, ParentIndex parentIndex, NodeType type, string name, Vector size, Matrix transform, TextData textData, float fontSize, FontName fontName, TextPathStart textPathStart, VectorData vectorData, StyleType styleType, StyleId styleIdForText, TextDecoration textDecoration
+message Message NodeChange[] nodeChanges, Blob[] blobs
+";
+use figcraft_doc::{NodeKind, TextPath};
+
+fn o(fields: Vec<(&'static str, Kv<'static>)>) -> Kv<'static> {
+    Kv::Object(fields)
+}
+
+fn a(values: Vec<Kv<'static>>) -> Kv<'static> {
+    Kv::Array(values)
+}
+
+fn f(value: f32) -> Kv<'static> {
+    Kv::Float(value)
+}
+
+fn u(value: u64) -> Kv<'static> {
+    Kv::Uint(value)
+}
+
+fn s(value: &'static str) -> Kv<'static> {
+    Kv::Str(value.into())
+}
+
+fn point(x: f32, y: f32) -> Kv<'static> {
+    o(vec![("x", f(x)), ("y", f(y))])
+}
+
+fn guid(id: u64) -> Kv<'static> {
+    o(vec![("sessionID", u(1)), ("localID", u(id))])
+}
+
+fn node(id: u64, parent: Option<u64>, ty: &'static str, fields: Vec<(&'static str, Kv<'static>)>) -> Kv<'static> {
+    let mut node = vec![("guid", guid(id)), ("type", s(ty))];
+    if let Some(parent) = parent {
+        node.push(("parentIndex", o(vec![("guid", guid(parent)), ("position", s("!"))])));
+    }
+    node.extend(fields);
+    o(node)
+}
+
+fn blob() -> Vec<u8> {
+    let mut bytes = Vec::new();
+    let u32le = |out: &mut Vec<u8>, n: u32| out.extend_from_slice(&n.to_le_bytes());
+    let f32le = |out: &mut Vec<u8>, n: f32| out.extend_from_slice(&n.to_le_bytes());
+    u32le(&mut bytes, 2); // vertices
+    u32le(&mut bytes, 1); // segments
+    u32le(&mut bytes, 0); // regions
+    for (x, y) in [(0.0, 0.0), (100.0, 0.0)] {
+        u32le(&mut bytes, 0);
+        f32le(&mut bytes, x);
+        f32le(&mut bytes, y);
+    }
+    u32le(&mut bytes, 0x01ff_ffff); // source start-segment marker
+    u32le(&mut bytes, 0);
+    f32le(&mut bytes, 0.0);
+    f32le(&mut bytes, 0.0);
+    u32le(&mut bytes, 1);
+    f32le(&mut bytes, 0.0);
+    f32le(&mut bytes, 0.0);
+    bytes
+}
+
+fn canvas() -> Vec<u8> {
+    let schema = super::kiwi::Schema::parse(SCHEMA).unwrap();
+    let message = message(true);
+    let message = super::kiwi::encode::message(&schema, schema.find("Message").unwrap(), &message).unwrap();
+    let mut out = b"fig-kiwi\0\0\0\0".to_vec();
+    for raw in [super::kiwi::encode::schema(&schema), message] {
+        let mut encoder = flate2::write::DeflateEncoder::new(Vec::new(), flate2::Compression::default());
+        std::io::Write::write_all(&mut encoder, &raw).unwrap();
+        let compressed = encoder.finish().unwrap();
+        out.extend_from_slice(&(compressed.len() as u32).to_le_bytes());
+        out.extend_from_slice(&compressed);
+    }
+    out
+}
+
+fn message(with_path: bool) -> Kv<'static> {
+    let mut nodes = vec![node(0, None, "DOCUMENT", vec![]), node(1, Some(0), "CANVAS", vec![])];
+    let mut blobs = Vec::new();
+    if with_path {
+        blobs.push(o(vec![("bytes", Kv::Bytes(blob()))]));
+        let text = o(vec![
+            ("characters", s("alpha")),
+            ("characterStyleIDs", a(vec![u(0), u(0), u(0), u(2), u(2)])),
+            (
+                "styleOverrideTable",
+                a(vec![o(vec![("styleID", u(2)), ("fontName", o(vec![("family", s("Inter")), ("style", s("Medium"))])), ("fontSize", f(30.0))])]),
+            ),
+        ]);
+        nodes.push(node(
+            2,
+            Some(1),
+            "TEXT_PATH",
+            vec![
+                ("name", s("alpha path")),
+                ("size", point(100.0, 0.0)),
+                ("transform", o(vec![("m00", f(1.0)), ("m01", f(0.0)), ("m02", f(0.0)), ("m10", f(0.0)), ("m11", f(1.0)), ("m12", f(0.0))])),
+                ("textData", text),
+                ("fontSize", f(24.0)),
+                ("fontName", o(vec![("family", s("Inter")), ("style", s("Regular"))])),
+                ("textPathStart", o(vec![("tValue", f(0.5)), ("forward", Kv::Bool(true))])),
+                ("vectorData", o(vec![("vectorNetworkBlob", u(0)), ("normalizedSize", point(100.0, 0.0))])),
+            ],
+        ));
+    } else {
+        nodes.push(node(2, Some(1), "TEXT_PATH", vec![("name", s("broken path")), ("textData", o(vec![("characters", s("fallback"))]))]));
+    }
+    o(vec![("nodeChanges", a(nodes)), ("blobs", a(blobs))])
+}
+
+fn linked_underline_message() -> Kv<'static> {
+    let Kv::Object(mut root) = message(true) else { panic!("expected message object") };
+    let (_, Kv::Array(nodes)) = root.iter_mut().find(|(key, _)| *key == "nodeChanges").unwrap() else { panic!("expected node changes array") };
+    let text = nodes.iter_mut().find(|n| n.get("name").and_then(Kv::str) == Some("alpha path")).unwrap();
+    let Kv::Object(fields) = text else { panic!("expected text node object") };
+    fields.push(("styleIdForText", o(vec![("guid", guid(3))])));
+    nodes.push(node(
+        3,
+        Some(1),
+        "TEXT",
+        vec![
+            ("name", s("Shared style")),
+            ("styleType", s("TEXT")),
+            ("fontName", o(vec![("family", s("Inter")), ("style", s("Regular"))])),
+            ("fontSize", f(24.0)),
+            ("textDecoration", s("UNDERLINE")),
+        ],
+    ));
+    Kv::Object(root)
+}
+
+#[test]
+fn mapped_text_path_reaches_native_model_with_runs_and_no_standin_warning() {
+    let message = message(true);
+    let (json, warnings, _) = super::map::to_rest(&message, "Text path", crate::rest::MAX_NODES);
+    assert!(!warnings.iter().any(|w| w.contains("text off its path")), "{warnings:?}");
+    let (doc, warnings) = crate::rest::import_fig(&json, &|_| None).unwrap();
+    assert!(!warnings.iter().any(|w| w.contains("text off its path")), "{warnings:?}");
+    let node = doc.nodes().find(|n| n.name == "alpha path").unwrap();
+    let NodeKind::Text(text) = &node.kind else { panic!("expected text") };
+    let path = text.path.as_deref().unwrap();
+    assert_eq!(path, &TextPath { d: "M0,0 L100,0".into(), start: 0.5, flip: false });
+    assert_eq!(text.characters, "alpha");
+    assert_eq!(text.runs.len(), 1);
+    assert_eq!(text.runs[0].start, 3);
+    assert_eq!(text.runs[0].end, 5);
+}
+
+#[test]
+fn public_rest_import_ignores_private_fig_text_path_field() {
+    let message = message(true);
+    let (json, _, _) = super::map::to_rest(&message, "Text path", crate::rest::MAX_NODES);
+    // The mapper's private field is accepted only by import_fig, never by public REST import.
+    let path = json["document"]["children"][0]["children"][0]["_figTextPath"].clone();
+    assert!(path.is_object());
+    let (doc, _) = crate::rest::import(&json, &|_| None).unwrap();
+    let node = doc.nodes().find(|n| n.name == "alpha path").unwrap();
+    let NodeKind::Text(text) = &node.kind else { panic!("expected text") };
+    assert!(text.path.is_none());
+}
+
+#[test]
+fn serialized_kiwi_canvas_import_decodes_start_and_builds_native_path() {
+    let (doc, warnings) = super::import(&canvas(), "Serialized text path").unwrap();
+    let node = doc.nodes().find(|n| n.name == "alpha path").unwrap();
+    let NodeKind::Text(text) = &node.kind else { panic!("expected text") };
+    let path = text.path.as_deref().unwrap();
+    assert_eq!(path, &TextPath { d: "M0,0 L100,0".into(), start: 0.5, flip: false });
+    assert_eq!(text.characters, "alpha");
+    assert!(!warnings.iter().any(|w| w.contains("text off its path")), "{warnings:?}");
+}
+
+#[test]
+fn malformed_text_path_falls_back_with_specific_warning() {
+    let message = message(false);
+    let (json, warnings, _) = super::map::to_rest(&message, "Text path", crate::rest::MAX_NODES);
+    assert!(warnings.iter().any(|w| w.contains("text path has no start data") && w.contains("text imports off its path")), "{warnings:?}");
+    let (doc, _) = crate::rest::import_fig(&json, &|_| None).unwrap();
+    let node = doc.nodes().find(|n| n.name == "broken path").unwrap();
+    assert!(matches!(&node.kind, NodeKind::Text(text) if text.path.is_none()));
+}
+
+#[test]
+fn linked_text_style_decoration_warns_from_effective_mapped_style() {
+    let message = linked_underline_message();
+    let (json, warnings, _) = super::map::to_rest(&message, "Text path", crate::rest::MAX_NODES);
+    assert_eq!(json["document"]["children"][0]["children"][0]["style"]["textDecoration"], "UNDERLINE");
+    assert!(warnings.iter().any(|w| w == "text path underline or strikethrough decoration is not rendered"), "{warnings:?}");
+}
diff --git a/crates/format/src/fig/text_skip_ink_tests.rs b/crates/format/src/fig/text_skip_ink_tests.rs
new file mode 100644
index 000000000..485663847
--- /dev/null
+++ b/crates/format/src/fig/text_skip_ink_tests.rs
@@ -0,0 +1,272 @@
+//! `.fig` text skip-ink values map, inherit and round-trip as native decoration look state. Skip
+//! ink only shows on an underline, so the fixtures are underlined.
+
+use super::kiwi::Kv;
+use super::{export, import};
+use figcraft_doc::{Document, NodeKind, StyleKind, StyleRun, TextData, TextDecoration, TextStyle};
+use serde_json::Value;
+
+fn object(fields: Vec<(&'static str, Kv<'static>)>) -> Kv<'static> {
+    Kv::Object(fields)
+}
+
+fn guid(id: u64) -> Kv<'static> {
+    object(vec![("sessionID", Kv::Uint(8)), ("localID", Kv::Uint(id))])
+}
+
+fn node(id: u64, ty: &'static str, name: &str, parent: Option<u64>, mut fields: Vec<(&'static str, Kv<'static>)>) -> Kv<'static> {
+    let mut out = vec![("guid", guid(id)), ("type", Kv::Enum(ty)), ("name", Kv::Str(name.into()))];
+    if let Some(parent) = parent {
+        out.push(("parentIndex", object(vec![("guid", guid(parent)), ("position", Kv::Str("a".into()))])));
+    }
+    out.append(&mut fields);
+    object(out)
+}
+
+fn font() -> Kv<'static> {
+    object(vec![("family", Kv::Str("Inter".into())), ("style", Kv::Str("Regular".into())), ("postscript", Kv::Str(String::new()))])
+}
+
+fn raw(base: Option<Kv<'static>>, runs: Vec<Kv<'static>>, chars: &str, ids: Vec<u64>, shared: Option<Option<Kv<'static>>>) -> Value {
+    let mut layer = vec![
+        ("fontName", font()),
+        ("fontSize", Kv::Float(20.0)),
+        ("textDecoration", Kv::Enum("UNDERLINE")),
+        (
+            "textData",
+            object(vec![
+                ("characters", Kv::Str(chars.into())),
+                ("characterStyleIDs", Kv::Array(ids.into_iter().map(Kv::Uint).collect())),
+                ("styleOverrideTable", Kv::Array(runs)),
+            ]),
+        ),
+    ];
+    if let Some(value) = base {
+        layer.push(("textDecorationSkipInk", value));
+    }
+    let mut nodes = vec![node(1, "DOCUMENT", "Document", None, vec![]), node(2, "CANVAS", "Page", Some(1), vec![])];
+    if let Some(shared) = shared {
+        let mut fields =
+            vec![("styleType", Kv::Enum("TEXT")), ("fontName", font()), ("fontSize", Kv::Float(20.0)), ("textDecoration", Kv::Enum("UNDERLINE"))];
+        if let Some(value) = shared {
+            fields.push(("textDecorationSkipInk", value));
+        }
+        nodes.push(node(10, "TEXT", "Body", Some(2), fields));
+        layer.push(("styleIdForText", object(vec![("guid", guid(10))])));
+    }
+    nodes.push(node(11, "TEXT", "Label", Some(2), layer));
+    let message = object(vec![("nodeChanges", Kv::Array(nodes))]);
+    super::map::to_rest(&message, "Synthetic skip ink", crate::rest::MAX_NODES).0
+}
+
+fn imported(value: &Value) -> Document {
+    let (doc, warnings) = crate::rest::import_fig(value, &|_| None).unwrap();
+    assert!(warnings.is_empty(), "{warnings:?}");
+    doc
+}
+
+fn label(doc: &Document) -> &TextData {
+    doc.nodes().find(|n| n.name == "Label").unwrap().kind.text().unwrap()
+}
+
+fn skip_at(text: &TextData, index: usize) -> bool {
+    text.runs.iter().find(|r| r.start <= index && index < r.end).map_or_else(|| text.style.look().skip_ink, |r| r.style.look().skip_ink)
+}
+
+#[test]
+fn node_boolean_false_true_omitted_and_malformed_keep_typed_semantics() {
+    for (raw_value, expected) in [(Some(Kv::Bool(true)), true), (Some(Kv::Bool(false)), false), (None, false), (Some(Kv::Str("true".into())), false)]
+    {
+        let doc = imported(&raw(raw_value.clone(), vec![], "A", vec![0], None));
+        assert_eq!(label(&doc).style.look().skip_ink, expected, "source value {raw_value:?}");
+    }
+}
+
+#[test]
+fn runs_inherit_explicit_false_and_true_by_utf16_character_ids() {
+    let table = vec![
+        object(vec![("styleID", Kv::Uint(1))]),
+        object(vec![("styleID", Kv::Uint(2)), ("textDecorationSkipInk", Kv::Bool(false))]),
+        object(vec![("styleID", Kv::Uint(3)), ("textDecorationSkipInk", Kv::Bool(true))]),
+    ];
+    let doc = imported(&raw(Some(Kv::Bool(true)), table, "A😀BC", vec![0, 1, 1, 2, 3], None));
+    let text = label(&doc);
+    assert_eq!(text.characters.chars().count(), 4);
+    assert_eq!(text.characters.encode_utf16().count(), 5, "the emoji occupies two source style-ID units");
+    assert_eq!((0..text.char_count()).map(|i| skip_at(text, i)).collect::<Vec<_>>(), vec![true, true, false, true]);
+
+    let false_base = imported(&raw(
+        Some(Kv::Bool(false)),
+        vec![object(vec![("styleID", Kv::Uint(1)), ("textDecorationSkipInk", Kv::Bool(true))])],
+        "ab",
+        vec![1, 0],
+        None,
+    ));
+    assert_eq!((0..2).map(|i| skip_at(label(&false_base), i)).collect::<Vec<_>>(), vec![true, false]);
+}
+
+#[test]
+fn local_skip_ink_override_preserves_shared_style_and_omitted_value_inherits() {
+    for (local, expected) in [(Some(false), false), (None, true)] {
+        let value = raw(local.map(Kv::Bool), vec![], "ab", vec![0, 0], Some(Some(Kv::Bool(true))));
+        let doc = imported(&value);
+        let node = doc.nodes().find(|n| n.name == "Label").unwrap();
+        assert_eq!(node.kind.text().unwrap().style.look().skip_ink, expected);
+        let linked = doc.style(node.styles.text.as_deref().unwrap()).unwrap();
+        let StyleKind::Text { style } = &linked.kind else { panic!("linked definition must remain text") };
+        assert!(style.look().skip_ink, "local value must not alter definition");
+    }
+}
+
+#[test]
+fn instance_path_override_preserves_explicit_false_over_true_main() {
+    let main_text = node(
+        21,
+        "TEXT",
+        "Label",
+        Some(20),
+        vec![
+            ("fontName", font()),
+            ("fontSize", Kv::Float(20.0)),
+            ("textDecoration", Kv::Enum("UNDERLINE")),
+            ("textDecorationSkipInk", Kv::Bool(true)),
+            ("textData", object(vec![("characters", Kv::Str("A".into()))])),
+        ],
+    );
+    let instance = node(
+        30,
+        "INSTANCE",
+        "Copy",
+        Some(2),
+        vec![(
+            "symbolData",
+            object(vec![
+                ("symbolID", guid(20)),
+                (
+                    "symbolOverrides",
+                    Kv::Array(vec![object(vec![
+                        ("guidPath", object(vec![("guids", Kv::Array(vec![guid(21)]))])),
+                        ("textDecorationSkipInk", Kv::Bool(false)),
+                    ])]),
+                ),
+            ]),
+        )],
+    );
+    let message = object(vec![(
+        "nodeChanges",
+        Kv::Array(vec![
+            node(1, "DOCUMENT", "Document", None, vec![]),
+            node(2, "CANVAS", "Page", Some(1), vec![]),
+            node(20, "SYMBOL", "Main", Some(2), vec![]),
+            main_text,
+            instance,
+        ]),
+    )]);
+    let value = super::map::to_rest(&message, "Instance skip ink", crate::rest::MAX_NODES).0;
+    let copy = value["document"]["children"][0]["children"].as_array().unwrap().iter().find(|n| n["name"] == "Copy").unwrap();
+    let label = copy["children"].as_array().unwrap().iter().find(|n| n["name"] == "Label").unwrap();
+    assert_eq!(label["style"]["textDecorationSkipInk"], false);
+    let doc = imported(&value);
+    let copy = doc.nodes().find(|n| n.name == "Copy").unwrap();
+    let instance_label = doc.node(*copy.children.first().unwrap()).unwrap();
+    assert!(!instance_label.kind.text().unwrap().style.look().skip_ink);
+}
+
+#[test]
+fn export_writes_one_actual_node_value_and_complete_run_values_without_skip_only_warning() {
+    let mut doc = Document::new("Skip ink export");
+    let mut text = TextData::new("abcd");
+    text.style.decoration = TextDecoration::Underline;
+    text.style.set_look(|look| look.skip_ink = false);
+    let mut skipped = text.style.clone();
+    skipped.set_look(|look| look.skip_ink = true);
+    text.runs = vec![StyleRun { start: 1, end: 3, style: skipped }];
+    doc.create(doc.first_page().unwrap(), NodeKind::Text(text), "Label", 0.0, 0.0, 100.0, 30.0).unwrap();
+
+    let (bytes, warnings) = export(&doc, None).unwrap();
+    assert!(warnings.is_empty(), "skip-ink is supported: {warnings:?}");
+    let archive = super::Archive::open(&bytes).unwrap();
+    let (schema, body) = super::decode_canvas(&archive.canvas).unwrap();
+    let message = schema.decode_message(schema.find("Message").unwrap(), &body).unwrap();
+    let value = super::debug_json(&message);
+    let layer = value["nodeChanges"].as_array().unwrap().iter().find(|n| n["name"] == "Label").unwrap();
+    assert_eq!(layer["textDecorationSkipInk"], false);
+    assert_eq!(layer.as_object().unwrap().keys().filter(|k| *k == "textDecorationSkipInk").count(), 1);
+    let rows = layer["textData"]["styleOverrideTable"].as_array().unwrap();
+    assert_eq!(rows.len(), 1);
+    assert_eq!(rows[0]["textDecorationSkipInk"], true);
+    let (back, warnings) = import(&bytes, "Skip ink export").unwrap();
+    assert!(warnings.is_empty(), "{warnings:?}");
+    assert_eq!((0..4).map(|i| skip_at(label(&back), i)).collect::<Vec<_>>(), vec![false, true, true, false]);
+
+    let mut custom = TextData::new("x");
+    custom.style.set_look(|look| look.skip_ink = true);
+    custom.style.set_look(|look| look.thickness = figcraft_doc::DecorationLength::Pixels(2.0));
+    let mut custom_doc = Document::new("Unsupported decoration");
+    custom_doc.create(custom_doc.first_page().unwrap(), NodeKind::Text(custom), "Custom", 0.0, 0.0, 100.0, 30.0).unwrap();
+    let (_, warnings) = export(&custom_doc, None).unwrap();
+    assert!(warnings.iter().any(|w| w.contains("text decoration looks")), "custom look warning missing: {warnings:?}");
+
+    let mut variable = TextData::new("x");
+    variable.style.variations.insert("wght".into(), 400.0);
+    let mut variable_doc = Document::new("Variable font warning");
+    variable_doc.create(variable_doc.first_page().unwrap(), NodeKind::Text(variable), "Variable", 0.0, 0.0, 100.0, 30.0).unwrap();
+    let (_, warnings) = export(&variable_doc, None).unwrap();
+    assert!(warnings.iter().any(|w| w.contains("variable font settings")), "variation warning missing: {warnings:?}");
+
+    let mut shared = TextStyle { decoration: TextDecoration::Underline, ..TextStyle::default() };
+    shared.set_look(|look| look.skip_ink = true);
+    let mut local = TextStyle { decoration: TextDecoration::Underline, ..TextStyle::default() };
+    local.set_look(|look| look.skip_ink = false);
+    let mut linked_doc = Document::new("Shared skip ink");
+    linked_doc.styles.push(figcraft_doc::Style {
+        id: "body".into(),
+        name: "Body".into(),
+        description: String::new(),
+        kind: StyleKind::Text { style: shared },
+        bound: Default::default(),
+    });
+    let id = linked_doc
+        .create(linked_doc.first_page().unwrap(), NodeKind::Text(TextData { style: local, ..TextData::new("x") }), "Label", 0.0, 0.0, 100.0, 30.0)
+        .unwrap();
+    linked_doc.node_mut(id).unwrap().styles.text = Some("body".into());
+    let (bytes, warnings) = export(&linked_doc, None).unwrap();
+    assert!(warnings.is_empty(), "skip-ink-only shared styles are supported: {warnings:?}");
+    let (back, warnings) = import(&bytes, "Shared skip ink").unwrap();
+    assert!(warnings.is_empty(), "{warnings:?}");
+    let node = back.nodes().find(|n| n.name == "Label").unwrap();
+    assert!(!node.kind.text().unwrap().style.look().skip_ink);
+    let linked = back.style(node.styles.text.as_deref().unwrap()).unwrap();
+    let StyleKind::Text { style } = &linked.kind else { panic!("shared style link must remain text") };
+    assert!(style.look().skip_ink, "local false must not alter the shared definition");
+}
+
+#[test]
+fn skip_ink_without_an_underline_stays_out_of_the_look_and_exports_the_default() {
+    // Plain text with the files' default value imports with the default look...
+    let mut value = raw(Some(Kv::Bool(true)), vec![], "ab", vec![0, 0], None);
+    value["document"]["children"][0]["children"][0]["style"].as_object_mut().unwrap().remove("textDecoration");
+    let doc = imported(&value);
+    assert_eq!(label(&doc).style.decoration, TextDecoration::None);
+    assert!(label(&doc).style.decoration_look.is_none());
+
+    // ...an underlined run of it keeps the layer's value...
+    let mut value =
+        raw(Some(Kv::Bool(true)), vec![object(vec![("styleID", Kv::Uint(1)), ("textDecoration", Kv::Enum("UNDERLINE"))])], "ab", vec![1, 0], None);
+    value["document"]["children"][0]["children"][0]["style"].as_object_mut().unwrap().remove("textDecoration");
+    let doc = imported(&value);
+    assert_eq!((0..2).map(|i| skip_at(label(&doc), i)).collect::<Vec<_>>(), vec![true, false]);
+
+    // ...and default native text writes the default, which reads back as the default look.
+    let mut doc = Document::new("Plain");
+    doc.create(doc.first_page().unwrap(), NodeKind::Text(TextData::new("x")), "Label", 0.0, 0.0, 100.0, 30.0).unwrap();
+    let (bytes, _) = export(&doc, None).unwrap();
+    let archive = super::Archive::open(&bytes).unwrap();
+    let (schema, body) = super::decode_canvas(&archive.canvas).unwrap();
+    let message = schema.decode_message(schema.find("Message").unwrap(), &body).unwrap();
+    let value = super::debug_json(&message);
+    let layer = value["nodeChanges"].as_array().unwrap().iter().find(|n| n["name"] == "Label").unwrap();
+    assert_eq!(layer["textDecorationSkipInk"], true);
+    let (back, _) = import(&bytes, "Plain").unwrap();
+    assert!(label(&back).style.decoration_look.is_none());
+}
diff --git a/crates/format/src/fig/text_style_tests.rs b/crates/format/src/fig/text_style_tests.rs
new file mode 100644
index 000000000..b2c4ed596
--- /dev/null
+++ b/crates/format/src/fig/text_style_tests.rs
@@ -0,0 +1,292 @@
+//! Text layers and their shared text styles on import: which of the style, the layer's own
+//! values and an instance's overrides win, on messages built in code.
+
+use figcraft_doc::{Document, LetterSpacing, StyleKind, TextCase, TextDecoration};
+use serde_json::Value;
+
+use super::kiwi::Kv;
+
+type Fields = Vec<(&'static str, Kv<'static>)>;
+
+const NO_STYLE: u64 = 4_294_967_295;
+
+fn object(fields: Fields) -> Kv<'static> {
+    Kv::Object(fields)
+}
+
+fn guid(id: u64) -> Kv<'static> {
+    object(vec![("sessionID", Kv::Uint(9)), ("localID", Kv::Uint(id))])
+}
+
+fn link(id: u64) -> Kv<'static> {
+    object(vec![("guid", guid(id))])
+}
+
+fn node(id: u64, ty: &'static str, name: &str, parent: Option<u64>, mut more: Fields) -> Kv<'static> {
+    let mut fields = vec![("guid", guid(id)), ("type", Kv::Enum(ty)), ("name", Kv::Str(name.into()))];
+    if let Some(parent) = parent {
+        fields.push(("parentIndex", object(vec![("guid", guid(parent)), ("position", Kv::Str("a".into()))])));
+    }
+    fields.append(&mut more);
+    object(fields)
+}
+
+fn font(family: &str) -> Kv<'static> {
+    object(vec![("family", Kv::Str(family.into())), ("style", Kv::Str("Regular".into())), ("postscript", Kv::Str(String::new()))])
+}
+
+fn chars(text: &str) -> Kv<'static> {
+    object(vec![("characters", Kv::Str(text.into()))])
+}
+
+/// The REST JSON of a page holding `nodes`.
+fn rest(nodes: Vec<Kv<'static>>) -> Value {
+    let base = vec![node(1, "DOCUMENT", "Document", None, vec![]), node(2, "CANVAS", "Page", Some(1), vec![])];
+    let message = object(vec![("nodeChanges", Kv::Array(base.into_iter().chain(nodes).collect()))]);
+    super::map::to_rest(&message, "Synthetic text", crate::rest::MAX_NODES).0
+}
+
+fn import(value: &Value) -> Document {
+    let (doc, warnings) = crate::rest::import_fig(value, &|_| None).unwrap();
+    assert!(warnings.is_empty(), "{warnings:?}");
+    doc
+}
+
+/// Depth-first search for a REST node by name below `v`.
+fn find<'v>(v: &'v Value, name: &str) -> Option<&'v Value> {
+    if v["name"] == name {
+        return Some(v);
+    }
+    v["children"].as_array()?.iter().find_map(|c| find(c, name))
+}
+
+/// A shared text style (Inter, 20 px, with `shared` fields) and a layer linking it whose own
+/// copy of the typography is stale (40 px, another family) and which sets `local`.
+fn linked(shared: Fields, local: Fields) -> Document {
+    let mut definition = vec![("styleType", Kv::Enum("TEXT")), ("fontName", font("Inter")), ("fontSize", Kv::Float(20.0))];
+    definition.extend(shared);
+    let mut layer = vec![("fontName", font("Stale copy")), ("fontSize", Kv::Float(40.0)), ("styleIdForText", link(10)), ("textData", chars("a\nb"))];
+    layer.extend(local);
+    import(&rest(vec![node(10, "TEXT", "Shared", Some(2), definition), node(11, "TEXT", "Label", Some(2), layer)]))
+}
+
+struct Seen {
+    case: TextCase,
+    decoration: TextDecoration,
+    spacing: f64,
+    indent: f64,
+    shared_case: TextCase,
+}
+
+fn seen(doc: &Document) -> Seen {
+    let label = doc.nodes().find(|n| n.name == "Label").unwrap();
+    let text = label.kind.text().unwrap();
+    // The shared style's typography beats the layer's stale copy, whatever the layer sets locally.
+    assert_eq!((text.style.font_family.as_str(), text.style.font_size), ("Inter", 20.0));
+    let linked = doc.style(label.styles.text.as_deref().unwrap()).unwrap();
+    assert_eq!(linked.name, "Shared");
+    let StyleKind::Text { style } = &linked.kind else { panic!("the linked definition must stay a text style") };
+    Seen {
+        case: text.style.case,
+        decoration: text.style.decoration,
+        spacing: text.paragraph_spacing,
+        indent: text.paragraph_indent,
+        shared_case: style.case,
+    }
+}
+
+#[test]
+fn local_case_decoration_and_paragraph_values_beat_the_shared_style() {
+    let shared = vec![
+        ("textCase", Kv::Enum("UPPER")),
+        ("textDecoration", Kv::Enum("UNDERLINE")),
+        ("paragraphSpacing", Kv::Float(24.0)),
+        ("paragraphIndent", Kv::Float(12.0)),
+    ];
+    // Nothing set on the layer: the style's values stay.
+    let s = seen(&linked(shared.clone(), vec![]));
+    assert_eq!((s.case, s.decoration, s.spacing, s.indent), (TextCase::Upper, TextDecoration::Underline, 24.0, 12.0));
+    // Explicit values on the layer win, and "original", "none" and zero clear the style's.
+    let cleared = vec![
+        ("textCase", Kv::Enum("ORIGINAL")),
+        ("textDecoration", Kv::Enum("NONE")),
+        ("paragraphSpacing", Kv::Float(0.0)),
+        ("paragraphIndent", Kv::Float(0.0)),
+    ];
+    let s = seen(&linked(shared.clone(), cleared));
+    assert_eq!((s.case, s.decoration, s.spacing, s.indent), (TextCase::Original, TextDecoration::None, 0.0, 0.0));
+    assert_eq!(s.shared_case, TextCase::Upper, "a local value must not change the definition");
+    let local = vec![
+        ("textCase", Kv::Enum("SMALL_CAPS_FORCED")),
+        ("textDecoration", Kv::Enum("STRIKETHROUGH")),
+        ("paragraphSpacing", Kv::Float(6.0)),
+        ("paragraphIndent", Kv::Float(3.0)),
+    ];
+    let s = seen(&linked(vec![], local));
+    assert_eq!((s.case, s.decoration, s.spacing, s.indent), (TextCase::SmallCaps, TextDecoration::Strikethrough, 6.0, 3.0));
+    // A value the importer does not know leaves the style's in place.
+    let s = seen(&linked(shared, vec![("textCase", Kv::Enum("UNSUPPORTED_CASE")), ("textDecoration", Kv::Enum("WAVY"))]));
+    assert_eq!((s.case, s.decoration), (TextCase::Upper, TextDecoration::Underline));
+}
+
+#[test]
+fn an_instance_override_beats_the_shared_style_and_a_detach_unlinks_it() {
+    let value = rest(vec![
+        node(10, "TEXT", "Body", Some(2), vec![("styleType", Kv::Enum("TEXT")), ("fontName", font("Inter")), ("fontSize", Kv::Float(14.0))]),
+        node(20, "SYMBOL", "Main", Some(2), vec![]),
+        node(
+            21,
+            "TEXT",
+            "Label",
+            Some(20),
+            vec![("fontName", font("Inter")), ("fontSize", Kv::Float(14.0)), ("styleIdForText", link(10)), ("textData", chars("Hi"))],
+        ),
+        node(
+            30,
+            "INSTANCE",
+            "Inst",
+            Some(2),
+            vec![(
+                "symbolData",
+                object(vec![
+                    ("symbolID", guid(20)),
+                    (
+                        "symbolOverrides",
+                        Kv::Array(vec![object(vec![
+                            ("guidPath", object(vec![("guids", Kv::Array(vec![guid(21)]))])),
+                            ("fontSize", Kv::Float(30.0)),
+                        ])]),
+                    ),
+                ]),
+            )],
+        ),
+        // An explicit "no style" detaches, even when the older field still names a style.
+        node(
+            40,
+            "TEXT",
+            "Detached",
+            Some(2),
+            vec![
+                ("fontName", font("Roboto")),
+                ("fontSize", Kv::Float(40.0)),
+                ("styleIdForText", object(vec![("guid", object(vec![("sessionID", Kv::Uint(NO_STYLE)), ("localID", Kv::Uint(NO_STYLE))]))])),
+                ("inheritTextStyleID", guid(10)),
+                ("textData", chars("ab")),
+            ],
+        ),
+    ]);
+    let label = find(find(&value["document"], "Inst").unwrap(), "Label").unwrap();
+    assert_eq!(label["style"]["fontSize"].as_f64(), Some(30.0), "the override beats the style");
+    let detached = find(&value["document"], "Detached").unwrap();
+    assert!(detached["styles"].get("text").is_none(), "{}", detached["styles"]);
+    assert_eq!(detached["style"]["fontSize"].as_f64(), Some(40.0));
+}
+
+#[test]
+fn a_text_property_value_drops_the_run_styles_made_for_the_main_text() {
+    let ids = [0u64, 0, 0, 1, 1, 1].map(Kv::Uint).to_vec();
+    let value = rest(vec![
+        node(
+            20,
+            "SYMBOL",
+            "Main",
+            Some(2),
+            vec![(
+                "componentPropDefs",
+                Kv::Array(vec![object(vec![
+                    ("id", guid(70)),
+                    ("name", Kv::Str("Text".into())),
+                    ("type", Kv::Enum("TEXT")),
+                    ("initialValue", object(vec![("textValue", chars("Hi you"))])),
+                ])]),
+            )],
+        ),
+        node(
+            21,
+            "TEXT",
+            "Label",
+            Some(20),
+            vec![
+                ("fontName", font("Inter")),
+                ("fontSize", Kv::Float(12.0)),
+                (
+                    "textData",
+                    object(vec![
+                        ("characters", Kv::Str("Hi you".into())),
+                        ("characterStyleIDs", Kv::Array(ids)),
+                        ("styleOverrideTable", Kv::Array(vec![object(vec![("styleID", Kv::Uint(1)), ("fontSize", Kv::Float(30.0))])])),
+                    ]),
+                ),
+                (
+                    "parameterConsumptionMap",
+                    object(vec![(
+                        "entries",
+                        Kv::Array(vec![object(vec![
+                            ("variableField", Kv::Enum("TEXT_DATA")),
+                            ("variableData", object(vec![("value", object(vec![("propRefValue", object(vec![("defId", guid(70))]))]))])),
+                        ])]),
+                    )]),
+                ),
+            ],
+        ),
+        node(
+            30,
+            "INSTANCE",
+            "Inst",
+            Some(2),
+            vec![
+                ("symbolData", object(vec![("symbolID", guid(20))])),
+                (
+                    "componentPropAssignments",
+                    Kv::Array(vec![object(vec![("defID", guid(70)), ("value", object(vec![("textValue", chars("Goodbye"))]))])]),
+                ),
+            ],
+        ),
+    ]);
+    let main = find(find(&value["document"], "Main").unwrap(), "Label").unwrap();
+    let kept: Vec<u64> = main["characterStyleOverrides"].as_array().map(|a| a.iter().filter_map(Value::as_u64).collect()).unwrap_or_default();
+    assert_eq!(kept, [0, 0, 0, 1, 1, 1], "the main keeps its run styles");
+    let inst = find(&value["document"], "Inst").unwrap();
+    let layer = find(inst, "Label").unwrap();
+    assert_eq!(layer["characters"], "Goodbye");
+    assert!(layer.get("characterStyleOverrides").is_none(), "positions of the main's runs do not fit the property text");
+}
+
+#[test]
+fn percent_letter_spacing_stays_a_percentage() {
+    let spacing = |units: &'static str, value: f32| object(vec![("value", Kv::Float(value)), ("units", Kv::Enum(units))]);
+    let layer = |id, name: &str, letter: Kv<'static>| {
+        node(
+            id,
+            "TEXT",
+            name,
+            Some(2),
+            vec![("fontName", font("Inter")), ("fontSize", Kv::Float(20.0)), ("letterSpacing", letter), ("textData", chars("Hello"))],
+        )
+    };
+    let doc = import(&rest(vec![layer(10, "Percent", spacing("PERCENT", 5.0)), layer(11, "Pixels", spacing("PIXELS", 2.0))]));
+    let spacing = |name: &str| doc.nodes().find(|n| n.name == name).unwrap().kind.text().unwrap().style.letter_spacing;
+    assert_eq!(spacing("Percent"), LetterSpacing::Percent(5.0));
+    assert_eq!(spacing("Pixels"), LetterSpacing::Pixels(2.0));
+}
+
+#[test]
+fn the_private_percent_is_read_for_fig_imports_only() {
+    let value = rest(vec![node(
+        10,
+        "TEXT",
+        "Label",
+        Some(2),
+        vec![
+            ("fontName", font("Inter")),
+            ("fontSize", Kv::Float(20.0)),
+            ("letterSpacing", object(vec![("value", Kv::Float(5.0)), ("units", Kv::Enum("PERCENT"))])),
+            ("textData", chars("Hello")),
+        ],
+    )]);
+    let spacing = |doc: &Document| doc.nodes().find(|n| n.name == "Label").unwrap().kind.text().unwrap().style.letter_spacing;
+    assert_eq!(spacing(&import(&value)), LetterSpacing::Percent(5.0));
+    // The same JSON through the public REST import is pixels.
+    let (public, _) = crate::rest::import(&value, &|_| None).unwrap();
+    assert_eq!(spacing(&public), LetterSpacing::Pixels(1.0));
+}
diff --git a/crates/format/src/large_tests.rs b/crates/format/src/large_tests.rs
index 3ff352aca..889074f18 100644
--- a/crates/format/src/large_tests.rs
+++ b/crates/format/src/large_tests.rs
@@ -202,3 +202,20 @@ fn the_header_is_read_on_its_own() {
     let (_, _, index) = parse_json(&d.replacen("\"imageIndex\":[]", "\"imageIndex\":[{\"hash\":\"ab\"},{\"nope\":1}]", 1)).unwrap();
     assert_eq!(index, Some(["ab".to_string()].into_iter().collect()));
 }
+
+#[test]
+fn document_json_may_unpack_in_proportion_to_its_packed_size() {
+    const MB: u64 = 1024 * 1024;
+    // A small archive keeps the member cap: it can't unpack into gigabytes.
+    assert_eq!(document_limit(0, 0), MAX_MEMBER);
+    assert_eq!(document_limit(MB, 2 * MB), MAX_MEMBER);
+    // A real 900 000-layer document saved by us packs 1 477 139 810 bytes into 244 362 923, and
+    // didn't open again under the 512 MB cap.
+    if cfg!(not(target_pointer_width = "32")) {
+        assert!(document_limit(244_362_923, 260 * MB) > 1_477_139_810);
+    }
+    // The packed size an archive claims counts only up to the archive's own size.
+    assert_eq!(document_limit(u64::MAX, MB), MAX_MEMBER);
+    // Never more than the ceiling.
+    assert_eq!(document_limit(u64::MAX, u64::MAX), MAX_DOCUMENT);
+}
diff --git a/crates/format/src/lib.rs b/crates/format/src/lib.rs
index f88416e27..9f7e51bc4 100644
--- a/crates/format/src/lib.rs
+++ b/crates/format/src/lib.rs
@@ -39,6 +39,15 @@ pub const FORMAT: &str = "figcraft";
 pub const VERSION: u32 = 1;
 /// Largest archive member we read (guards against zip bombs).
 const MAX_MEMBER: u64 = 512 * 1024 * 1024;
+/// `document.json` may unpack to [`DOCUMENT_RATIO`] times what it takes in the archive, within
+/// [`MAX_MEMBER`] and [`MAX_DOCUMENT`]: a large document saved by us (a 900 000-layer file packs
+/// 1.48 GB into 244 MB) opens again, while a small archive still can't unpack into gigabytes.
+/// 32-bit targets (wasm32) have a 4 GB address space in all, so their ceiling is lower.
+const DOCUMENT_RATIO: u64 = 16;
+#[cfg(not(target_pointer_width = "32"))]
+const MAX_DOCUMENT: u64 = 4 * 1024 * 1024 * 1024;
+#[cfg(target_pointer_width = "32")]
+const MAX_DOCUMENT: u64 = 1024 * 1024 * 1024;
 /// Most versions a file keeps: saving more is refused, extra entries in a file are skipped.
 pub const MAX_VERSIONS: usize = 100;
 /// Longest version name and description kept (chars).
@@ -455,6 +464,11 @@ pub(crate) fn read_member<R: Read + Seek>(z: &mut zip::ZipArchive<R>, name: &str
     Ok(data)
 }
 
+/// Largest `document.json` read from an archive of `len` bytes in which it takes `packed`.
+pub(crate) fn document_limit(packed: u64, len: u64) -> u64 {
+    packed.min(len).saturating_mul(DOCUMENT_RATIO).clamp(MAX_MEMBER, MAX_DOCUMENT)
+}
+
 /// How many images, and how many bytes of them together, one file may give.
 #[derive(Clone, Copy, Debug)]
 pub(crate) struct ImageBudget {
@@ -476,7 +490,9 @@ pub(crate) fn load_within(bytes: &[u8], budget: ImageBudget) -> Result<Loaded, F
         return Ok(Loaded { issues, ..Loaded::from(doc) });
     }
     let mut z = zip::ZipArchive::new(std::io::Cursor::new(bytes)).map_err(|e| FormatError::Corrupt(e.to_string()))?;
-    let text = String::from_utf8(read_member(&mut z, "document.json", MAX_MEMBER)?).map_err(|e| FormatError::Corrupt(e.to_string()))?;
+    let packed = z.by_name("document.json").map(|f| f.compressed_size()).unwrap_or(0);
+    let limit = document_limit(packed, bytes.len() as u64);
+    let text = String::from_utf8(read_member(&mut z, "document.json", limit)?).map_err(|e| FormatError::Corrupt(e.to_string()))?;
     let (mut doc, mut issues, own_images) = parse_json(&text)?;
     let (images, unread) = read_images(&mut z, own_images.as_ref(), budget);
     report_lost_images(&mut issues, &unread, own_images.as_ref(), &images);
diff --git a/crates/format/src/rest/fig_sources.rs b/crates/format/src/rest/fig_sources.rs
new file mode 100644
index 000000000..2793f9325
--- /dev/null
+++ b/crates/format/src/rest/fig_sources.rs
@@ -0,0 +1,321 @@
+//! Explicit .fig GUID provenance projected through instance expansion contexts.
+//! All strings borrow the bounded JSON; no names, node-kind similarity or child order match links.
+
+use std::collections::{BTreeMap, BTreeSet};
+
+use figcraft_doc::{Document, NodeId, NodeKind};
+use serde_json::Value;
+
+use super::{FIG_SOURCE_FIELD, MAX_DEPTH};
+
+// A GUID has at most two 20-digit u64 parts and a colon; instance paths contain at most
+// MAX_DEPTH + 2 GUIDs. Check before constructing any projected path string.
+const MAX_SOURCE_ID_BYTES: usize = 44 * (MAX_DEPTH + 2);
+
+#[derive(Clone, Copy)]
+struct Origin<'a> {
+    rest: &'a str,
+    guid: &'a str,
+    expanded: bool,
+    slot_content: bool,
+    wire_frame: bool,
+    wire_instance: bool,
+    component: Option<&'a str>,
+}
+
+pub(super) struct Sources<'a> {
+    /// Most layers recorded.
+    max_nodes: usize,
+    nodes: BTreeMap<NodeId, Origin<'a>>,
+    duplicate_ids: BTreeSet<&'a str>,
+    rejected: usize,
+}
+
+fn guid(s: &str) -> bool {
+    let Some((session, local)) = s.split_once(':') else { return false };
+    s.len() <= 41
+        && [session, local].into_iter().all(|part| !part.is_empty() && part.bytes().all(|c| c.is_ascii_digit()) && part.parse::<u64>().is_ok())
+}
+
+fn expanded_id(instance: &str, origin: &str) -> Option<String> {
+    let bytes = instance.len().checked_add(origin.len())?.checked_add(2)?;
+    if bytes > MAX_SOURCE_ID_BYTES {
+        return None;
+    }
+    Some(if instance.starts_with('I') { format!("{instance};{origin}") } else { format!("I{instance};{origin}") })
+}
+
+impl<'a> Sources<'a> {
+    pub(super) fn new(max_nodes: usize) -> Self {
+        Self { max_nodes, nodes: BTreeMap::new(), duplicate_ids: BTreeSet::new(), rejected: 0 }
+    }
+
+    pub(super) fn record(&mut self, id: NodeId, node: &'a Value, primary: bool) {
+        let Some(rest) = node.get("id").and_then(Value::as_str) else { return };
+        if !primary {
+            self.duplicate_ids.insert(rest);
+            return;
+        }
+        let Some(meta) = node.get(FIG_SOURCE_FIELD) else { return };
+        let parsed = meta.get("origin").and_then(Value::as_str).zip(meta.get("expanded").and_then(Value::as_bool));
+        let Some((origin, expanded)) = parsed else {
+            self.rejected += 1;
+            return;
+        };
+        if self.nodes.len() >= self.max_nodes
+            || rest.len() > MAX_SOURCE_ID_BYTES
+            || !guid(origin)
+            || (!expanded && rest != origin)
+            || (expanded && !rest.starts_with('I'))
+        {
+            self.rejected += 1;
+            return;
+        }
+        let wire_frame = meta.get("wireFrame").and_then(Value::as_bool).unwrap_or(false);
+        let wire_instance = !wire_frame
+            && meta.get("wireInstance").and_then(Value::as_bool) == Some(true)
+            && node.get("type").and_then(Value::as_str) == Some("INSTANCE");
+        let component = wire_instance.then(|| node.get("componentId").and_then(Value::as_str).filter(|id| guid(id))).flatten();
+        let slot_content = meta.get("slotContent").and_then(Value::as_bool).unwrap_or(false);
+        self.nodes.insert(id, Origin { rest, guid: origin, expanded, slot_content, wire_frame, wire_instance, component });
+    }
+
+    fn origin(&self, id: NodeId) -> Option<Origin<'a>> {
+        let meta = *self.nodes.get(&id)?;
+        (!self.duplicate_ids.contains(meta.rest)).then_some(meta)
+    }
+
+    fn raw_in_main(&self, origin: &str, main: NodeId, doc: &Document, ids: &BTreeMap<String, NodeId>) -> Option<NodeId> {
+        let target = *ids.get(origin)?;
+        let meta = self.origin(target)?;
+        (!meta.expanded && meta.rest == origin && target != main && doc.is_ancestor(main, target)).then_some(target)
+    }
+
+    fn root_source(&self, id: NodeId, doc: &Document) -> Option<NodeId> {
+        let NodeKind::Instance { component, .. } = &doc.node(id)?.kind else { return None };
+        let main_meta = self.origin(*component)?;
+        (!main_meta.expanded
+            && matches!(doc.node(*component)?.kind, NodeKind::Component { .. })
+            && *component != id
+            && !doc.is_ancestor(id, *component)
+            && !doc.is_ancestor(*component, id))
+        .then_some(*component)
+    }
+
+    fn missing_frame(&self, id: NodeId, doc: &Document, ids: &BTreeMap<String, NodeId>) -> bool {
+        self.origin(id).is_some_and(|meta| {
+            meta.wire_instance
+                && matches!(doc.node(id).map(|n| &n.kind), Some(NodeKind::Frame))
+                // An existing target of the wrong kind or a cycle-blocked main is not missing.
+                && meta.component.is_some_and(|main| !ids.contains_key(main))
+        })
+    }
+
+    fn owner(&self, id: NodeId, doc: &Document, ids: &BTreeMap<String, NodeId>) -> Option<NodeId> {
+        let mut current = doc.node(id)?.parent;
+        let mut seen = BTreeSet::from([id]);
+        for _ in 0..512 {
+            let parent = current?;
+            if !seen.insert(parent) {
+                return None;
+            }
+            let node = doc.node(parent)?;
+            if matches!(node.kind, NodeKind::Instance { .. }) || self.missing_frame(parent, doc, ids) {
+                return Some(parent);
+            }
+            current = node.parent;
+        }
+        None
+    }
+
+    fn namespace(&self, id: NodeId, owner: NodeId, doc: &Document) -> bool {
+        let Some(owner_meta) = self.origin(owner) else { return false };
+        let mut current = id;
+        let mut seen = BTreeSet::new();
+        for _ in 0..512 {
+            if current == owner {
+                return true;
+            }
+            if !seen.insert(current) {
+                return false;
+            }
+            let Some(meta) = self.origin(current) else { return false };
+            if !meta.expanded || expanded_id(owner_meta.rest, meta.guid).as_deref() != Some(meta.rest) {
+                return false;
+            }
+            let Some(parent) = doc.node(current).and_then(|n| n.parent) else { return false };
+            current = parent;
+        }
+        false
+    }
+
+    // A missing-main instance is materialized as a frame. Outside real instances its children
+    // are owned layers; known instances there become ordinary roots with their own actual main.
+    fn owned_layer(&self, id: NodeId, doc: &Document, ids: &BTreeMap<String, NodeId>) -> bool {
+        if doc.ancestors(id).into_iter().any(|p| doc.node(p).is_some_and(|n| matches!(n.kind, NodeKind::Instance { .. }))) {
+            return false;
+        }
+        let mut current = id;
+        for _ in 0..=MAX_DEPTH {
+            let Some(owner) = self.owner(current, doc, ids) else { return false };
+            if !self.missing_frame(owner, doc, ids) || !self.namespace(current, owner, doc) {
+                return false;
+            }
+            let Some(meta) = self.origin(owner) else { return false };
+            if !meta.expanded {
+                return true;
+            }
+            current = owner;
+        }
+        false
+    }
+
+    fn frame_target(&self, id: NodeId, owner: NodeId, source_owner: NodeId, doc: &Document, ids: &BTreeMap<String, NodeId>) -> Option<NodeId> {
+        let meta = self.origin(id)?;
+        let owner_meta = self.origin(owner)?;
+        let source_meta = self.origin(source_owner)?;
+        if !self.missing_frame(source_owner, doc, ids) || owner_meta.component != source_meta.component {
+            return None;
+        }
+        let target = *ids.get(expanded_id(source_meta.rest, meta.guid)?.as_str())?;
+        let target_meta = self.origin(target)?;
+        if !target_meta.expanded
+            || target_meta.guid != meta.guid
+            || self.owner(target, doc, ids) != Some(source_owner)
+            || !self.namespace(target, source_owner, doc)
+        {
+            return None;
+        }
+        let parent = doc.node(id)?.parent?;
+        let target_parent = doc.node(target)?.parent?;
+        if parent == owner {
+            (target_parent == source_owner).then_some(target)
+        } else {
+            (target_parent != source_owner && self.origin(parent)?.guid == self.origin(target_parent)?.guid).then_some(target)
+        }
+    }
+
+    fn source(
+        &self,
+        id: NodeId,
+        doc: &Document,
+        ids: &BTreeMap<String, NodeId>,
+        memo: &mut BTreeMap<NodeId, Option<NodeId>>,
+        active: &mut BTreeSet<NodeId>,
+        depth: usize,
+    ) -> Option<NodeId> {
+        if let Some(source) = memo.get(&id) {
+            return *source;
+        }
+        if depth > MAX_DEPTH || !active.insert(id) {
+            return None;
+        }
+        let found = (|| {
+            let meta = self.origin(id)?;
+            let _ = doc.node(id)?;
+            if meta.slot_content {
+                return if matches!(doc.node(id)?.kind, NodeKind::Instance { .. }) { self.root_source(id, doc) } else { None };
+            }
+            if !meta.expanded {
+                return self.root_source(id, doc);
+            }
+            // An actual wire INSTANCE whose main is absent remains a namespace owner even
+            // when the REST importer materializes it as a frame. Ordinary frames never do.
+            let owner = self.owner(id, doc, ids)?;
+            if !self.namespace(id, owner, doc) {
+                return None;
+            }
+            let source_owner = self.source(owner, doc, ids, memo, active, depth + 1);
+            if self.missing_frame(owner, doc, ids) {
+                let target = match source_owner {
+                    Some(source_owner) => self.frame_target(id, owner, source_owner, doc, ids)?,
+                    None if self.owned_layer(id, doc, ids) => return self.root_source(id, doc),
+                    _ => return None,
+                };
+                return (target != id && !doc.is_ancestor(id, target)).then_some(target);
+            }
+            let NodeKind::Instance { component: main, .. } = &doc.node(owner)?.kind else { return None };
+            let source_owner = source_owner?;
+            let target = match &doc.node(source_owner)?.kind {
+                NodeKind::Component { .. } if source_owner == *main => self.raw_in_main(meta.guid, *main, doc, ids)?,
+                NodeKind::Instance { component: source_main, .. } if source_main != main => {
+                    // A resolved main switch is evidence for resetting to that CURRENT main.
+                    self.raw_in_main(meta.guid, *main, doc, ids)?
+                }
+                NodeKind::Instance { component: source_main, .. } if source_main == main => {
+                    let source_meta = self.origin(source_owner)?;
+                    let target = *ids.get(expanded_id(source_meta.rest, meta.guid)?.as_str())?;
+                    let target_meta = self.origin(target)?;
+                    let target_owner = self.owner(target, doc, ids);
+                    if !target_meta.expanded || target_meta.guid != meta.guid || target_owner != Some(source_owner) {
+                        return None;
+                    }
+                    target
+                }
+                NodeKind::Frame if self.origin(source_owner)?.wire_frame => {
+                    // An actual wire FRAME becoming INSTANCE has no previous main. Its resolved
+                    // current main is the only proven namespace for its newly expanded children.
+                    self.raw_in_main(meta.guid, *main, doc, ids)?
+                }
+                _ => return None,
+            };
+            (target != id && !doc.is_ancestor(id, target)).then_some(target)
+        })();
+        active.remove(&id);
+        memo.insert(id, found);
+        found
+    }
+
+    pub(super) fn apply(self, doc: &mut Document, ids: &BTreeMap<String, NodeId>) -> usize {
+        let mut links = BTreeMap::new();
+        let mut active = BTreeSet::new();
+        for &id in self.nodes.keys() {
+            let _ = self.source(id, doc, ids, &mut links, &mut active, 0);
+        }
+        let mut missing = self.rejected;
+        for (&id, meta) in &self.nodes {
+            let needs_source = (!meta.slot_content && meta.expanded && !self.owned_layer(id, doc, ids))
+                || doc.node(id).is_some_and(|n| matches!(n.kind, NodeKind::Instance { .. }));
+            if !needs_source {
+                continue;
+            }
+            let target = links.get(&id).copied().flatten().filter(|_| acyclic(id, &links));
+            if let Some(target) = target {
+                if let Some(node) = doc.node_mut(id) {
+                    node.source = Some(target);
+                }
+            } else {
+                missing += 1;
+            }
+        }
+        missing
+    }
+}
+
+fn acyclic(id: NodeId, links: &BTreeMap<NodeId, Option<NodeId>>) -> bool {
+    let mut current = id;
+    for _ in 0..=MAX_DEPTH {
+        let Some(next) = links.get(&current).copied().flatten() else { return true };
+        if next == id {
+            return false;
+        }
+        current = next;
+    }
+    false
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn self_cycles_and_overlong_source_chains_are_rejected() {
+        let self_link = BTreeMap::from([(NodeId(1), Some(NodeId(1)))]);
+        assert!(!acyclic(NodeId(1), &self_link));
+        let cycle = BTreeMap::from([(NodeId(1), Some(NodeId(2))), (NodeId(2), Some(NodeId(1)))]);
+        assert!(!acyclic(NodeId(1), &cycle));
+        let long = (1..=MAX_DEPTH as u64 + 2).map(|i| (NodeId(i), Some(NodeId(i + 1)))).collect();
+        assert!(!acyclic(NodeId(1), &long));
+        assert!(expanded_id(&"x".repeat(MAX_SOURCE_ID_BYTES), "1:2").is_none());
+    }
+}
diff --git a/crates/format/src/rest/grid_track_tests.rs b/crates/format/src/rest/grid_track_tests.rs
new file mode 100644
index 000000000..a11780ca5
--- /dev/null
+++ b/crates/format/src/rest/grid_track_tests.rs
@@ -0,0 +1,42 @@
+//! REST import of grid track sizes (`gridColumnsSizing`, `gridRowsSizing`: CSS
+//! `grid-template-columns`/`-rows` strings). Fixtures are synthetic, written by hand.
+
+use super::*;
+use figcraft_doc::GridTrack;
+use serde_json::json;
+
+fn tracks(columns: Value, rows: Value) -> (Vec<GridTrack>, Vec<GridTrack>) {
+    let file = json!({"name": "Fixture", "document": {"id": "0:0", "name": "Document", "type": "DOCUMENT", "children": [
+        {"id": "0:1", "name": "Page", "type": "CANVAS", "children": [
+            {"id": "1", "name": "Grid", "type": "FRAME", "relativeTransform": [[1, 0, 0], [0, 1, 0]], "size": {"x": 400, "y": 200},
+             "layoutMode": "GRID", "gridColumnCount": 7, "gridRowCount": 2, "gridColumnsSizing": columns, "gridRowsSizing": rows}
+        ]}
+    ]}});
+    let (doc, _) = import(&file, &no_images).unwrap();
+    let layout = doc.nodes().find(|n| n.name == "Grid").unwrap().layout.clone().unwrap();
+    (layout.column_tracks, layout.row_tracks)
+}
+
+#[test]
+fn css_track_strings_set_the_track_sizes() {
+    let (cols, rows) = tracks(json!("120px 2fr auto"), json!("repeat(2, minmax(0, 1fr))"));
+    assert_eq!(cols, [GridTrack::fixed(120.0), GridTrack::fill(2.0), GridTrack::hug()]);
+    assert_eq!(rows, [GridTrack::fill(1.0); 2]);
+    let (cols, rows) = tracks(json!(" repeat(2, 40px 1.5fr)  minmax(64px, 64px) "), json!("min-content max-content"));
+    assert_eq!(cols, [GridTrack::fixed(40.0), GridTrack::fill(1.5), GridTrack::fixed(40.0), GridTrack::fill(1.5), GridTrack::fixed(64.0)]);
+    assert_eq!(rows, [GridTrack::hug(); 2]);
+}
+
+#[test]
+fn unsupported_or_junk_tracks_are_equal_tracks() {
+    // Ranges the grid can't express, units it doesn't have and junk keep their place as 1fr.
+    let (cols, rows) = tracks(json!("minmax(10px, 80px) 5em -3px 0fr NaNpx repeat(x, 1px) 10px"), json!(7));
+    assert_eq!(cols, [[GridTrack::default(); 6].as_slice(), &[GridTrack::fixed(10.0)]].concat());
+    assert!(rows.is_empty(), "a non-string is ignored");
+    // Tracks past the grid's own count are left out; huge repeats and deep nesting stay bounded.
+    let (cols, rows) = tracks(json!(format!("repeat(999999999999, 1px) {}", "minmax(".repeat(10_000))), json!("1px 2px 3px"));
+    assert_eq!(cols, [GridTrack::fixed(1.0); 7]);
+    assert_eq!(rows, [GridTrack::fixed(1.0), GridTrack::fixed(2.0)]);
+    let (cols, rows) = tracks(json!("1e9px"), json!("( ) )) repeat(2,)"));
+    assert_eq!((cols, rows.len()), (vec![GridTrack::default()], 2));
+}
diff --git a/crates/format/src/rest/import_regression_tests.rs b/crates/format/src/rest/import_regression_tests.rs
new file mode 100644
index 000000000..2d6364be2
--- /dev/null
+++ b/crates/format/src/rest/import_regression_tests.rs
@@ -0,0 +1,59 @@
+//! Stroke-only vectors that import as the outline of their stroke keep the stroke's style and variables.
+
+use super::proto_variable_tests::{BRAND, alias, variables_json};
+use super::*;
+use serde_json::json;
+
+fn at(x: f64, y: f64) -> Value {
+    json!([[1, 0, x], [0, 1, y]])
+}
+
+fn file(children: Value) -> Value {
+    json!({"name": "Fixture", "schemaVersion": 0, "document": {"id": "0:0", "name": "Document", "type": "DOCUMENT", "children": [
+        {"id": "0:1", "name": "Page", "type": "CANVAS", "children": children}
+    ]}})
+}
+
+fn named<'a>(doc: &'a Document, name: &str) -> &'a Node {
+    doc.nodes().find(|n| n.name == name).unwrap_or_else(|| panic!("no node {name}"))
+}
+
+/// A stroke-only icon vector as `geometry=paths` returns it: no fills, one visible stroke.
+fn stroke_only_vector(id: &str, name: &str, stroke: Value) -> Value {
+    json!({"id": id, "name": name, "type": "VECTOR", "relativeTransform": at(0.0, 0.0), "size": {"x": 10, "y": 10},
+           "fills": [], "strokes": [stroke], "strokeWeight": 2,
+           "fillGeometry": [],
+           "strokeGeometry": [{"path": "M 0 0 L 10 0 L 10 2 L 0 2 Z", "windingRule": "NONZERO"}],
+           "styles": {"stroke": "S:stroke"}})
+}
+
+#[test]
+fn stroke_only_vector_shared_stroke_style_keeps_paints() {
+    let stroke = json!({"type": "SOLID", "color": {"r": 1, "g": 0, "b": 0, "a": 1}});
+    let mut v = file(json!([stroke_only_vector("1:1", "Icon", stroke)]));
+    v["styles"] = json!({"S:stroke": {"key": "k", "name": "Brand/Stroke", "styleType": "FILL"}});
+    let (doc, _) = import(&v, &no_images).unwrap();
+    let icon = named(&doc, "Icon");
+    assert!(matches!(icon.kind, NodeKind::Vector { .. }));
+    let style = doc.style("S:stroke").expect("shared stroke style is created");
+    match &style.kind {
+        StyleKind::Paint { paints } => assert_eq!(paints.len(), 1, "shared stroke style must keep the stroke paint, got {paints:?}"),
+        k => panic!("unexpected style kind {k:?}"),
+    }
+}
+
+#[test]
+fn stroke_colour_variable_on_outlined_vector_is_kept() {
+    let stroke = json!({"type": "SOLID", "color": {"r": 1, "g": 0, "b": 0, "a": 1}, "boundVariables": {"color": alias(BRAND)}});
+    let mut node = stroke_only_vector("1:1", "Icon", stroke);
+    node.as_object_mut().unwrap().remove("styles");
+    node["boundVariables"] = json!({"strokes": [alias(BRAND)]});
+    let (doc, warnings) = import_with(&file(json!([node])), Some(&variables_json()), &no_images).unwrap();
+    let icon = named(&doc, "Icon");
+    // The stroke paint now paints the outline as its fill: its colour token must follow it.
+    assert!(
+        icon.bound.values().any(|v| v == BRAND),
+        "colour variable bound on the outlined stroke was dropped; bound={:?} warnings={warnings:?}",
+        icon.bound
+    );
+}
diff --git a/crates/format/src/rest/mod.rs b/crates/format/src/rest/mod.rs
index 798b2645a..78279e915 100644
--- a/crates/format/src/rest/mod.rs
+++ b/crates/format/src/rest/mod.rs
@@ -6,8 +6,8 @@
 //! (`relativeTransform`, else `absoluteBoundingBox` + `rotation`), paints, strokes, effects,
 //! corners, constraints, auto layout, layout grids, export settings, text with styled runs,
 //! vectors from `fillGeometry` / `strokeGeometry`, components, component sets, instances and
-//! component properties are imported. Image fills keep their `imageRef` as the image key and
-//! show a grey placeholder unless an [`ImageResolver`] supplies the bytes (nothing is fetched).
+//! component properties (slots included) are imported. Image fills keep their `imageRef` as the
+//! image key and show a grey placeholder unless an [`ImageResolver`] supplies the bytes (nothing is fetched).
 //! Prototyping comes along: interactions (triggers, actions, transitions, easing), flows,
 //! scrolling and the prototype device. Variables come from the local variables response
 //! (`GET /v1/files/:key/variables/local`), embedded next to the file JSON or passed separately
@@ -16,7 +16,8 @@
 //!
 //! Instances come out with their own layers as the file lists them. Linking those layers to the
 //! main component's (`source`) and deriving overrides is left to the caller (the engine does it
-//! after loading), since that needs the component model.
+//! after loading), since that needs the component model. The private .fig entry point additionally
+//! preserves explicit GUID/expansion provenance before the engine derives overrides.
 
 #[cfg(test)]
 mod blur_tests;
@@ -24,13 +25,20 @@ mod blur_tests;
 mod conditional_tests;
 #[cfg(test)]
 mod effects_tests;
+mod fig_sources;
 #[cfg(test)]
 mod gamepad_tests;
+#[cfg(test)]
+mod grid_track_tests;
+#[cfg(test)]
+mod import_regression_tests;
 pub(crate) mod props;
 pub(crate) mod proto;
 #[cfg(test)]
 mod proto_variable_tests;
 #[cfg(test)]
+pub(crate) mod slot_tests;
+#[cfg(test)]
 mod tests;
 mod text;
 mod variables;
@@ -49,16 +57,20 @@ use crate::FormatError;
 use props::{MAX_COORD, MAX_SIZE, clip_str, flag, list, num, text};
 pub use variables::export as export_variables;
 
-/// Most layers imported from one file.
+/// Most layers imported from one file. The `.fig` import sets its own, from the file's size.
 pub const MAX_NODES: usize = 200_000;
 /// Deepest layer nesting followed.
 const MAX_DEPTH: usize = 256;
+/// Private .fig provenance, consumed only by the `.fig` import ([`import_with_networks`]).
+pub(crate) const FIG_SOURCE_FIELD: &str = "_figSource";
+/// Hidden .fig library context; accepted only by the `.fig` import ([`import_with_networks`]).
+pub(crate) const FIG_LIBRARY_CONTEXTS_FIELD: &str = "_figLibraryContexts";
 /// Longest SVG path string read from one geometry entry.
 const MAX_PATH_BYTES: usize = 4 << 20;
 /// Most path elements in one vector.
 const MAX_PATH_ELEMENTS: usize = 200_000;
 /// Most distinct warnings reported.
-const MAX_WARNINGS: usize = 200;
+pub(crate) const MAX_WARNINGS: usize = 200;
 /// Most shared style definitions read.
 const MAX_STYLES: usize = 10_000;
 /// Image key used for image fills without an `imageRef`.
@@ -96,12 +108,25 @@ pub fn is_variables_json(v: &Value) -> bool {
 }
 
 /// The collections and variables of a local variables response (or its `meta`), checked like a
-/// file's, with the warnings about what was skipped; None when `v` isn't one.
+/// file's, with the warnings about what was skipped (and when it holds no variables at all, or
+/// fewer than its collections list); None when `v` isn't one.
 pub fn read_variables(v: &Value) -> Option<(figcraft_doc::Variables, Vec<String>)> {
-    let src = variables::source(v)?;
+    variables::source(v)?;
     let mut cx = Ctx::new(Document::new("Variables"), &no_images);
-    cx.variables(src);
-    Some((std::mem::take(&mut cx.doc.variables), cx.warnings.finish()))
+    cx.variables(v);
+    let vars = std::mem::take(&mut cx.doc.variables);
+    let mut warnings = cx.warnings.finish();
+    if vars.variables.is_empty() {
+        warnings.push("no variables found: expected `meta.variables` (an object of variables by id, next to `meta.variableCollections`)".into());
+    } else {
+        let listed = variables::listed_ids(v);
+        let read: BTreeSet<&str> = vars.variables.iter().map(|x| x.id.as_str()).collect();
+        let missing = listed.difference(&read).count();
+        if missing > 0 {
+            warnings.push(format!("{missing} of the {} variables the collections list in `variableIds` weren't imported", listed.len()));
+        }
+    }
+    Some((vars, warnings))
 }
 
 /// Import `bytes` when they are REST API file JSON; `None` when they are something else (the
@@ -138,25 +163,58 @@ pub fn import(v: &Value, images: ImageResolver) -> Result<(Document, Vec<String>
 /// in the file JSON (a `meta` with `variableCollections`, or `variableCollections` and
 /// `variables` at the top level) are read too; the first definition of an id wins.
 pub fn import_with(v: &Value, variables: Option<&Value>, images: ImageResolver) -> Result<(Document, Vec<String>), FormatError> {
+    import_parts(v, variables, images, Vec::new(), MAX_NODES, false)
+}
+
+/// Internal .fig JSON path: GUID provenance is not part of the public REST import contract.
+/// The `.fig` import itself goes through [`import_with_networks`].
+#[cfg(test)]
+pub(crate) fn import_fig(v: &Value, images: ImageResolver) -> Result<(Document, Vec<String>), FormatError> {
+    import_with_networks(v, images, Vec::new(), MAX_NODES)
+}
+
+/// [`import_fig`] for the `.fig` import's JSON, whose vectors name their networks by
+/// `vectorNetworkRef`, an index in `networks` (built once each, and far smaller than as JSON).
+/// `max_nodes`: the layer cap, set by the `.fig` import in place of [`MAX_NODES`].
+pub(crate) fn import_with_networks(
+    v: &Value,
+    images: ImageResolver,
+    networks: Vec<Option<VectorNetwork>>,
+    max_nodes: usize,
+) -> Result<(Document, Vec<String>), FormatError> {
+    import_parts(v, None, images, networks, max_nodes, true)
+}
+
+fn import_parts(
+    v: &Value,
+    variables: Option<&Value>,
+    images: ImageResolver,
+    networks: Vec<Option<VectorNetwork>>,
+    max_nodes: usize,
+    fig_sources: bool,
+) -> Result<(Document, Vec<String>), FormatError> {
     let entries: Vec<&Value> = if is_document(v) { vec![v] } else { nodes_entries(v).collect() };
     if entries.is_empty() {
         return Err(FormatError::Corrupt("not a REST API file JSON (no `document`)".into()));
     }
     let name = text(v, "name").filter(|n| !n.trim().is_empty()).map_or("Imported file", clip_str);
     let mut cx = Ctx::new(Document::new(name), images);
+    cx.fig_sources = fig_sources.then(|| fig_sources::Sources::new(max_nodes));
     let blank = cx.doc.first_page();
     let mut loose: Option<NodeId> = None;
     for e in &entries {
         cx.collect_meta(e);
     }
     // Variables first: layers link to them as they are built.
-    for src in [variables::source(v), variables.and_then(variables::source)].into_iter().flatten() {
+    for src in [Some(v), variables].into_iter().flatten() {
         cx.variables(src);
     }
     if variables.is_some_and(|x| variables::source(x).is_none()) {
         cx.warn("the variables JSON has no `variableCollections` (expected the local variables response) and was ignored");
     }
     cx.style_definitions(v);
+    cx.networks = networks;
+    cx.max_nodes = max_nodes;
     for e in entries {
         let Some(root) = e.get("document") else { continue };
         match text(root, "type") {
@@ -178,6 +236,12 @@ pub fn import_with(v: &Value, variables: Option<&Value>, images: ImageResolver)
             None => cx.warn("entries without a node type were skipped"),
         }
     }
+    if fig_sources {
+        for context in v.get(FIG_LIBRARY_CONTEXTS_FIELD).and_then(Value::as_array).into_iter().flatten() {
+            let store = cx.doc.ensure_library_store();
+            cx.build(context, store, Space::default(), None, 0, false);
+        }
+    }
     // Drop the empty page the new document started with once real pages exist.
     if let Some(p) = blank
         && cx.doc.pages.len() > 1
@@ -210,7 +274,7 @@ fn style_binding(slot: &str, key: &str) -> Option<String> {
 /// Put back the shape a layer was before the `.fig` export wrote it as the outline of its stroke
 /// (`outlinedStroke`: `{kind, fills, strokes, stroke}` as the document holds them). Anything that
 /// isn't such a shape is ignored.
-fn restore_stroke(n: &mut Node, original: &Value) {
+fn restore_stroke(n: &mut Node, original: &Value) -> bool {
     #[derive(serde::Deserialize)]
     struct Original {
         kind: NodeKind,
@@ -218,16 +282,16 @@ fn restore_stroke(n: &mut Node, original: &Value) {
         strokes: Vec<figcraft_doc::color::Paint>,
         stroke: figcraft_doc::StrokeProps,
     }
-    let Ok(mut o) = serde_json::from_value::<Original>(original.clone()) else { return };
+    let Ok(mut o) = serde_json::from_value::<Original>(original.clone()) else { return false };
     match &mut o.kind {
         NodeKind::Vector { network } => {
             if network.vertices.len() + network.segments.len() > MAX_PATH_ELEMENTS {
-                return;
+                return false;
             }
             network.sanitize();
         }
         NodeKind::Line | NodeKind::Ellipse { .. } | NodeKind::Polygon { .. } | NodeKind::Star { .. } | NodeKind::Rectangle => {}
-        _ => return,
+        _ => return false,
     }
     let sp = &mut o.stroke;
     sp.weight = sp.weight.clamp(0.0, props::MAX_SIZE);
@@ -237,6 +301,28 @@ fn restore_stroke(n: &mut Node, original: &Value) {
     o.fills.truncate(64);
     o.strokes.truncate(64);
     (n.kind, n.fills, n.strokes, n.stroke) = (o.kind, o.fills, o.strokes, o.stroke);
+    true
+}
+
+/// A stroke-only vector imported as the outline of its stroke: the stroke paints fill the
+/// outline, and the stroke's shared style and colour variables move with them. The hidden fills
+/// it replaces go, with their style and bindings.
+fn outline_stroke(n: &mut Node) {
+    n.fills = std::mem::take(&mut n.strokes);
+    n.styles.fill = n.styles.stroke.take();
+    let bound = std::mem::take(&mut n.bound);
+    for (key, var) in bound {
+        let moved = match key.as_str() {
+            "fill" => continue,
+            k if k.starts_with("fills/") => continue,
+            "stroke" => "fill".to_string(),
+            k => match k.strip_prefix("strokes/") {
+                Some(rest) => format!("fills/{rest}"),
+                None => key,
+            },
+        };
+        n.bound.insert(moved, var);
+    }
 }
 
 fn children(v: &Value) -> &[Value] {
@@ -291,11 +377,16 @@ pub(crate) struct Ctx<'a> {
     count: usize,
     /// REST node id → imported node.
     ids: BTreeMap<String, NodeId>,
+    fig_sources: Option<fig_sources::Sources<'a>>,
     component_meta: BTreeMap<&'a str, &'a Value>,
     set_meta: BTreeMap<&'a str, &'a Value>,
     style_meta: BTreeMap<&'a str, &'a Value>,
     /// Instances (imported as frames until their main is resolved) with their JSON.
     instances: Vec<(NodeId, &'a Value)>,
+    /// `SLOT` layers (imported as frames until their slot property is resolved) with their JSON.
+    slots: Vec<(NodeId, &'a Value)>,
+    /// Slot property defaults (the main's slot content id): (component or set, property) → value.
+    slot_defaults: BTreeMap<(NodeId, String), &'a Value>,
     /// Instance-swap property defaults: (component or set, property, REST id of the default).
     swap_defaults: Vec<(NodeId, String, String)>,
     /// Property definitions of component sets, shared by their variants.
@@ -309,6 +400,10 @@ pub(crate) struct Ctx<'a> {
     /// Imported variables by id, and the mode ids of imported collections (default first).
     var_kinds: BTreeMap<String, VariableType>,
     var_modes: BTreeMap<String, Vec<String>>,
+    /// Vector networks built by the `.fig` import, named by layers' `vectorNetworkRef`.
+    networks: Vec<Option<VectorNetwork>>,
+    /// Most layers imported: [`MAX_NODES`], or the `.fig` import's own cap.
+    max_nodes: usize,
 }
 
 impl<'a> Ctx<'a> {
@@ -321,10 +416,13 @@ impl<'a> Ctx<'a> {
             warnings: Warnings::default(),
             count: 0,
             ids: BTreeMap::new(),
+            fig_sources: None,
             component_meta: BTreeMap::new(),
             set_meta: BTreeMap::new(),
             style_meta: BTreeMap::new(),
             instances: Vec::new(),
+            slots: Vec::new(),
+            slot_defaults: BTreeMap::new(),
             swap_defaults: Vec::new(),
             set_defs: BTreeMap::new(),
             flows: Vec::new(),
@@ -332,6 +430,8 @@ impl<'a> Ctx<'a> {
             overlay_meta: BTreeMap::new(),
             var_kinds: BTreeMap::new(),
             var_modes: BTreeMap::new(),
+            networks: Vec::new(),
+            max_nodes: MAX_NODES,
         }
     }
 
@@ -387,8 +487,9 @@ impl<'a> Ctx<'a> {
             self.warn(format!("layers nested deeper than {MAX_DEPTH} levels were skipped"));
             return;
         }
-        if self.count >= MAX_NODES {
-            self.warn(format!("the file has more than {MAX_NODES} layers; the rest were skipped"));
+        if self.count >= self.max_nodes {
+            let max = self.max_nodes;
+            self.warn(format!("the file has more than {max} layers; the rest were skipped"));
             return;
         }
         let Some(ty) = text(j, "type") else {
@@ -403,6 +504,12 @@ impl<'a> Ctx<'a> {
         let id = self.doc.alloc_id();
         let label = kind.label();
         let mut n = Node::new(id, kind, text(j, "name").map_or(label, clip_str), w, h);
+        // Overrides the .fig names explicitly (the rest are found by comparing with the main).
+        for (flag, group) in [("slotOverride", "slot"), ("sizeOverride", "size")] {
+            if self.fig_sources.is_some() && j.get(FIG_SOURCE_FIELD).and_then(|source| source.get(flag)).and_then(Value::as_bool) == Some(true) {
+                n.overrides.insert(group.into());
+            }
+        }
         n.transform = local(space.world, world);
         self.common(&mut n, j, parent_mode);
         let (container, follows, mode) = (n.kind.is_container(), n.kind.bounds_follow_children(), n.layout.as_ref().map(|l| l.mode));
@@ -411,10 +518,15 @@ impl<'a> Ctx<'a> {
         }
         self.count += 1;
         if let Some(rid) = text(j, "id") {
-            self.ids.entry(rid.to_string()).or_insert(id);
+            let primary = *self.ids.entry(rid.to_string()).or_insert(id) == id;
+            if let Some(sources) = &mut self.fig_sources {
+                sources.record(id, j, primary);
+            }
         }
-        if ty == "INSTANCE" {
-            self.instances.push((id, j));
+        match ty {
+            "INSTANCE" => self.instances.push((id, j)),
+            "SLOT" => self.slots.push((id, j)),
+            _ => {}
         }
         let kids = children(j);
         if kids.is_empty() {
@@ -437,8 +549,8 @@ impl<'a> Ctx<'a> {
         let point_count = || num(j, "pointCount").filter(|c| *c >= 3.0).map(|c| c.min(1000.0) as u32);
         let has_geometry = !list(j, "fillGeometry").is_empty() || !list(j, "strokeGeometry").is_empty();
         Some(match ty {
-            // Instances start as frames; `finish` links them to their main.
-            "FRAME" | "INSTANCE" => NodeKind::Frame,
+            // Instances and slots start as frames; `finish` links them to their main and property.
+            "FRAME" | "INSTANCE" | "SLOT" => NodeKind::Frame,
             "GROUP" => NodeKind::Group,
             "SECTION" => NodeKind::Section { contents_hidden: flag(j, "sectionContentsHidden").unwrap_or(false) },
             "RECTANGLE" => NodeKind::Rectangle,
@@ -548,19 +660,18 @@ impl<'a> Ctx<'a> {
             if let Some(c) = flag(j, "clipsContent") {
                 n.clip = c;
             }
-            n.layout = props::auto_layout(j);
+            n.layout = props::auto_layout(j, self.fig_sources.is_some());
             n.grids = props::layout_grids(j);
         }
         n.child_layout = props::child_layout(j, n.layout.as_ref().map(|l| l.mode), parent_mode);
         n.exports = props::export_settings(j);
         for (field, prop) in j.get("componentPropertyReferences").and_then(Value::as_object).into_iter().flatten() {
-            if let (Some(p), true) = (prop.as_str(), matches!(field.as_str(), "visible" | "characters" | "mainComponent")) {
+            let supported = matches!(field.as_str(), "visible" | "characters" | "mainComponent") || (field == "slot" && self.fig_sources.is_some());
+            if let (Some(p), true) = (prop.as_str(), supported) {
                 n.prop_refs.insert(field.clone(), p.to_string());
             }
         }
-        if matches!(n.kind, NodeKind::Vector { .. }) {
-            self.vector(n, j);
-        }
+        let outlined = matches!(n.kind, NodeKind::Vector { .. }) && self.vector(n, j);
         if matches!(n.kind, NodeKind::Component { .. } | NodeKind::ComponentSet { .. }) {
             let defs = self.prop_defs(n.id, j);
             match &mut n.kind {
@@ -581,20 +692,28 @@ impl<'a> Ctx<'a> {
             self.overlay_meta.entry(rid).or_insert(j);
         }
         self.bindings(n, j);
-        if let Some(original) = j.get("outlinedStroke") {
-            restore_stroke(n, original);
+        let restored = j.get("outlinedStroke").is_some_and(|original| restore_stroke(n, original));
+        // Styles and bindings were read against the stroke: they follow its paints to the fill.
+        if outlined && !restored {
+            outline_stroke(n);
         }
     }
 
-    /// A vector's network: the editable one when the JSON carries it (`vectorNetwork`, our
-    /// extension, written by the `.fig` import), else from its geometry. A stroke-only vector
-    /// uses the stroke outline, painted with the stroke paints (exact look, editable as a shape).
-    fn vector(&mut self, n: &mut Node, j: &Value) {
-        if let Some(net) = j.get("vectorNetwork") {
-            match network(net) {
+    /// A vector's network: the editable one when the JSON carries it (`vectorNetwork`, or
+    /// `vectorNetworkRef` naming one built by the `.fig` import: our extensions), else from its
+    /// geometry. A stroke-only vector uses the stroke outline, painted with the stroke paints
+    /// (exact look, editable as a shape): returns whether it does, and the caller moves the paints
+    /// with [`outline_stroke`] once the styles and variables of the stroke are read.
+    fn vector(&mut self, n: &mut Node, j: &Value) -> bool {
+        let net = match j.get("vectorNetworkRef") {
+            Some(r) => Some(r.as_u64().and_then(|i| self.networks.get(usize::try_from(i).ok()?).cloned().flatten())),
+            None => j.get("vectorNetwork").map(network),
+        };
+        if let Some(net) = net {
+            match net {
                 Some(network) => {
                     n.kind = NodeKind::Vector { network };
-                    return;
+                    return false;
                 }
                 None => self.warn("invalid or oversized vector networks import as outlines"),
             }
@@ -609,17 +728,15 @@ impl<'a> Ctx<'a> {
             (None, Some(s)) => (s, true),
             (None, None) => {
                 self.warn("vectors without geometry are empty (export the file JSON with geometry=paths)");
-                return;
+                return false;
             }
         };
         let mut network = VectorNetwork::from_path(&path);
         for r in &mut network.regions {
             r.winding = winding;
         }
-        if outline {
-            n.fills = std::mem::take(&mut n.strokes);
-        }
         n.kind = NodeKind::Vector { network };
+        outline
     }
 
     /// The paths of a `fillGeometry` / `strokeGeometry` list (node-local SVG path data).
@@ -644,7 +761,7 @@ impl<'a> Ctx<'a> {
     }
 
     /// Component property definitions (variant ones are implied by the variant names).
-    fn prop_defs(&mut self, owner: NodeId, j: &Value) -> BTreeMap<String, PropDef> {
+    fn prop_defs(&mut self, owner: NodeId, j: &'a Value) -> BTreeMap<String, PropDef> {
         let mut out = BTreeMap::new();
         for (name, d) in j.get("componentPropertyDefinitions").and_then(Value::as_object).into_iter().flatten().take(256) {
             let default = d.get("defaultValue");
@@ -658,6 +775,13 @@ impl<'a> Ctx<'a> {
                     continue;
                 }
                 Some("VARIANT") => continue,
+                Some("SLOT") => {
+                    if let Some(d) = default {
+                        self.slot_defaults.insert((owner, name.clone()), d);
+                    }
+                    self.slot_notes(d);
+                    PropDef::Slot { preferred: Vec::new() }
+                }
                 _ => {
                     self.warn("unknown component property types were skipped");
                     continue;
@@ -668,6 +792,20 @@ impl<'a> Ctx<'a> {
         out
     }
 
+    /// Notes on what a slot property sets that the editor doesn't keep: preferred components (keys
+    /// of library components, not layers of the file) and limits on its content.
+    fn slot_notes(&mut self, d: &Value) {
+        if !list(d, "preferredValues").is_empty() {
+            self.warn("preferred slot component keys cannot be resolved to file nodes and were skipped");
+        }
+        // Insertion and empty-slot display only change editing aids, not what the file shows.
+        let s = d.get("slotSettings");
+        let limit = |k: &str| s.and_then(|s| num(s, k)).is_some_and(|n| n != 0.0);
+        if limit("minChildren") || limit("maxChildren") || s.and_then(|s| flag(s, "allowPreferredValuesOnly")) == Some(true) {
+            self.warn("non-default slot settings are not represented and were skipped");
+        }
+    }
+
     /// Shared styles with their values (`styleDefinitions`, written by the `.fig` import: a list of
     /// `{id, name, description, styleType, node}`, the node being a layer that shows the style), in
     /// the file's order. Layers then link to them; styles that no layer uses come across too.
@@ -822,6 +960,12 @@ impl<'a> Ctx<'a> {
             }
         }
         self.resolve_instances();
+        if let Some(sources) = self.fig_sources.take() {
+            let missing = sources.apply(&mut self.doc, &self.ids);
+            if missing > 0 {
+                self.warn(format!("{missing} .fig instance source link(s) could not be resolved and were left unlinked"));
+            }
+        }
         self.rename_props();
         for (id, j) in std::mem::take(&mut self.protos) {
             let list = self.interactions(j);
@@ -870,6 +1014,7 @@ impl<'a> Ctx<'a> {
     /// outside components, and instances that would nest a component inside itself (directly or
     /// through other components), stay frames.
     fn resolve_instances(&mut self) {
+        let frames: BTreeSet<NodeId> = self.instances.iter().map(|(i, _)| *i).collect();
         let mut links: Vec<(NodeId, NodeId, &'a Value)> = Vec::new();
         for (inst, j) in std::mem::take(&mut self.instances) {
             match text(j, "componentId").and_then(|r| self.component(r)) {
@@ -899,6 +1044,7 @@ impl<'a> Ctx<'a> {
                 linked.push((inst, j));
             }
         }
+        self.resolve_slots(&frames, &linked);
         // Overridden fields the file lists, on the instance and its layers.
         for (inst, j) in linked {
             for o in list(j, "overrides") {
@@ -914,6 +1060,70 @@ impl<'a> Ctx<'a> {
         }
     }
 
+    /// `SLOT` layers. In a main component a slot is bound to its slot property: the one the layer
+    /// references, else the one named like it, else the main's only slot property left. In an
+    /// instance it follows its main's slot, and holds the instance's own content (kept across syncs)
+    /// unless the instance's value of the property is the main's default content (without the
+    /// values to compare, a slot holding layers keeps them as its own). A slot without a property
+    /// stays a frame. `frames`: every instance
+    /// layer of the file, `linked`: those that became instances.
+    fn resolve_slots(&mut self, frames: &BTreeSet<NodeId>, linked: &[(NodeId, &'a Value)]) {
+        let linked: BTreeMap<NodeId, &Value> = linked.iter().copied().collect();
+        let mut bound: BTreeSet<(NodeId, String)> = BTreeSet::new();
+        for (id, j) in std::mem::take(&mut self.slots) {
+            // The nearest main component or instance above the slot owns it; in an instance whose
+            // main isn't in the file (a frame), the slot stays a frame too.
+            let owner = self.doc.ancestors(id).into_iter().find_map(|a| match self.doc.node(a).map(|n| &n.kind) {
+                Some(NodeKind::Instance { component, .. }) => Some(linked.get(&a).map(|j| (*component, Some(*j)))),
+                Some(NodeKind::Component { .. }) => Some(Some((a, None))),
+                _ => frames.contains(&a).then_some(None),
+            });
+            let Some(owner) = owner else {
+                self.warn("slot layers without a matching slot property were imported as frames");
+                continue;
+            };
+            let Some((main, inst)) = owner else { continue };
+            let Some(NodeKind::Component { props, .. }) = self.doc.node(main).map(|n| &n.kind) else { continue };
+            let defs: Vec<&String> = props.iter().filter(|(_, d)| matches!(d, PropDef::Slot { .. })).map(|(k, _)| k).collect();
+            let layer = text(j, "name").unwrap_or_default();
+            let refs: Vec<&str> =
+                j.get("componentPropertyReferences").and_then(Value::as_object).into_iter().flatten().filter_map(|(_, v)| v.as_str()).collect();
+            // An instance's slot is matched against all of its main's slot properties.
+            let free: Vec<&&String> = defs.iter().filter(|d| inst.is_some() || !bound.contains(&(main, (**d).clone()))).collect();
+            let name = defs
+                .iter()
+                .find(|d| refs.contains(&d.as_str()))
+                .or_else(|| defs.iter().find(|d| short_prop_name(d) == layer))
+                .or_else(|| if free.len() == 1 { free.first().copied() } else { None })
+                .map(|d| (*d).clone());
+            let Some(n) = self.doc.node(id) else { continue };
+            let has_content = !n.children.is_empty();
+            let Some(inst) = inst else {
+                match name.filter(|p| bound.insert((main, p.clone()))) {
+                    Some(p) => {
+                        if let Some(n) = self.doc.node_mut(id) {
+                            n.prop_refs.insert("slot".into(), p);
+                        }
+                    }
+                    None => self.warn("slot layers without a matching slot property were imported as frames"),
+                }
+                continue;
+            };
+            let set = self.doc.node(main).and_then(|n| n.parent);
+            let default =
+                name.as_ref().and_then(|p| [Some(main), set].into_iter().flatten().find_map(|o| self.slot_defaults.get(&(o, p.clone())).copied()));
+            let value = name.as_ref().and_then(|p| inst.get("componentProperties")?.get(p)?.get("value"));
+            let own = name.is_some()
+                && match (value, default) {
+                    (Some(v), Some(d)) => v != d,
+                    _ => has_content,
+                };
+            if own && let Some(n) = self.doc.node_mut(id) {
+                n.overrides.insert("slot".into());
+            }
+        }
+    }
+
     /// An instance's property values (variant values are implied by the main it shows).
     fn instance_props(&self, j: &Value) -> BTreeMap<String, Value> {
         let mut out = BTreeMap::new();
@@ -1055,6 +1265,16 @@ fn override_group(field: &str) -> Option<&'static str> {
         | "textDecorationSkipInk"
         | "textDecorationColor" => "textStyle",
         "width" | "height" | "size" => "size",
+        "layoutSizingHorizontal"
+        | "layoutSizingVertical"
+        | "layoutGrow"
+        | "layoutAlign"
+        | "primaryAxisSizingMode"
+        | "counterAxisSizingMode"
+        | "minWidth"
+        | "maxWidth"
+        | "minHeight"
+        | "maxHeight" => "resizing",
         "paddingLeft" | "paddingRight" | "paddingTop" | "paddingBottom" | "horizontalPadding" | "verticalPadding" => "padding",
         "itemSpacing" | "counterAxisSpacing" => "gap",
         "primaryAxisAlignItems" | "counterAxisAlignItems" => "alignment",
@@ -1110,7 +1330,7 @@ fn local(parent: Affine, world: Affine) -> Affine {
 
 /// Finite path data within the coordinate cap.
 /// A vector network in our own JSON shape, when it's within bounds and refers only to what it has.
-fn network(v: &Value) -> Option<VectorNetwork> {
+pub(crate) fn network(v: &Value) -> Option<VectorNetwork> {
     use serde::Deserialize;
     let mut net = VectorNetwork::deserialize(v).ok()?;
     let entries: usize = net.regions.iter().flat_map(|r| &r.loops).map(Vec::len).sum();
diff --git a/crates/format/src/rest/props.rs b/crates/format/src/rest/props.rs
index 67ec8063b..ff06c737e 100644
--- a/crates/format/src/rest/props.rs
+++ b/crates/format/src/rest/props.rs
@@ -5,8 +5,8 @@ use figcraft_doc::color::{BlendMode, Color, ColorStop, Gradient, GradientKind, I
 use figcraft_doc::geom::Affine;
 use figcraft_doc::{
     AutoLayout, Blur, BlurType, CellAlign, ChildLayout, Constraints, ContentAlign, CrossAlign, Effect, EffectKind, ExportFormat, ExportSetting,
-    ExportSize, Glass, GridAlign, GridKind, HConstraint, LayoutGrid, LayoutMode, MainAlign, Noise, NoiseMode, Shadow, Sizing, StrokeAlign, StrokeCap,
-    StrokeJoin, StrokeProps, Texture, VConstraint, WidthPoint, WidthProfile,
+    ExportSize, Glass, GridAlign, GridKind, GridTrack, HConstraint, LayoutGrid, LayoutMode, MainAlign, Noise, NoiseMode, Shadow, Sizing, StrokeAlign,
+    StrokeCap, StrokeJoin, StrokeProps, Texture, VConstraint, WidthPoint, WidthProfile,
 };
 use serde_json::Value;
 
@@ -139,7 +139,7 @@ fn paint(cx: &mut Ctx, p: &Value) -> Option<Paint> {
             return None;
         }
     };
-    Some(Paint { kind, opacity, visible: flag(p, "visible").unwrap_or(true), blend: paint_blend(p) })
+    Some(Paint { kind, opacity, visible: flag(p, "visible").unwrap_or(true), blend: paint_blend(p), color_alpha: false })
 }
 
 /// Gradient handles are already in the node's unit box (start, end, width), like ours.
@@ -178,6 +178,24 @@ fn image(cx: &mut Ctx, p: &Value) -> ImagePaint {
         .filter(|c| c[0].abs() > 1e-9 && c[3].abs() > 1e-9);
     let f = p.get("filters");
     let filter = |k: &str| f.and_then(|f| num(f, k)).unwrap_or(0.0).clamp(-1.0, 1.0) as f32;
+    let filter_fields = ["exposure", "contrast", "saturation", "temperature", "tint", "highlights", "shadows"];
+    let mut has_filters = false;
+    if let Some(filters) = f.and_then(Value::as_object) {
+        for (key, value) in filters {
+            match value.as_f64().filter(|value| value.is_finite()) {
+                Some(value) if filter_fields.contains(&key.as_str()) => has_filters |= value != 0.0,
+                Some(0.0) => {}
+                Some(_) => cx.warn(format!("nonzero unsupported image filter `{}` was skipped", clip_str(key))),
+                None => cx.warn(format!("malformed image filter `{}` was skipped", clip_str(key))),
+            }
+        }
+    } else if f.is_some_and(|filters| !filters.is_null()) {
+        cx.warn("malformed image filters container was skipped");
+    }
+    let fig = cx.fig_sources.is_some();
+    if has_filters && fig {
+        cx.warn("image filters use FigCraft's approximate renderer");
+    }
     ImagePaint {
         image: cx.image_key(text(p, "imageRef").unwrap_or("")),
         scale_mode,
@@ -189,7 +207,9 @@ fn image(cx: &mut Ctx, p: &Value) -> ImagePaint {
             contrast: filter("contrast"),
             saturation: filter("saturation"),
             temperature: filter("temperature"),
-            tint: filter("tint"),
+            // The files' tint runs from green (negative) to magenta (positive), in REST file JSON and
+            // .fig alike; a positive native tint adds green. (`0 - x`: no negative zero.)
+            tint: 0.0 - filter("tint"),
             highlights: filter("highlights"),
             shadows: filter("shadows"),
         },
@@ -394,7 +414,7 @@ pub(super) fn constraints(v: &Value) -> Option<Constraints> {
 // ---- auto layout ----
 
 /// The auto layout of a frame-like node (`layoutMode` other than `NONE`).
-pub(super) fn auto_layout(v: &Value) -> Option<AutoLayout> {
+pub(super) fn auto_layout(v: &Value, fig_tracks: bool) -> Option<AutoLayout> {
     let mode = match text(v, "layoutMode")? {
         "HORIZONTAL" => LayoutMode::Horizontal,
         "VERTICAL" => LayoutMode::Vertical,
@@ -404,6 +424,7 @@ pub(super) fn auto_layout(v: &Value) -> Option<AutoLayout> {
     let pad = |k: &str| len(v, k).unwrap_or(0.0);
     let count = |k: &str, d: u32| num(v, k).filter(|n| *n >= 1.0).map_or(d, |n| n.min(1000.0) as u32);
     let grid = mode == LayoutMode::Grid;
+    let (columns, rows) = (count("gridColumnCount", 2), count("gridRowCount", 2));
     Some(AutoLayout {
         mode,
         wrap: text(v, "layoutWrap") == Some("WRAP"),
@@ -428,14 +449,104 @@ pub(super) fn auto_layout(v: &Value) -> Option<AutoLayout> {
             Some("SPACE_BETWEEN") => ContentAlign::SpaceBetween,
             _ => ContentAlign::Auto,
         },
-        grid_columns: count("gridColumnCount", 2),
-        grid_rows: count("gridRowCount", 2),
+        grid_columns: columns,
+        grid_rows: rows,
         strokes_included: flag(v, "strokesIncludedInLayout").unwrap_or(false),
         reverse_z: flag(v, "itemReverseZIndex").unwrap_or(false),
-        ..AutoLayout::default()
+        column_tracks: grid_tracks(v, grid, fig_tracks, "columnTracks", "gridColumnsSizing", columns),
+        row_tracks: grid_tracks(v, grid, fig_tracks, "rowTracks", "gridRowsSizing", rows),
     })
 }
 
+/// A grid axis's track sizes: from the `.fig` source when there is one, else the API's CSS
+/// `grid-template-*` string (at most `count` tracks, the axis's own).
+fn grid_tracks(v: &Value, grid: bool, fig_tracks: bool, fig_axis: &str, css_key: &str, count: u32) -> Vec<GridTrack> {
+    match (grid, fig_tracks) {
+        (false, _) => Vec::new(),
+        (true, true) => fig_grid_tracks(v, fig_axis),
+        (true, false) => text(v, css_key).map(|css| css_grid_tracks(css, count as usize)).unwrap_or_default(),
+    }
+}
+
+/// The first `max` tracks of a CSS `grid-template-columns`/`-rows` value: `120px`, `2fr`, `auto`
+/// (hug), `minmax(0, 1fr)` and `repeat(3, …)`; any other track is an equal (1fr) one.
+fn css_grid_tracks(css: &str, max: usize) -> Vec<GridTrack> {
+    let mut out = Vec::new();
+    for item in css_split(css, char::is_whitespace) {
+        let repeated = item.strip_prefix("repeat(").and_then(|r| r.strip_suffix(')')).and_then(|r| {
+            let (count, tracks) = r.split_once(',')?;
+            Some((count.trim().parse::<usize>().ok()?, css_split(tracks, char::is_whitespace)))
+        });
+        let (count, tracks) = repeated.unwrap_or((1, vec![item]));
+        for t in tracks.iter().cycle().take(count.saturating_mul(tracks.len())) {
+            if out.len() >= max {
+                return out;
+            }
+            out.push(css_track(t));
+        }
+    }
+    out
+}
+
+fn css_track(t: &str) -> GridTrack {
+    let Some(args) = t.strip_prefix("minmax(").and_then(|r| r.strip_suffix(')')) else { return css_size(t).unwrap_or_default() };
+    // A flexible maximum is the track's share whatever its minimum; other ranges only when both ends agree.
+    match css_split(args, |c| c == ',').iter().map(|a| css_size(a.trim())).collect::<Vec<_>>()[..] {
+        [_, Some(max)] if max.sizing == Sizing::Fill => max,
+        [Some(min), Some(max)] if min == max => min,
+        _ => GridTrack::default(),
+    }
+}
+
+fn css_size(t: &str) -> Option<GridTrack> {
+    let n = |s: &str| s.parse::<f64>().ok().filter(|n| n.is_finite() && (0.0..=MAX_SIZE).contains(n));
+    if let Some(px) = t.strip_suffix("px").and_then(n) {
+        Some(GridTrack::fixed(px))
+    } else if let Some(fr) = t.strip_suffix("fr").and_then(n) {
+        (fr > 0.0).then(|| GridTrack::fill(fr))
+    } else {
+        matches!(t, "auto" | "min-content" | "max-content").then(GridTrack::hug)
+    }
+}
+
+/// `s` split at the `sep` characters outside parentheses, empty parts dropped.
+fn css_split(s: &str, sep: fn(char) -> bool) -> Vec<&str> {
+    let (mut parts, mut depth, mut start) = (Vec::new(), 0usize, 0);
+    for (i, c) in s.char_indices() {
+        match c {
+            '(' => depth += 1,
+            ')' => depth = depth.saturating_sub(1),
+            c if depth == 0 && sep(c) => {
+                parts.extend(s.get(start..i).filter(|p| !p.trim().is_empty()));
+                start = i + c.len_utf8();
+            }
+            _ => {}
+        }
+    }
+    parts.extend(s.get(start..).filter(|p| !p.trim().is_empty()));
+    parts
+}
+
+fn fig_grid_tracks(v: &Value, axis: &str) -> Vec<GridTrack> {
+    v.get(crate::rest::FIG_SOURCE_FIELD)
+        .and_then(|source| source.get("gridTracks"))
+        .and_then(|tracks| tracks.get(axis))
+        .and_then(Value::as_array)
+        .into_iter()
+        .flatten()
+        .take(1_000)
+        .map(|track| {
+            let value = track.get("value").and_then(Value::as_f64).filter(|n| n.is_finite() && (0.0..=MAX_SIZE).contains(n));
+            match (track.get("sizing").and_then(Value::as_str), value) {
+                (Some("fixed"), Some(px)) => GridTrack::fixed(px),
+                (Some("fill"), Some(fr)) if fr > 0.0 => GridTrack::fill(fr),
+                (Some("hug"), _) => GridTrack::hug(),
+                _ => GridTrack::default(),
+            }
+        })
+        .collect()
+}
+
 /// How the node sizes and sits in its parent: its own hug/fixed axes (auto layout frames), its
 /// fill/fixed axes as a child of an auto layout `parent_mode`, absolute positioning, min/max sizes
 /// and grid cells.
@@ -443,8 +554,17 @@ pub(super) fn child_layout(v: &Value, own: Option<LayoutMode>, parent_mode: Opti
     let mut cl = ChildLayout::default();
     let horizontal_main = |m: LayoutMode| m != LayoutMode::Vertical;
     // Legacy fields first, the explicit per-axis sizing wins.
+    // A text's resize mode is its sizing: auto width hugs both axes, auto height its height.
+    if text(v, "type") == Some("TEXT") && v.get("style").and_then(|s| text(s, "textTruncation")) != Some("ENDING") {
+        match v.get("style").and_then(|s| text(s, "textAutoResize")) {
+            Some("WIDTH_AND_HEIGHT") => (cl.sizing_h, cl.sizing_v) = (Sizing::Hug, Sizing::Hug),
+            Some("HEIGHT") => cl.sizing_v = Sizing::Hug,
+            _ => {}
+        }
+    }
     if let Some(m) = own {
-        let hug = |k: &str| text(v, k) == Some("AUTO");
+        // Both default to AUTO (hug) when the file leaves them out.
+        let hug = |k: &str| text(v, k) != Some("FIXED");
         let (main, cross) = (hug("primaryAxisSizingMode"), hug("counterAxisSizingMode"));
         let (h, w) = if horizontal_main(m) { (main, cross) } else { (cross, main) };
         if h {
@@ -550,6 +670,6 @@ pub(super) fn export_settings(v: &Value) -> Vec<ExportSetting> {
 }
 
 /// At most 200 chars of `s` (names and labels from the file stay readable in warnings).
-pub(super) fn clip_str(s: &str) -> &str {
+pub(crate) fn clip_str(s: &str) -> &str {
     s.char_indices().nth(200).and_then(|(i, _)| s.get(..i)).unwrap_or(s)
 }
diff --git a/crates/format/src/rest/slot_tests.rs b/crates/format/src/rest/slot_tests.rs
new file mode 100644
index 000000000..d85d15c62
--- /dev/null
+++ b/crates/format/src/rest/slot_tests.rs
@@ -0,0 +1,229 @@
+//! `SLOT` layers of the REST file JSON: bound to their slot property in a main component, and
+//! holding each instance's own content (synthetic files).
+
+use super::*;
+use serde_json::json;
+
+fn at(x: f64, y: f64) -> Value {
+    json!([[1, 0, x], [0, 1, y]])
+}
+
+pub(crate) fn file(children: Value) -> Value {
+    json!({"name": "Slots", "schemaVersion": 0, "document": {"id": "0:0", "name": "Document", "type": "DOCUMENT", "children": [
+        {"id": "0:1", "name": "Page", "type": "CANVAS", "children": children}
+    ]}})
+}
+
+fn content_id(local: u32) -> Value {
+    json!({"guid": {"sessionID": 5, "localID": local}})
+}
+
+fn slot(id: &str, name: &str, children: Value) -> Value {
+    json!({"id": id, "name": name, "type": "SLOT", "relativeTransform": at(10.0, 40.0), "size": {"x": 280, "y": 100}, "children": children})
+}
+
+fn label(id: &str, text: &str) -> Value {
+    json!({"id": id, "name": text, "type": "TEXT", "characters": text, "relativeTransform": at(0.0, 0.0), "size": {"x": 100, "y": 20}})
+}
+
+/// A "Chip" component (`1:9`), a "Container" component (`1:2`) with a "Title" text and an empty
+/// "Slot" (property `Slot#1:3`, default content 5:1), and the given layers after them.
+pub(crate) fn container_file(more: Vec<Value>) -> Value {
+    let mut layers = vec![
+        json!({"id": "1:9", "name": "Chip", "type": "COMPONENT", "relativeTransform": at(0.0, 400.0), "size": {"x": 40, "y": 20}, "children": [
+            {"id": "1:10", "name": "Dot", "type": "ELLIPSE", "relativeTransform": at(2.0, 2.0), "size": {"x": 16, "y": 16}}
+        ]}),
+        json!({"id": "1:2", "name": "Container", "type": "COMPONENT", "relativeTransform": at(0.0, 0.0), "size": {"x": 300, "y": 160},
+               "componentPropertyDefinitions": {"Slot#1:3": {"type": "SLOT", "defaultValue": content_id(1)}},
+               "children": [label("1:4", "Title"), slot("1:5", "Slot", json!([]))]}),
+    ];
+    layers.extend(more);
+    file(Value::Array(layers))
+}
+
+/// An instance `id` of Container at `x` whose slot holds `content` (property value `value`).
+pub(crate) fn container(id: &str, x: f64, value: Value, content: Value) -> Value {
+    json!({"id": id, "name": "Container", "type": "INSTANCE", "componentId": "1:2", "relativeTransform": at(x, 0.0), "size": {"x": 300, "y": 160},
+           "componentProperties": {"Slot#1:3": {"type": "SLOT", "value": value}},
+           "children": [label(&format!("I{id};1:4"), "Title"), slot(&format!("I{id};1:5"), "Slot", content)]})
+}
+
+pub(crate) fn chip(id: &str) -> Value {
+    json!({"id": id, "name": "Chip", "type": "INSTANCE", "componentId": "1:9", "relativeTransform": at(0.0, 30.0), "size": {"x": 40, "y": 20}, "children": [
+        {"id": format!("I{id};1:10"), "name": "Dot", "type": "ELLIPSE", "relativeTransform": at(2.0, 2.0), "size": {"x": 16, "y": 16}}
+    ]})
+}
+
+fn by_rest<'d>(doc: &'d Document, v: &Value, rest: &str) -> &'d Node {
+    // Names repeat across copies: find by position in the file's tree instead.
+    fn path(v: &Value, rest: &str, out: &mut Vec<usize>) -> bool {
+        if v.get("id").and_then(Value::as_str) == Some(rest) {
+            return true;
+        }
+        for (i, c) in v.get("children").and_then(Value::as_array).into_iter().flatten().enumerate() {
+            out.push(i);
+            if path(c, rest, out) {
+                return true;
+            }
+            out.pop();
+        }
+        false
+    }
+    let mut p = Vec::new();
+    assert!(path(&v["document"]["children"][0], rest, &mut p), "no {rest} in the file");
+    let mut id = doc.pages[0];
+    for i in p {
+        id = doc.node(id).unwrap().children[i];
+    }
+    doc.node(id).unwrap()
+}
+
+fn names(doc: &Document, n: &Node) -> Vec<String> {
+    n.children.iter().map(|c| doc.node(*c).unwrap().name.clone()).collect()
+}
+
+#[test]
+fn slot_layers_bind_to_their_property_and_keep_instance_content() {
+    let v = container_file(vec![
+        container("2:1", 400.0, content_id(7), json!([label("2:2", "Reports in progress"), chip("2:3")])),
+        container("3:1", 800.0, content_id(1), json!([])),
+    ]);
+    let (doc, warnings) = import(&v, &no_images).unwrap();
+    assert!(warnings.iter().all(|w| !w.contains("SLOT") && !w.contains("slot")), "{warnings:?}");
+
+    let main = by_rest(&doc, &v, "1:2");
+    let NodeKind::Component { props, .. } = &main.kind else { panic!("{:?}", main.kind) };
+    assert_eq!(props.get("Slot"), Some(&PropDef::Slot { preferred: Vec::new() }), "named without its #id suffix");
+    let main_slot = by_rest(&doc, &v, "1:5");
+    assert!(matches!(main_slot.kind, NodeKind::Frame));
+    assert_eq!(main_slot.prop_refs.get("slot").map(String::as_str), Some("Slot"));
+    assert!(main_slot.children.is_empty(), "the main's slot stays empty");
+
+    let filled = by_rest(&doc, &v, "I2:1;1:5");
+    assert!(filled.overrides.contains("slot"), "the instance's own content");
+    assert!(filled.prop_refs.is_empty(), "an instance's slot follows its main's");
+    assert_eq!(names(&doc, filled), ["Reports in progress", "Chip"]);
+    let chip = by_rest(&doc, &v, "2:3");
+    assert!(matches!(chip.kind, NodeKind::Instance { .. }), "instances in slot content link to their own main");
+
+    let default = by_rest(&doc, &v, "I3:1;1:5");
+    assert!(!default.overrides.contains("slot"), "the main's default content follows the main");
+}
+
+#[test]
+fn slot_ownership_without_values_follows_the_content() {
+    let mut owned = container("2:1", 400.0, json!(null), json!([label("2:2", "Own")]));
+    owned["componentProperties"] = json!({});
+    let mut empty = container("3:1", 800.0, json!(null), json!([]));
+    empty["componentProperties"] = json!({});
+    let v = container_file(vec![owned, empty]);
+    let (doc, _) = import(&v, &no_images).unwrap();
+    assert!(by_rest(&doc, &v, "I2:1;1:5").overrides.contains("slot"));
+    assert!(!by_rest(&doc, &v, "I3:1;1:5").overrides.contains("slot"));
+}
+
+#[test]
+fn slots_match_by_reference_then_name_then_the_one_left() {
+    let comp = json!({"id": "1:2", "name": "Card", "type": "COMPONENT", "relativeTransform": at(0.0, 0.0), "size": {"x": 300, "y": 300},
+    "componentPropertyDefinitions": {
+        "Header#1:3": {"type": "SLOT", "defaultValue": content_id(1)},
+        "Body#1:4": {"type": "SLOT", "defaultValue": content_id(2)},
+        "Footer#1:5": {"type": "SLOT", "defaultValue": content_id(3)},
+        "Visible#1:6": {"type": "BOOLEAN", "defaultValue": true}
+    },
+    "children": [
+        {"id": "1:7", "name": "Top", "type": "SLOT", "componentPropertyReferences": {"visible": "Visible#1:6", "slot": "Header#1:3"},
+         "relativeTransform": at(0.0, 0.0), "size": {"x": 300, "y": 50}},
+        {"id": "1:8", "name": "Body", "type": "SLOT", "relativeTransform": at(0.0, 50.0), "size": {"x": 300, "y": 50}},
+        {"id": "1:9", "name": "Bottom", "type": "SLOT", "relativeTransform": at(0.0, 100.0), "size": {"x": 300, "y": 50}}
+    ]});
+    let v = file(json!([comp]));
+    let (doc, warnings) = import(&v, &no_images).unwrap();
+    assert!(warnings.is_empty(), "{warnings:?}");
+    let bound = |rest: &str| by_rest(&doc, &v, rest).prop_refs.get("slot").cloned();
+    assert_eq!(bound("1:7").as_deref(), Some("Header"));
+    assert_eq!(by_rest(&doc, &v, "1:7").prop_refs.get("visible").map(String::as_str), Some("Visible"));
+    assert_eq!(bound("1:8").as_deref(), Some("Body"));
+    assert_eq!(bound("1:9").as_deref(), Some("Footer"));
+}
+
+#[test]
+fn variants_share_their_set_slot_property() {
+    let variant = |id: &str, name: &str, x: f64| {
+        json!({"id": id, "name": name, "type": "COMPONENT", "relativeTransform": at(x, 0.0), "size": {"x": 100, "y": 100},
+               "children": [slot(&format!("{id}s"), "Content", json!([]))]})
+    };
+    let set = json!({"id": "1:1", "name": "Panel", "type": "COMPONENT_SET", "relativeTransform": at(0.0, 0.0), "size": {"x": 300, "y": 100},
+        "componentPropertyDefinitions": {"Size": {"type": "VARIANT", "defaultValue": "Small"}, "Content#2:1": {"type": "SLOT", "defaultValue": content_id(1)}},
+        "children": [variant("1:2", "Size=Small", 0.0), variant("1:3", "Size=Large", 150.0)]});
+    let inst = json!({"id": "4:1", "name": "Panel", "type": "INSTANCE", "componentId": "1:3", "relativeTransform": at(0.0, 300.0), "size": {"x": 100, "y": 100},
+        "componentProperties": {"Content#2:1": {"type": "SLOT", "value": content_id(9)}},
+        "children": [slot("I4:1;1:3s", "Content", json!([label("4:2", "Mine")]))]});
+    let v = file(json!([set, inst]));
+    let (doc, warnings) = import(&v, &no_images).unwrap();
+    assert!(warnings.is_empty(), "{warnings:?}");
+    for rest in ["1:2s", "1:3s"] {
+        assert_eq!(by_rest(&doc, &v, rest).prop_refs.get("slot").map(String::as_str), Some("Content"), "{rest}");
+    }
+    assert!(by_rest(&doc, &v, "I4:1;1:3s").overrides.contains("slot"));
+}
+
+#[test]
+fn nested_instances_own_the_slots_of_their_main() {
+    // A "Screen" main places a Container whose slot holds a chip; an instance of Screen places
+    // other content in that nested slot.
+    let screen = json!({"id": "6:1", "name": "Screen", "type": "COMPONENT", "relativeTransform": at(0.0, 600.0), "size": {"x": 300, "y": 160},
+        "children": [container("6:2", 0.0, content_id(7), json!([chip("6:3")]))]});
+    let nested = container("I7:1;6:2", 0.0, content_id(8), json!([label("7:2", "Other")]));
+    let outer = json!({"id": "7:1", "name": "Screen", "type": "INSTANCE", "componentId": "6:1", "relativeTransform": at(400.0, 600.0), "size": {"x": 300, "y": 160},
+        "children": [nested]});
+    let v = container_file(vec![screen, outer]);
+    let (doc, _) = import(&v, &no_images).unwrap();
+    let in_main = by_rest(&doc, &v, "I6:2;1:5");
+    assert!(in_main.overrides.contains("slot") && in_main.prop_refs.is_empty());
+    assert!(matches!(by_rest(&doc, &v, "6:3").kind, NodeKind::Instance { .. }));
+    let in_outer = by_rest(&doc, &v, "II7:1;6:2;1:5");
+    assert!(in_outer.overrides.contains("slot"));
+    assert_eq!(names(&doc, in_outer), ["Other"]);
+}
+
+#[test]
+fn slots_outside_components_or_without_a_property_stay_frames() {
+    let mut no_def = container_file(Vec::new());
+    no_def["document"]["children"][0]["children"][1].as_object_mut().unwrap().remove("componentPropertyDefinitions");
+    let loose = slot("8:1", "Loose", json!([label("8:2", "Kept")]));
+    no_def["document"]["children"][0]["children"].as_array_mut().unwrap().push(loose);
+    let (doc, warnings) = import(&no_def, &no_images).unwrap();
+    assert!(warnings.iter().any(|w| w.starts_with("slot layers without a matching slot property were imported as frames (×2)")), "{warnings:?}");
+    let kept = by_rest(&doc, &no_def, "8:1");
+    assert!(matches!(kept.kind, NodeKind::Frame) && kept.prop_refs.is_empty());
+    assert_eq!(names(&doc, kept), ["Kept"]);
+    assert!(by_rest(&doc, &no_def, "1:5").prop_refs.is_empty());
+}
+
+#[test]
+fn slot_settings_the_editor_cannot_keep_are_noted() {
+    let mut v = container_file(Vec::new());
+    v["document"]["children"][0]["children"][1]["componentPropertyDefinitions"]["Slot#1:3"]["slotSettings"] =
+        json!({"stretchChildOnInsert": true, "displayEmptyByDefault": true, "minChildren": null, "maxChildren": 3});
+    v["document"]["children"][0]["children"][1]["componentPropertyDefinitions"]["Slot#1:3"]["preferredValues"] =
+        json!([{"type": "COMPONENT", "key": "abc"}]);
+    let (_, warnings) = import(&v, &no_images).unwrap();
+    assert!(warnings.iter().any(|w| w == "non-default slot settings are not represented and were skipped"), "{warnings:?}");
+    assert!(warnings.iter().any(|w| w == "preferred slot component keys cannot be resolved to file nodes and were skipped"), "{warnings:?}");
+    let mut plain = container_file(Vec::new());
+    plain["document"]["children"][0]["children"][1]["componentPropertyDefinitions"]["Slot#1:3"]["slotSettings"] =
+        json!({"stretchChildOnInsert": true, "minChildren": null, "maxChildren": null, "allowPreferredValuesOnly": false});
+    assert!(import(&plain, &no_images).unwrap().1.is_empty());
+}
+
+#[test]
+fn junk_slot_json_never_panics() {
+    for junk in [json!(null), json!(1), json!("x"), json!([]), json!({"guid": null}), json!({"type": "SLOT"})] {
+        let mut v = container_file(vec![container("2:1", 400.0, junk.clone(), json!([label("2:2", "A")]))]);
+        v["document"]["children"][0]["children"][1]["componentPropertyDefinitions"]["Slot#1:3"] =
+            json!({"type": "SLOT", "defaultValue": junk.clone(), "slotSettings": junk.clone(), "preferredValues": junk.clone()});
+        v["document"]["children"][0]["children"][1]["children"][1]["componentPropertyReferences"] = json!({"slot": junk});
+        assert!(import(&v, &no_images).is_ok());
+    }
+}
diff --git a/crates/format/src/rest/tests.rs b/crates/format/src/rest/tests.rs
index d7117fd00..1b3f85b6e 100644
--- a/crates/format/src/rest/tests.rs
+++ b/crates/format/src/rest/tests.rs
@@ -186,6 +186,26 @@ fn paints_gradients_and_image_placeholders() {
     assert!(warnings.iter().any(|w| w.starts_with("1 image without image data shows")), "{warnings:?}");
 }
 
+#[test]
+fn image_filter_tint_turns_magenta_positive_into_native_green_positive() {
+    let rect = |name: &str, tint: f64| {
+        json!({
+            "id": name, "name": name, "type": "RECTANGLE", "relativeTransform": at(0.0, 0.0), "size": {"x": 10, "y": 10},
+            "fills": [{"type": "IMAGE", "imageRef": "tint", "filters": {"tint": tint}}]
+        })
+    };
+    let (doc, warnings) = one(json!([rect("Magenta", 0.75), rect("Green", -0.5), rect("Neutral", 0.0)]));
+    let image = |name: &str| {
+        let PaintKind::Image(image) = &named(&doc, name).fills[0].kind else { panic!("{name} is not an image fill") };
+        image
+    };
+    // The same sign as a `.fig` import (`fig::tests::image_filters`).
+    assert!(close(f64::from(image("Magenta").filters.tint), -0.75));
+    assert!(close(f64::from(image("Green").filters.tint), 0.5));
+    assert!(image("Neutral").filters.tint.is_sign_positive(), "no negative zero");
+    assert!(!warnings.iter().any(|w| w.contains("approximate renderer")), "{warnings:?}");
+}
+
 #[test]
 fn image_bytes_come_from_the_resolver() {
     let png = {
@@ -363,6 +383,7 @@ fn auto_layout_constraints_and_grids() {
          ]},
         {"id": "4", "name": "Grid", "type": "FRAME", "relativeTransform": at(200.0, 0.0), "size": {"x": 300, "y": 200},
          "layoutMode": "GRID", "gridColumnCount": 3, "gridRowCount": 2, "gridColumnGap": 4, "gridRowGap": 6,
+         "_figSource": {"gridTracks": {"columnTracks": [{"sizing": "fixed", "value": 120}] }},
          "children": [{"id": "5", "name": "Cell", "type": "RECTANGLE", "relativeTransform": at(0.0, 0.0), "size": {"x": 10, "y": 10},
                        "gridColumnAnchorIndex": 1, "gridRowAnchorIndex": 0, "gridColumnSpan": 2, "gridRowSpan": 1}]}
     ]));
@@ -389,6 +410,7 @@ fn auto_layout_constraints_and_grids() {
     assert_eq!((abs.constraints.horizontal, abs.constraints.vertical), (HConstraint::LeftRight, VConstraint::Bottom));
     let grid = named(&doc, "Grid").layout.clone().unwrap();
     assert_eq!((grid.mode, grid.grid_columns, grid.grid_rows, grid.gap, grid.cross_gap), (LayoutMode::Grid, 3, 2, 4.0, 6.0));
+    assert!(grid.column_tracks.is_empty(), "private .fig track metadata is ignored by the public REST importer");
     let cell = &named(&doc, "Cell").child_layout;
     assert_eq!((cell.grid_column, cell.grid_row, cell.grid_column_span, cell.grid_row_span), (Some(1), Some(0), 2, 1));
 }
@@ -707,3 +729,18 @@ fn layer_count_is_capped() {
     assert_eq!(doc.node_count(), MAX_NODES + 1);
     assert!(warnings.iter().any(|w| w.contains("more than")), "{warnings:?}");
 }
+
+#[test]
+fn the_fig_import_sets_its_own_layer_cap() {
+    // The `.fig` import passes a cap from the file's size: above `MAX_NODES` every layer comes in.
+    let kids: Vec<Value> = (0..MAX_NODES + 5).map(|i| json!({"id": i.to_string(), "type": "RECTANGLE", "name": "R"})).collect();
+    let json = file(json!([page("Page", Value::Array(kids))]));
+    let (doc, warnings) = import_with_networks(&json, &no_images, Vec::new(), MAX_NODES + 10).unwrap();
+    assert_eq!(doc.node_count(), MAX_NODES + 6);
+    assert!(!warnings.iter().any(|w| w.contains("more than")), "{warnings:?}");
+    // Below it, the import stops at the cap it was given.
+    let few: Vec<Value> = (0..10).map(|i| json!({"id": i.to_string(), "type": "RECTANGLE", "name": "R"})).collect();
+    let (doc, warnings) = import_with_networks(&file(json!([page("Page", Value::Array(few))])), &no_images, Vec::new(), 4).unwrap();
+    assert_eq!(doc.node_count(), 5);
+    assert!(warnings.iter().any(|w| w.contains("more than 4 layers")), "{warnings:?}");
+}
diff --git a/crates/format/src/rest/text.rs b/crates/format/src/rest/text.rs
index c5381bb2e..367677a6f 100644
--- a/crates/format/src/rest/text.rs
+++ b/crates/format/src/rest/text.rs
@@ -5,7 +5,7 @@ use std::collections::BTreeMap;
 
 use figcraft_doc::{
     DecorationLength, DecorationStyle, LetterSpacing, LineHeight, ListStyle, ParaList, StyleRun, TextAlignH, TextAlignV, TextAutoResize, TextCase,
-    TextData, TextDecoration, TextStyle,
+    TextData, TextDecoration, TextPath, TextStyle,
 };
 use serde_json::Value;
 
@@ -27,8 +27,25 @@ pub(super) fn text_data(cx: &mut Ctx, v: &Value) -> TextData {
     let mut td = TextData { characters, style: base, ..TextData::default() };
     paragraph(style_json, &mut td);
     td.runs = runs(cx, v, &td);
+    // Skip ink only shows on an underline. A file can carry it on any text, so elsewhere it stays out
+    // of the look (runs have inherited the base value by now).
+    for st in std::iter::once(&mut td.style).chain(td.runs.iter_mut().map(|r| &mut r.style)) {
+        if st.decoration != TextDecoration::Underline && st.look().skip_ink {
+            st.set_look(|l| l.skip_ink = false);
+        }
+    }
     td.normalize();
     lists(v, &mut td);
+    if cx.fig_sources.is_some()
+        && let Some(path) = v.get("_figTextPath")
+    {
+        match (path.get("d").and_then(Value::as_str), path.get("start").and_then(Value::as_f64), path.get("flip").and_then(Value::as_bool)) {
+            (Some(d), Some(start), Some(flip)) if !d.is_empty() && start.is_finite() && (0.0..=1.0).contains(&start) => {
+                td.path = Some(Box::new(TextPath { d: d.to_owned(), start, flip }));
+            }
+            _ => cx.warn("invalid internal .fig text path data was ignored"),
+        }
+    }
     td
 }
 
@@ -106,6 +123,12 @@ fn type_style(cx: &mut Ctx, s: &Value, base: &TextStyle) -> TextStyle {
     if let Some(ls) = num(s, "letterSpacing") {
         t.letter_spacing = if ls == 0.0 { LetterSpacing::default() } else { LetterSpacing::Pixels(ls.clamp(-1e4, 1e4)) };
     }
+    // Private, from the .fig mapper: the spacing was a share of the font size.
+    if cx.fig_sources.is_some()
+        && let Some(p) = num(s, "_letterSpacingPercent")
+    {
+        t.letter_spacing = LetterSpacing::Percent(p.clamp(-1e4, 1e4));
+    }
     match text(s, "textCase") {
         Some("ORIGINAL") => t.case = TextCase::Original,
         Some("UPPER") => t.case = TextCase::Upper,
@@ -210,10 +233,12 @@ fn runs(cx: &mut Ctx, v: &Value, td: &TextData) -> Vec<StyleRun> {
     out
 }
 
-/// Each paragraph's list type and nesting level from `lineTypes` and `lineIndentations`.
+/// Each paragraph's list type, nesting level and start number from `lineTypes`,
+/// `lineIndentations` and (from `.fig` files) `listStartOffsets`.
 fn lists(v: &Value, td: &mut TextData) {
     let types = list(v, "lineTypes");
     let indents = list(v, "lineIndentations");
+    let starts = list(v, "listStartOffsets");
     td.paragraphs = types
         .iter()
         .enumerate()
@@ -224,6 +249,7 @@ fn lists(v: &Value, td: &mut TextData) {
                 _ => ListStyle::None,
             },
             indent: indents.get(i).and_then(Value::as_f64).filter(|d| d.is_finite()).map_or(0, |d| d.clamp(0.0, 255.0) as u8),
+            start_offset: starts.get(i).and_then(Value::as_f64).filter(|n| n.is_finite()).map_or(0, |n| n.clamp(0.0, f64::from(u32::MAX)) as u32),
         })
         .collect();
     // Clamp the levels and fold one style for all back into the layer's list style.
diff --git a/crates/format/src/rest/variables.rs b/crates/format/src/rest/variables.rs
index 91d14001c..d58da409b 100644
--- a/crates/format/src/rest/variables.rs
+++ b/crates/format/src/rest/variables.rs
@@ -27,6 +27,16 @@ pub fn source(v: &Value) -> Option<&Value> {
     [v.get("meta"), Some(v)].into_iter().flatten().find(|m| m.get("variableCollections").is_some_and(Value::is_object))
 }
 
+/// The variable ids the collections of a local variables response list in `variableIds`.
+pub(super) fn listed_ids(v: &Value) -> BTreeSet<&str> {
+    source(v)
+        .into_iter()
+        .flat_map(|src| objects(src, "variableCollections", MAX_COLLECTIONS))
+        .flat_map(|(_, c)| list(c, "variableIds").iter().filter_map(Value::as_str).map(clip_str))
+        .take(MAX_VARIABLES)
+        .collect()
+}
+
 pub(super) fn kind_of(t: &str) -> Option<VariableType> {
     Some(match t {
         "COLOR" => VariableType::Color,
@@ -118,14 +128,18 @@ fn objects<'v>(v: &'v Value, key: &str, max: usize) -> impl Iterator<Item = (&'v
 }
 
 impl Ctx<'_> {
-    /// Add the collections and variables of a local variables response (or its `meta`).
-    pub(super) fn variables(&mut self, src: &Value) {
+    /// Add the collections and variables of a local variables response (or its `meta`); nothing
+    /// when `v` isn't one. The `variables` map is read next to `variableCollections`, or from
+    /// `meta` or the top level when it sits on the other side.
+    pub(super) fn variables(&mut self, v: &Value) {
+        let Some(src) = source(v) else { return };
         for (key, c) in objects(src, "variableCollections", MAX_COLLECTIONS) {
             self.collection(key, c);
         }
+        let holder = [Some(src), v.get("meta"), Some(v)].into_iter().flatten().find(|m| m.get("variables").is_some_and(Value::is_object));
         let mut found: Vec<Variable> = Vec::new();
         let mut seen: BTreeSet<String> = BTreeSet::new();
-        for (key, v) in objects(src, "variables", MAX_VARIABLES) {
+        for (key, v) in holder.into_iter().flat_map(|h| objects(h, "variables", MAX_VARIABLES)) {
             if let Some(var) = self.variable(key, v)
                 && seen.insert(var.id.clone())
             {
diff --git a/crates/format/src/thumbnail.rs b/crates/format/src/thumbnail.rs
index a5e7e2b34..76ebcf4e3 100644
--- a/crates/format/src/thumbnail.rs
+++ b/crates/format/src/thumbnail.rs
@@ -109,6 +109,8 @@ pub fn file_thumbnail(path: &Path, fit: u32) -> Option<Thumbnail> {
 pub struct Preview {
     pub page: Option<[f32; 4]>,
     pub picture: Option<Thumbnail>,
+    /// A design file or a board (`.fig` files and images: design).
+    pub kind: figcraft_doc::FileKind,
 }
 
 /// The [`Preview`] of the file at `path`, its picture at most `fit` pixels on its longer side.
@@ -119,7 +121,7 @@ pub fn file_preview(path: &Path, fit: u32) -> Preview {
             let Ok(file) = std::fs::File::open(path) else { return Preview::default() };
             archive_preview(std::io::BufReader::new(file), fit)
         }
-        FileKind::Image => Preview { page: None, picture: file_thumbnail(path, fit) },
+        FileKind::Image => Preview { picture: file_thumbnail(path, fit), ..Preview::default() },
         FileKind::Svg | FileKind::Other => Preview::default(),
     }
 }
@@ -129,31 +131,33 @@ pub fn file_preview(path: &Path, fit: u32) -> Preview {
 pub fn archive_preview<R: Read + Seek>(archive: R, fit: u32) -> Preview {
     let Ok(mut z) = zip::ZipArchive::new(archive) else { return Preview::default() };
     let picture = crate::read_member(&mut z, "thumbnail.png", MAX_THUMBNAIL_BYTES).ok().and_then(|png| decode_thumbnail(&png, fit));
-    let page = if z.file_names().any(|n| n == "document.json") {
-        crate::read_member(&mut z, "document.json", MAX_DOCUMENT_BYTES).ok().and_then(|json| figcraft_page(&json))
+    let (page, kind) = if z.file_names().any(|n| n == "document.json") {
+        crate::read_member(&mut z, "document.json", MAX_DOCUMENT_BYTES).ok().map(|json| figcraft_page(&json)).unwrap_or_default()
     } else {
-        crate::read_member(&mut z, "meta.json", MAX_META_BYTES).ok().and_then(|json| fig_page(&json))
+        (crate::read_member(&mut z, "meta.json", MAX_META_BYTES).ok().and_then(|json| fig_page(&json)), figcraft_doc::FileKind::Design)
     };
-    Preview { page, picture }
+    Preview { page, picture, kind }
 }
 
-/// The first page's background in a `.figcraft` `document.json`.
-fn figcraft_page(json: &[u8]) -> Option<[f32; 4]> {
+/// The first page's background in a `.figcraft` `document.json`, and the file's kind.
+fn figcraft_page(json: &[u8]) -> (Option<[f32; 4]>, figcraft_doc::FileKind) {
     #[derive(serde::Deserialize)]
     struct Head {
         #[serde(default)]
         pages: Vec<u64>,
         #[serde(default)]
         nodes: std::collections::BTreeMap<String, Node>,
+        #[serde(default)]
+        kind: figcraft_doc::FileKind,
     }
     #[derive(serde::Deserialize)]
     struct Node {
         #[serde(default)]
         background: Option<serde_json::Value>,
     }
-    let head: Head = serde_json::from_slice(json).ok()?;
-    let first = head.pages.first()?;
-    rgba(head.nodes.get(&first.to_string())?.background.as_ref()?)
+    let Ok(head) = serde_json::from_slice::<Head>(json) else { return (None, figcraft_doc::FileKind::Design) };
+    let page = head.pages.first().and_then(|first| head.nodes.get(&first.to_string())).and_then(|n| n.background.as_ref()).and_then(rgba);
+    (page, head.kind)
 }
 
 /// The canvas colour a `.fig` file's `meta.json` gives (`client_meta.background_color`).
diff --git a/crates/format/src/thumbnail_tests.rs b/crates/format/src/thumbnail_tests.rs
index 864c0f249..eeaeaba59 100644
--- a/crates/format/src/thumbnail_tests.rs
+++ b/crates/format/src/thumbnail_tests.rs
@@ -148,7 +148,12 @@ fn previews_carry_the_first_pages_colour() {
     assert!(p.picture.is_some());
     // A file with nothing on it: its colour, no picture.
     let bytes = crate::save_bytes(&doc_on([0.9, 0.9, 0.9]), None).unwrap();
-    assert_eq!(archive_preview(Cursor::new(&bytes), 640), Preview { page: Some([0.9, 0.9, 0.9, 1.0]), picture: None });
+    assert_eq!(archive_preview(Cursor::new(&bytes), 640), Preview { page: Some([0.9, 0.9, 0.9, 1.0]), picture: None, kind: Default::default() });
+    // A board says so (the home screen marks it).
+    let mut board = doc_on([0.9, 0.9, 0.9]);
+    board.kind = figcraft_doc::FileKind::Board;
+    let bytes = crate::save_bytes(&board, None).unwrap();
+    assert_eq!(archive_preview(Cursor::new(&bytes), 640).kind, figcraft_doc::FileKind::Board);
     // Damaged or odd metadata: no colour, never a panic.
     for meta in [&b"{"[..], b"{\"client_meta\":{\"background_color\":{\"r\":\"x\",\"g\":0,\"b\":0}}}", b"[]", b"{\"client_meta\":7}"] {
         assert_eq!(archive_preview(Cursor::new(zip(&[("meta.json", meta)])), 640).page, None, "{}", String::from_utf8_lossy(meta));
diff --git a/crates/format/tests/it/distributed_alignment.rs b/crates/format/tests/it/distributed_alignment.rs
new file mode 100644
index 000000000..bcf8a52df
--- /dev/null
+++ b/crates/format/tests/it/distributed_alignment.rs
@@ -0,0 +1,24 @@
+//! FIG export + import keeps all three distributed main-axis alignments distinct.
+
+use figcraft_doc::{AutoLayout, Document, MainAlign, NodeKind};
+use figcraft_format::fig;
+
+#[test]
+fn distributed_alignment_round_trip() {
+    let mut results = Vec::new();
+    for expected in [MainAlign::SpaceBetween, MainAlign::SpaceAround, MainAlign::SpaceEvenly] {
+        let mut doc = Document::new("Alignment");
+        let page = doc.first_page().unwrap();
+        let frame = doc.create(page, NodeKind::Frame, "Frame", 0.0, 0.0, 200.0, 40.0).unwrap();
+        doc.node_mut(frame).unwrap().layout = Some(AutoLayout { main_align: expected, ..Default::default() });
+        let (native, _) = figcraft_format::load_bytes(&figcraft_format::save_bytes(&doc, None).unwrap()).unwrap();
+        assert_eq!(native.node(frame).unwrap().layout.as_ref().unwrap().main_align, expected);
+        let (bytes, export_warnings) = fig::export(&doc, None).unwrap();
+        let (imported, import_warnings) = fig::import(&bytes, "Alignment").unwrap();
+        let actual = imported.nodes().find(|n| n.name == "Frame").unwrap().layout.as_ref().unwrap().main_align;
+        assert!(export_warnings.is_empty());
+        assert!(import_warnings.is_empty());
+        results.push((expected, actual));
+    }
+    assert!(results.iter().all(|(expected, actual)| expected == actual), "{results:?}");
+}
diff --git a/crates/format/tests/import_link_contract.rs b/crates/format/tests/it/import_link_contract.rs
similarity index 100%
rename from crates/format/tests/import_link_contract.rs
rename to crates/format/tests/it/import_link_contract.rs
diff --git a/crates/format/tests/it/main.rs b/crates/format/tests/it/main.rs
new file mode 100644
index 000000000..6286e8db1
--- /dev/null
+++ b/crates/format/tests/it/main.rs
@@ -0,0 +1,5 @@
+//! The crate's integration tests, built as one test binary.
+
+mod distributed_alignment;
+mod import_link_contract;
+mod range_hyperlink_round_trip;
diff --git a/crates/format/tests/range_hyperlink_round_trip.rs b/crates/format/tests/it/range_hyperlink_round_trip.rs
similarity index 100%
rename from crates/format/tests/range_hyperlink_round_trip.rs
rename to crates/format/tests/it/range_hyperlink_round_trip.rs
diff --git a/crates/geom/src/lib.rs b/crates/geom/src/lib.rs
index da351e5bb..e0a4dde06 100644
--- a/crates/geom/src/lib.rs
+++ b/crates/geom/src/lib.rs
@@ -284,7 +284,9 @@ impl ReverseSubpaths for BezPath {
                     kurbo::PathSeg::Cubic(c) => out.curve_to(c.p1, c.p2, c.p3),
                 }
             }
-            out.close_path();
+            if matches!(seg_path.elements().last(), Some(kurbo::PathEl::ClosePath)) {
+                out.close_path();
+            }
         }
         out
     }
diff --git a/crates/geom/src/tests.rs b/crates/geom/src/tests.rs
index b99d7d8c3..15e24d494 100644
--- a/crates/geom/src/tests.rs
+++ b/crates/geom/src/tests.rs
@@ -108,3 +108,18 @@ fn set_rotation_keeps_center() {
         }
     }
 }
+
+#[test]
+fn reverse_subpaths_preserves_open_and_closed() {
+    let mut open = BezPath::new();
+    open.move_to((0.0, 0.0));
+    open.line_to((10.0, 0.0));
+    open.line_to((10.0, 10.0));
+    let r = <BezPath as ReverseSubpaths>::reverse_subpaths(&open);
+    assert!(!r.elements().iter().any(|e| matches!(e, kurbo::PathEl::ClosePath)), "{:?}", r.elements());
+
+    let mut closed = open.clone();
+    closed.close_path();
+    let r = <BezPath as ReverseSubpaths>::reverse_subpaths(&closed);
+    assert!(matches!(r.elements().last(), Some(kurbo::PathEl::ClosePath)), "{:?}", r.elements());
+}
diff --git a/crates/mcp/src/backend.rs b/crates/mcp/src/backend.rs
index 1d42bdb44..f2021cc6c 100644
--- a/crates/mcp/src/backend.rs
+++ b/crates/mcp/src/backend.rs
@@ -22,10 +22,9 @@ pub trait Backend {
     fn describe(&self) -> String;
 
     /// PNG bytes of the document: `ids` (in page coordinates, their union) or, when empty, the
-    /// current page's content. The default goes through `ui.render` and a temporary file.
+    /// current page's content. The default goes through `ui.render`, the PNG coming back as data.
     fn render_png(&mut self, ids: &[u64], scale: f64) -> Result<Vec<u8>, String> {
-        let path = temp_png("render");
-        let mut params = json!({"path": path, "scale": scale});
+        let mut params = json!({"scale": scale});
         if !ids.is_empty() {
             params["ids"] = json!(ids);
         } else {
@@ -36,8 +35,7 @@ pub trait Backend {
             }
             params["ids"] = json!(kids);
         }
-        self.call("ui.render", params)?;
-        read_and_remove(&path)
+        decode_data(&self.call("ui.render", params)?)
     }
 
     /// PNG bytes of what the user sees: the app window when attached, the current viewport when
@@ -52,11 +50,10 @@ pub trait Backend {
     }
 }
 
-fn capture<B: Backend + ?Sized>(b: &mut B, mut params: Value) -> Result<Vec<u8>, String> {
-    let path = temp_png("screenshot");
-    params["path"] = json!(path);
-    b.call("ui.screenshot", params)?;
-    read_and_remove(&path)
+/// A window capture, the PNG coming back as data (no file: an app confined to automation roots
+/// writes none outside them).
+fn capture<B: Backend + ?Sized>(b: &mut B, params: Value) -> Result<Vec<u8>, String> {
+    decode_data(&b.call("ui.screenshot", params)?)
 }
 
 /// The ids of the current page's top-level layers.
@@ -72,17 +69,6 @@ pub fn page_children<B: Backend + ?Sized>(b: &mut B) -> Result<Vec<u64>, String>
         .unwrap_or_default())
 }
 
-fn temp_png(what: &str) -> String {
-    let n = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_nanos()).unwrap_or(0);
-    std::env::temp_dir().join(format!("figcraft-mcp-{what}-{}-{n}.png", std::process::id())).to_string_lossy().into_owned()
-}
-
-fn read_and_remove(path: &str) -> Result<Vec<u8>, String> {
-    let bytes = std::fs::read(path).map_err(|e| format!("{path}: {e}"))?;
-    let _ = std::fs::remove_file(path);
-    Ok(bytes)
-}
-
 /// Decode a `data` field (base64, optionally a data: URL) from an export result.
 pub fn decode_data(v: &Value) -> Result<Vec<u8>, String> {
     let d = v.get("data").and_then(Value::as_str).ok_or("the export returned no data")?;
diff --git a/crates/mcp/src/headless.rs b/crates/mcp/src/headless.rs
index 802a865dc..fcdb21a35 100644
--- a/crates/mcp/src/headless.rs
+++ b/crates/mcp/src/headless.rs
@@ -160,7 +160,7 @@ impl Headless {
                     self.execute("text.edit.begin", &json!({"id": self.single_text()}))?;
                 }
                 "select.children" if self.session.tool.pen.is_some() => {
-                    let _ = self.session.pen_finish();
+                    let _ = self.session.pen_end();
                 }
                 // Enter on shapes edits them as vectors (several at once).
                 "select.children" if self.vector_targets().is_some() => {
@@ -215,7 +215,7 @@ impl Headless {
         let (w, h) = crate::png_size(&bytes).unwrap_or((0, 0));
         match p.get("path").and_then(Value::as_str) {
             Some(path) => {
-                std::fs::write(path, &bytes).map_err(|e| format!("{path}: {e}"))?;
+                figcraft_engine::file_access::write(path, &bytes).map_err(|e| e.to_string())?;
                 Ok(json!({"path": path, "width": w, "height": h, "bytes": bytes.len()}))
             }
             None => Ok(json!({"format": "png", "width": w, "height": h, "data": base64::engine::general_purpose::STANDARD.encode(&bytes)})),
@@ -278,7 +278,7 @@ impl Backend for Headless {
                 let (w, h) = crate::png_size(&bytes).unwrap_or((0, 0));
                 match p.get("path").and_then(Value::as_str) {
                     Some(path) => {
-                        std::fs::write(path, &bytes).map_err(|e| format!("{path}: {e}"))?;
+                        figcraft_engine::file_access::write(path, &bytes).map_err(|e| e.to_string())?;
                         Ok(json!({"path": path, "width": w, "height": h}))
                     }
                     None => Ok(json!({"format": "png", "width": w, "height": h, "data": base64::engine::general_purpose::STANDARD.encode(&bytes)})),
diff --git a/crates/mcp/src/server.rs b/crates/mcp/src/server.rs
index 365c8579a..aad3530eb 100644
--- a/crates/mcp/src/server.rs
+++ b/crates/mcp/src/server.rs
@@ -1,6 +1,9 @@
 //! JSON-RPC 2.0 framing and the MCP lifecycle / tools / resources / prompts methods.
 
 use std::io::{BufRead, Read, Write};
+use std::sync::Arc;
+
+use figcraft_engine::file_access::{Roots, confined};
 
 use serde_json::{Value, json};
 
@@ -42,6 +45,9 @@ Resources: figcraft://document, figcraft://node/{id}, figcraft://command/{id}. p
 pub struct Server {
     backend: Box<dyn Backend>,
     initialized: bool,
+    /// The automation roots every request's file access is confined to (`--automation-read-root`,
+    /// `--automation-write-root`), if any.
+    roots: Option<Arc<Roots>>,
 }
 
 fn response(id: Value, result: Value) -> Value {
@@ -58,7 +64,14 @@ fn panic_message(payload: &(dyn std::any::Any + Send)) -> String {
 
 impl Server {
     pub fn new(backend: Box<dyn Backend>) -> Self {
-        Self { backend, initialized: false }
+        Self { backend, initialized: false, roots: None }
+    }
+
+    /// Confine the files every request reads and writes to `roots` (see
+    /// [`figcraft_engine::file_access`]).
+    pub fn with_roots(mut self, roots: Option<Roots>) -> Self {
+        self.roots = roots.map(Arc::new);
+        self
     }
 
     /// A server over a fresh headless session.
@@ -150,15 +163,23 @@ impl Server {
             return Some(error(id, INVALID_PARAMS, "`params` must be an object"));
         }
         // A bug that panics fails this request only; the server keeps serving.
-        let r = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| self.request(method, &params))).unwrap_or_else(|p| {
-            Err((INTERNAL_ERROR, format!("internal error in `{method}`: {} (please report this bug)", panic_message(p.as_ref()))))
-        });
+        let roots = self.roots.clone();
+        let r = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| confined(roots.as_ref(), || self.request(method, &params)))).unwrap_or_else(
+            |p| Err((INTERNAL_ERROR, format!("internal error in `{method}`: {} (please report this bug)", panic_message(p.as_ref())))),
+        );
         Some(match r {
             Ok(r) => response(id, r),
             Err((code, m)) => error(id, code, m),
         })
     }
 
+    /// What `initialize` says about the automation roots.
+    fn roots_note(&self) -> String {
+        let Some(r) = &self.roots else { return String::new() };
+        let j = r.to_json();
+        format!(" Files: only these folders may be read: {}; written: {} (any other path is refused).", j["read"], j["write"])
+    }
+
     fn notification(&mut self, method: &str) {
         match method {
             "notifications/initialized" => self.initialized = true,
@@ -180,7 +201,7 @@ impl Server {
                         "prompts": {"listChanged": false},
                     },
                     "serverInfo": {"name": "figcraft", "title": "FigCraft", "version": env!("CARGO_PKG_VERSION")},
-                    "instructions": format!("{INSTRUCTIONS} Backend: {}.", self.backend.describe()),
+                    "instructions": format!("{INSTRUCTIONS} Backend: {}.{}", self.backend.describe(), self.roots_note()),
                 }))
             }
             "ping" => Ok(json!({})),
diff --git a/crates/mcp/src/tools.rs b/crates/mcp/src/tools.rs
index 49fd272fd..7714da5a3 100644
--- a/crates/mcp/src/tools.rs
+++ b/crates/mcp/src/tools.rs
@@ -147,7 +147,7 @@ pub fn tool_definitions() -> Vec<Value> {
                     "type": {"type": "string", "enum": ["frame", "rectangle", "ellipse", "polygon", "star", "line", "arrow", "text", "vector", "section", "component", "slice"], "description": "Layer type"},
                     "x": num("Left, relative to the parent frame (default 0)"),
                     "y": num("Top, relative to the parent frame (default 0)"),
-                    "width": num("Width (default 100; text hugs its content unless width is set, which makes it wrap)"),
+                    "width": num("Width (default 100; text hugs its content unless width is set, which makes it wrap; for a vector with path, width/height scale the path, one alone keeping its proportion, and without them the path's own box is used)"),
                     "height": num("Height (default 100; ignored for lines/arrows and auto-height text)"),
                     "parent": id_schema("Parent frame/group/component id (default: the current page)"),
                     "index": int("Z-index among the parent's children (default: on top)"),
@@ -163,7 +163,7 @@ pub fn tool_definitions() -> Vec<Value> {
         tool(
             "set_properties",
             "Set properties",
-            "Set properties on one or more layers as one undo step (engine `node.set`). Keys: name, visible, locked, opacity (0-1), blend, x, y (relative to the parent frame; groups don't count), width, height, rotation (degrees), fill (colour) / fills (array of paints: \"#hex\" or {\"type\":\"solid\",\"color\":\"#hex\"} or {\"type\":\"linearGradient\",\"stops\":[\"#hex\",\"#hex\"]} or stops [{\"position\":0..1,\"color\":\"#hex\"}], optional from/to handles in the unit box; radialGradient too), stroke / strokes, strokeWeight, strokeAlign (inside|center|outside), cornerRadius (n or [tl,tr,br,bl]), effects (array, e.g. {\"type\":\"dropShadow\",\"color\":\"#00000040\",\"offset\":[0,4],\"radius\":8}), clip, layout (null|horizontal|vertical|grid), gap, padding (n or [t,r,b,l]), mainAlign (min|center|max|spaceBetween|spaceAround|spaceEvenly), crossAlign, wrap, contentAlign (auto|spaceBetween: wrapped lines), sizingH / sizingV (fixed|hug|fill), constraints {horizontal, vertical}, characters, fontFamily, fontStyle, fontSize, lineHeight, letterSpacing, textAlign, textAutoResize. Run list_commands with filter \"node.set\" for the full list. Unknown keys are an error. Returns the updated layers.",
+            "Set properties on one or more layers as one undo step (engine `node.set`). Keys: name, visible, locked, opacity (0-1), blend, x, y (relative to the parent frame; groups don't count), width, height, rotation (degrees), fill (colour) / fills (array of paints: \"#hex\" or {\"type\":\"solid\",\"color\":\"#hex\"} or {\"type\":\"linearGradient\",\"stops\":[\"#hex\",\"#hex\"]} or stops [{\"position\":0..1,\"color\":\"#hex\"}], optional from/to handles in the unit box; radialGradient too), stroke / strokes, strokeWeight, strokeAlign (inside|center|outside), cornerRadius (n or [tl,tr,br,bl]), effects (array, e.g. {\"type\":\"dropShadow\",\"color\":\"#00000040\",\"offset\":[0,4],\"radius\":8}), clip, layout (null|horizontal|vertical|grid), gap, padding (n or [t,r,b,l]), mainAlign (min|center|max|spaceBetween|spaceAround|spaceEvenly), crossAlign, wrap, contentAlign (auto|spaceBetween: wrapped lines), sizingH / sizingV (fixed|hug|fill), constraints {horizontal, vertical}, characters, fontFamily, fontStyle, fontSize, lineHeight, letterSpacing, textAlign, textAutoResize. Auto layout keys (gap, padding, mainAlign, crossAlign, wrap, …) apply to frames, components and instances only: other layers among the ids are skipped and named in `warnings`, and with none that can take them the call is an error. A fontStyle draws in the family's nearest face; `warnings` says when that face has another weight or slant than the name asks for. Run list_commands with filter \"node.set\" for the full list. Unknown keys are an error. Returns the updated layers.",
             obj(
                 json!({"ids": ids_schema("Layer ids (default: the selection)"), "props": {"type": "object", "description": "Property values to set"}}),
                 &["props"],
@@ -250,8 +250,8 @@ pub fn tool_definitions() -> Vec<Value> {
         tool(
             "save_file",
             "Save file",
-            "Save the active document as a .figcraft file. `path` is required the first time (an untitled document has no path); later saves reuse it.",
-            obj(json!({"path": string("Output .figcraft path")}), &[]),
+            "Save the active document as a .figcraft file. `path` is required the first time (an untitled document has no path); later saves reuse it. A `path` ending in .fig writes an experimental .fig export copy instead and leaves the document's own path and unsaved changes alone.",
+            obj(json!({"path": string("Output .figcraft path, or a .fig path for an experimental export copy")}), &[]),
             false,
         ),
         tool("undo", "Undo", "Undo the last change (one command, batch or gesture). Returns {undone: bool}.", empty(), false),
@@ -544,7 +544,7 @@ fn set_properties(b: &mut dyn Backend, a: &Map<String, Value>) -> Result<ToolRes
         }
         params["ids"] = json!(ids);
     }
-    exec(b, "node.set", params)?;
+    let warnings = exec(b, "node.set", params)?.get("warnings").cloned();
     let ids = match ids {
         Some(i) => i,
         None => b
@@ -555,7 +555,11 @@ fn set_properties(b: &mut dyn Backend, a: &Map<String, Value>) -> Result<ToolRes
             .unwrap_or_default(),
     };
     let nodes: Vec<Value> = ids.iter().take(20).filter_map(|i| b.call("node.get", json!({"id": i, "depth": 0})).ok()).collect();
-    Ok(ToolResult::json(&json!({"ok": true, "nodes": nodes})))
+    let mut out = json!({"ok": true, "nodes": nodes});
+    if let Some(w) = warnings {
+        out["warnings"] = w;
+    }
+    Ok(ToolResult::json(&out))
 }
 
 fn inspect_document(b: &mut dyn Backend, a: &Map<String, Value>) -> Result<ToolResult, String> {
diff --git a/crates/mcp/tests/agent_tasks.rs b/crates/mcp/tests/it/agent_tasks.rs
similarity index 99%
rename from crates/mcp/tests/agent_tasks.rs
rename to crates/mcp/tests/it/agent_tasks.rs
index b35f3e7fd..b83fc3b8f 100644
--- a/crates/mcp/tests/agent_tasks.rs
+++ b/crates/mcp/tests/it/agent_tasks.rs
@@ -1,8 +1,7 @@
 //! End-to-end agent tasks: an in-process MCP client completes realistic design tasks only through
 //! MCP tool calls, and checks every result through inspect_document / get_node like an agent would.
-#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
 
-mod common;
+use crate::common;
 
 use common::{Client, approx, png_dims};
 use serde_json::{Value, json};
diff --git a/crates/mcp/tests/attached.rs b/crates/mcp/tests/it/attached.rs
similarity index 99%
rename from crates/mcp/tests/attached.rs
rename to crates/mcp/tests/it/attached.rs
index 69194604e..f1343dd25 100644
--- a/crates/mcp/tests/attached.rs
+++ b/crates/mcp/tests/it/attached.rs
@@ -1,6 +1,5 @@
 //! The attached backend against a fake app: a loopback control server answering with a headless
 //! session, speaking the desktop app's JSON-lines protocol.
-#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
 
 use std::io::{BufRead, BufReader, Write};
 use std::net::TcpListener;
diff --git a/crates/mcp/tests/it/automation_roots.rs b/crates/mcp/tests/it/automation_roots.rs
new file mode 100644
index 000000000..aa8e1b246
--- /dev/null
+++ b/crates/mcp/tests/it/automation_roots.rs
@@ -0,0 +1,125 @@
+//! `--automation-read-root` / `--automation-write-root` over MCP (#715): a tool call reads only
+//! inside the read and write roots and writes only inside the write roots.
+
+use std::path::PathBuf;
+
+use figcraft_engine::file_access::Roots;
+use figcraft_mcp::Server;
+use serde_json::{Value, json};
+
+/// `<tmp>/figcraft-mcp-roots-<name>-<pid>` with `in/` (read root), `out/` (write root),
+/// `outside/` and `out2/` (named like the write root, outside it).
+struct Dirs(PathBuf);
+
+impl Dirs {
+    fn new(name: &str) -> Self {
+        let d = std::env::temp_dir().join(format!("figcraft-mcp-roots-{name}-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&d);
+        for sub in ["in", "out", "outside", "out2"] {
+            std::fs::create_dir_all(d.join(sub)).unwrap();
+        }
+        Self(d)
+    }
+
+    fn p(&self, rel: &str) -> String {
+        self.0.join(rel).to_string_lossy().into_owned()
+    }
+
+    fn server(&self) -> Server {
+        Server::headless().with_roots(Some(Roots::new(&[self.p("in")], &[self.p("out")]).unwrap()))
+    }
+}
+
+impl Drop for Dirs {
+    fn drop(&mut self) {
+        let _ = std::fs::remove_dir_all(&self.0);
+    }
+}
+
+fn call(s: &mut Server, tool: &str, args: Value) -> Value {
+    let line = json!({"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": tool, "arguments": args}}).to_string();
+    let r: Value = serde_json::from_str(&s.handle_line(&line).unwrap()).unwrap();
+    r["result"].clone()
+}
+
+fn text(r: &Value) -> String {
+    r["content"][0]["text"].as_str().unwrap_or_default().to_string()
+}
+
+#[test]
+fn writes_go_only_into_the_write_root() {
+    let d = Dirs::new("write");
+    let mut s = d.server();
+    assert_eq!(call(&mut s, "create_node", json!({"type": "frame", "width": 40, "height": 20}))["isError"], false);
+    assert_eq!(call(&mut s, "run_command", json!({"command": "export.add"}))["isError"], false);
+    for (tool, args) in [
+        ("save_file", json!({"path": d.p("outside/a.figcraft")})),
+        ("save_file", json!({"path": d.p("out2/a.figcraft")})),
+        ("save_file", json!({"path": d.p("out/../outside/a.figcraft")})),
+        ("save_file", json!({"path": d.p("in/a.figcraft")})),
+        ("export", json!({"format": "png", "path": d.p("outside/a.png")})),
+        ("run_command", json!({"command": "file.export", "params": {"format": "svg", "path": d.p("outside/a.svg")}})),
+        ("run_command", json!({"command": "file.exportLayers", "params": {"dir": d.p("outside")}})),
+        ("batch", json!({"commands": [{"command": "file.saveAs", "params": {"path": d.p("outside/b.figcraft")}}]})),
+    ] {
+        let r = call(&mut s, tool, args.clone());
+        assert_eq!(r["isError"], true, "{tool} {args}: {r}");
+        assert!(text(&r).contains("automation path rejected"), "{tool}: {r}");
+    }
+    for sub in ["outside", "out2", "in"] {
+        assert_eq!(std::fs::read_dir(d.0.join(sub)).unwrap().count(), 0, "nothing written in {sub}");
+    }
+    assert_eq!(call(&mut s, "save_file", json!({"path": d.p("out/a.figcraft")}))["isError"], false);
+    assert_eq!(call(&mut s, "export", json!({"format": "png", "path": d.p("out/a.png")}))["isError"], false);
+    assert!(d.0.join("out/a.figcraft").is_file() && d.0.join("out/a.png").is_file());
+    // Without a path the bytes come back, written nowhere.
+    let r = call(&mut s, "export", json!({"format": "png"}));
+    assert_eq!(r["content"][0]["type"], "image", "{r}");
+}
+
+#[test]
+fn reads_go_only_into_the_read_and_write_roots() {
+    let d = Dirs::new("read");
+    // Files made without roots: one in each folder.
+    let mut free = Server::headless();
+    assert_eq!(call(&mut free, "create_node", json!({"type": "frame", "width": 40, "height": 20, "name": "Made"}))["isError"], false);
+    for f in ["in/a.figcraft", "out/b.figcraft", "outside/c.figcraft"] {
+        assert_eq!(call(&mut free, "export", json!({"format": "svg", "path": d.p(&f.replace(".figcraft", ".svg"))}))["isError"], false);
+        assert_eq!(call(&mut free, "run_command", json!({"command": "file.saveAs", "params": {"path": d.p(f)}}))["isError"], false);
+    }
+    let mut s = d.server();
+    for (tool, args) in [
+        ("open_file", json!({"path": d.p("outside/c.figcraft")})),
+        ("open_file", json!({"path": d.p("in/../outside/c.figcraft")})),
+        ("open_file", json!({"path": d.p("in/a.figcraft"), "variables": d.p("outside/c.svg")})),
+        ("run_command", json!({"command": "file.import", "params": {"path": d.p("outside/c.svg")}})),
+        ("run_command", json!({"command": "file.placeImage", "params": {"path": d.p("outside/c.svg")}})),
+        ("run_command", json!({"command": "library.add", "params": {"path": d.p("outside/c.figcraft")}})),
+    ] {
+        let r = call(&mut s, tool, args.clone());
+        assert_eq!(r["isError"], true, "{tool} {args}: {r}");
+        assert!(text(&r).contains("automation path rejected"), "{tool}: {r}");
+    }
+    assert_eq!(call(&mut s, "open_file", json!({"path": d.p("in/a.figcraft")}))["isError"], false);
+    assert_eq!(call(&mut s, "open_file", json!({"path": d.p("out/b.figcraft")}))["isError"], false, "a write root may be read");
+    assert_eq!(call(&mut s, "run_command", json!({"command": "file.import", "params": {"path": d.p("in/a.svg")}}))["isError"], false);
+}
+
+#[test]
+fn initialize_names_the_roots_and_no_roots_changes_nothing() {
+    let d = Dirs::new("init");
+    let mut s = d.server();
+    let r: Value =
+        serde_json::from_str(&s.handle_line(r#"{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18"}}"#).unwrap())
+            .unwrap();
+    let ins = r["result"]["instructions"].as_str().unwrap();
+    assert!(ins.contains("only these folders may be read") && ins.contains("figcraft-mcp-roots-init"), "{ins}");
+    let mut free = Server::headless();
+    let r: Value = serde_json::from_str(
+        &free.handle_line(r#"{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18"}}"#).unwrap(),
+    )
+    .unwrap();
+    assert!(!r["result"]["instructions"].as_str().unwrap().contains("only these folders"));
+    assert_eq!(call(&mut free, "create_node", json!({"type": "frame", "width": 4, "height": 4}))["isError"], false);
+    assert_eq!(call(&mut free, "export", json!({"format": "png", "path": d.p("outside/free.png")}))["isError"], false);
+}
diff --git a/crates/mcp/tests/common/mod.rs b/crates/mcp/tests/it/common/mod.rs
similarity index 97%
rename from crates/mcp/tests/common/mod.rs
rename to crates/mcp/tests/it/common/mod.rs
index be4dcea2f..51e748650 100644
--- a/crates/mcp/tests/common/mod.rs
+++ b/crates/mcp/tests/it/common/mod.rs
@@ -1,5 +1,4 @@
 //! An in-process MCP client: feeds JSON-RPC lines to `Server::handle_line`.
-#![allow(dead_code, clippy::unwrap_used, clippy::expect_used, clippy::panic)]
 
 use figcraft_mcp::Server;
 use serde_json::{Value, json};
diff --git a/crates/mcp/tests/export_hidden_roots.rs b/crates/mcp/tests/it/export_hidden_roots.rs
similarity index 96%
rename from crates/mcp/tests/export_hidden_roots.rs
rename to crates/mcp/tests/it/export_hidden_roots.rs
index ded6f731b..0a3b8de46 100644
--- a/crates/mcp/tests/export_hidden_roots.rs
+++ b/crates/mcp/tests/it/export_hidden_roots.rs
@@ -1,7 +1,6 @@
 //! Hidden top-level layers in an export take no room in the image (issue #447).
-#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
 
-mod common;
+use crate::common;
 
 use common::{Client, png_dims};
 use serde_json::{Value, json};
diff --git a/crates/mcp/tests/garbage.rs b/crates/mcp/tests/it/garbage.rs
similarity index 98%
rename from crates/mcp/tests/garbage.rs
rename to crates/mcp/tests/it/garbage.rs
index 262934c71..5d9e237ed 100644
--- a/crates/mcp/tests/garbage.rs
+++ b/crates/mcp/tests/it/garbage.rs
@@ -1,5 +1,4 @@
 //! Fuzz-ish: no input line may crash the server or leave it unable to answer.
-#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
 
 use figcraft_mcp::{Server, TOOL_NAMES};
 use proptest::prelude::*;
diff --git a/crates/mcp/tests/it/main.rs b/crates/mcp/tests/it/main.rs
new file mode 100644
index 000000000..b5e3d89de
--- /dev/null
+++ b/crates/mcp/tests/it/main.rs
@@ -0,0 +1,18 @@
+//! The crate's integration tests, built as one test binary.
+
+#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+mod agent_tasks;
+#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+mod attached;
+#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::disallowed_methods)]
+mod automation_roots;
+#[allow(dead_code, clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+mod common;
+#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+mod export_hidden_roots;
+#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+mod garbage;
+#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+mod protocol;
+#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+mod screenshot_pixel_limit;
diff --git a/crates/mcp/tests/protocol.rs b/crates/mcp/tests/it/protocol.rs
similarity index 94%
rename from crates/mcp/tests/protocol.rs
rename to crates/mcp/tests/it/protocol.rs
index 89f2a6493..617790f43 100644
--- a/crates/mcp/tests/protocol.rs
+++ b/crates/mcp/tests/it/protocol.rs
@@ -1,7 +1,6 @@
 //! JSON-RPC / MCP protocol behaviour.
-#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
 
-mod common;
+use crate::common;
 
 use common::Client;
 use figcraft_mcp::{PROTOCOL_VERSION, Server, TOOL_NAMES};
@@ -208,3 +207,14 @@ fn serve_accepts_a_limit_sized_frame_and_a_final_unterminated_frame() {
     assert_eq!(lines[0]["result"], json!({}));
     assert_eq!(lines[1]["id"], 2);
 }
+
+#[test]
+fn set_properties_passes_on_what_it_skipped() {
+    let mut c = Client::new();
+    let f = c.ok("create_node", json!({"type": "frame"}))["id"].clone();
+    let t = c.ok("create_node", json!({"type": "text", "text": "Hi"}))["id"].clone();
+    let r = c.ok("set_properties", json!({"ids": [f, t], "props": {"gap": 8}}));
+    assert!(r["warnings"][0].as_str().is_some_and(|w| w.contains("`gap`") && w.contains("TEXT")), "{r}");
+    assert!(c.ok("set_properties", json!({"ids": [f], "props": {"gap": 4}})).get("warnings").is_none());
+    assert!(c.err("set_properties", json!({"ids": [t], "props": {"gap": 4}})).contains("auto layout"));
+}
diff --git a/crates/mcp/tests/screenshot_pixel_limit.rs b/crates/mcp/tests/it/screenshot_pixel_limit.rs
similarity index 96%
rename from crates/mcp/tests/screenshot_pixel_limit.rs
rename to crates/mcp/tests/it/screenshot_pixel_limit.rs
index 095992ff1..e575f1d57 100644
--- a/crates/mcp/tests/screenshot_pixel_limit.rs
+++ b/crates/mcp/tests/it/screenshot_pixel_limit.rs
@@ -1,6 +1,5 @@
 //! `screenshot` with `ids` must honour `maxSize` for the rendered paint area (shadows, overflow).
-#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
-mod common;
+use crate::common;
 use common::{Client, png_dims};
 use serde_json::{Value, json};
 
diff --git a/crates/pathops/src/lib.rs b/crates/pathops/src/lib.rs
index 553fce04f..ca2ee0b6b 100644
--- a/crates/pathops/src/lib.rs
+++ b/crates/pathops/src/lib.rs
@@ -13,6 +13,8 @@ mod brush_tests;
 mod ops_tests;
 mod points;
 #[cfg(test)]
+mod rounded_side_strokes_tests;
+#[cfg(test)]
 mod sides_tests;
 pub mod width;
 #[cfg(test)]
@@ -59,6 +61,13 @@ pub fn closed(path: &BezPath) -> BezPath {
 /// Every coordinate is finite and of a sane magnitude (the sweep needs bounded input).
 pub use figcraft_geom::measure::finite_path as finite;
 
+/// Run the sweep library on `f`. Version 0.4 can panic on rare near-degenerate input (an internal
+/// `unwrap` while ordering curves, hit by some font outlines): that is bad input, not a crash.
+// shortcut: no catch where panics abort (wasm32); drop this once a linesweeper release no longer panics there.
+fn sweep<T>(f: impl FnOnce() -> Result<T, PathOpsError>) -> Result<T, PathOpsError> {
+    std::panic::catch_unwind(std::panic::AssertUnwindSafe(f)).unwrap_or(Err(PathOpsError::BadInput))
+}
+
 fn binary(a: &BezPath, b: &BezPath, op: linesweeper::BinaryOp) -> Result<BezPath, PathOpsError> {
     if a.elements().is_empty() && b.elements().is_empty() {
         return Ok(BezPath::new());
@@ -66,7 +75,7 @@ fn binary(a: &BezPath, b: &BezPath, op: linesweeper::BinaryOp) -> Result<BezPath
     if !finite(a) || !finite(b) {
         return Err(PathOpsError::BadInput);
     }
-    let contours = linesweeper::binary_op(&closed(a), &closed(b), linesweeper::FillRule::NonZero, op).map_err(|_| PathOpsError::BadInput)?;
+    let contours = sweep(|| linesweeper::binary_op(&closed(a), &closed(b), linesweeper::FillRule::NonZero, op).map_err(|_| PathOpsError::BadInput))?;
     let mut out = BezPath::new();
     for c in contours.contours() {
         out.extend(c.path.elements().iter().copied());
@@ -192,9 +201,14 @@ pub fn faces(paths: &[(BezPath, bool)]) -> Result<Vec<ArrangementFace>, PathOpsE
     let bbox = closed_paths.iter().filter(|p| !p.elements().is_empty()).map(Shape::bounding_box).reduce(|a, b| a.union(b));
     let m = bbox.map(|b| b.x0.abs().max(b.x1.abs()).max(b.y0.abs()).max(b.y1.abs())).unwrap_or(0.0);
     let eps = (m * f64::EPSILON * 64.0).max(1e-6);
+    let even_odd: Vec<bool> = paths.iter().map(|(_, e)| *e).collect();
+    sweep(|| arrange(&closed_paths, &even_odd, eps))
+}
+
+/// [`faces`] of the closed `paths`, swept with tolerance `eps`.
+fn arrange(closed_paths: &[BezPath], even_odd: &[bool], eps: f64) -> Result<Vec<ArrangementFace>, PathOpsError> {
     let topo = linesweeper::topology::Topology::<Windings>::from_paths(closed_paths.iter().enumerate().map(|(i, p)| (p, i)), eps)
         .map_err(|_| PathOpsError::BadInput)?;
-    let even_odd: Vec<bool> = paths.iter().map(|(_, e)| *e).collect();
     let cover_of = |w: &Windings| -> Vec<usize> {
         w.0.iter()
             .enumerate()
@@ -258,11 +272,16 @@ pub(crate) fn kjoin(j: StrokeJoin) -> Join {
     }
 }
 
-/// Plain centred stroke of `path` at `width`.
+/// The widest stroke outlined: past this the rasteriser's fixed-point maths overflows and panics,
+/// and nothing visible changes (a stroke this wide covers any canvas already).
+pub const MAX_STROKE_WIDTH: f64 = 1e6;
+
+/// Plain centred stroke of `path` at `width` (capped at [`MAX_STROKE_WIDTH`]).
 pub fn stroke_center(path: &BezPath, width: f64, props: &StrokeProps) -> BezPath {
     if !(width.is_finite() && width > 0.0 && finite(path)) {
         return BezPath::new();
     }
+    let width = width.min(MAX_STROKE_WIDTH);
     let mut style = kurbo::Stroke::new(width)
         .with_join(kjoin(props.join))
         .with_miter_limit(props.miter_limit.clamp(1.0, 100.0))
@@ -284,10 +303,17 @@ pub fn stroke_outline(path: &BezPath, props: &StrokeProps, closed_shape: bool) -
 /// [`stroke_outline`] of a shape whose stroke follows vector network `net` (`path` is its stroke
 /// path): points with a cap or join of their own draw them there.
 pub fn stroke_outline_of(path: &BezPath, props: &StrokeProps, closed_shape: bool, net: Option<&VectorNetwork>) -> BezPath {
-    let w = props.weight;
-    if !(w.is_finite() && w > 0.0) {
+    if !(props.weight.is_finite() && props.weight > 0.0) {
         return BezPath::new();
     }
+    let capped;
+    let props = if props.weight > MAX_STROKE_WIDTH {
+        capped = StrokeProps { weight: MAX_STROKE_WIDTH, ..props.clone() };
+        &capped
+    } else {
+        props
+    };
+    let w = props.weight;
     let styled = net.and_then(|n| points::Styled::new(n, props));
     // Centred at `width` (twice the weight for Inside/Outside, which clip half of it away).
     let centred = |width: f64| match (&styled, &props.brush, props.profile()) {
@@ -427,6 +453,94 @@ pub fn rect_side_strokes(w: f64, h: f64, sides: [f64; 4], align: StrokeAlign) ->
     p
 }
 
+/// Per-side stroke of a rectangle with corner radii `[tl, tr, br, bl]`, like CSS borders: the outer
+/// edge is the rounded rectangle (center and outside grow its box by half or all of each side's
+/// weight, and each non-zero radius with it); the inner edge is inset by each side's weight, with
+/// elliptical corners `max(0, R − weight)` across and down (square where either is 0). An even-odd
+/// ring whose inner edge runs against the outer one, so it is a ring under non-zero too.
+pub fn rounded_side_strokes(w: f64, h: f64, radii: [f64; 4], smoothing: f64, sides: [f64; 4], align: StrokeAlign) -> BezPath {
+    let [t, r, b, l] = sides.map(non_negative);
+    if t + r + b + l <= 0.0 {
+        return BezPath::new();
+    }
+    let f = match align {
+        StrokeAlign::Inside => 0.0,
+        StrokeAlign::Center => 0.5,
+        StrokeAlign::Outside => 1.0,
+    };
+    // Clamped like the fill: at most half the shorter side.
+    let max_r = non_negative(w.min(h)) / 2.0;
+    let radii = radii.map(|v| non_negative(v).min(max_r));
+    // Each corner's radius with the weights across and down it, clockwise from the top-left.
+    let corners = [(radii[0], l, t), (radii[1], r, t), (radii[2], r, b), (radii[3], l, b)];
+    let outer = if align == StrokeAlign::Inside {
+        figcraft_geom::rounded_rect(w, h, radii, smoothing)
+    } else {
+        let grown = corners.map(|(rr, x, y)| if rr > 0.0 { (rr + x * f, rr + y * f) } else { (0.0, 0.0) });
+        elliptical_rect(figcraft_geom::Rect::new(-l * f, -t * f, w + r * f, h + b * f), grown)
+    };
+    let k = 1.0 - f;
+    let inner = figcraft_geom::Rect::new(l * k, t * k, w - r * k, h - b * k);
+    if inner.width() <= 0.0 || inner.height() <= 0.0 {
+        return outer;
+    }
+    let (inset, fit) = fit_corners(inner, corners.map(|(rr, x, y)| ((rr - x * k).max(0.0), (rr - y * k).max(0.0))));
+    // The hole's corners sit on the outer ones, inside them, unless they were shrunk to fit or the
+    // outer ones are smoothed: then it may leave the outer edge.
+    ring(outer, &elliptical_rect(inner, inset), fit < 1.0 || (align == StrokeAlign::Inside && smoothing > 0.0))
+}
+
+fn non_negative(v: f64) -> f64 {
+    if v.is_finite() { v.max(0.0) } else { 0.0 }
+}
+
+/// `outer` with `hole` taken out: cut out of it when the hole may leave it, else as an even-odd
+/// ring whose hole runs against it.
+fn ring(outer: BezPath, hole: &BezPath, cut: bool) -> BezPath {
+    if cut && let Ok(p) = boolean_step(&outer, hole, BoolOp::Subtract) {
+        return p;
+    }
+    let mut p = outer;
+    p.extend(hole.reverse_subpaths().elements().iter().copied());
+    p
+}
+
+/// Corner radii `(rx, ry)` for the inner box `inner`, square where either is 0, all shrunk by one
+/// factor (returned too) where two on an edge add up to more than it, as CSS shrinks radii.
+fn fit_corners(inner: figcraft_geom::Rect, corners: [(f64, f64); 4]) -> ([(f64, f64); 4], f64) {
+    let c = corners.map(|(rx, ry)| if rx > 0.0 && ry > 0.0 { (rx, ry) } else { (0.0, 0.0) });
+    let [tl, tr, br, bl] = c;
+    let edges = [(inner.width(), tl.0 + tr.0), (inner.width(), bl.0 + br.0), (inner.height(), tl.1 + bl.1), (inner.height(), tr.1 + br.1)];
+    let fit = edges.iter().filter(|(_, sum)| *sum > 0.0).fold(1.0_f64, |m, (len, sum)| m.min(len / sum));
+    (c.map(|(rx, ry)| (rx * fit, ry * fit)), fit)
+}
+
+/// Rectangle `r` with an `(rx, ry)` quarter ellipse at each corner `[tl, tr, br, bl]`, drawn like
+/// `figcraft_geom::rounded_rect` (circular corners come out the same).
+fn elliptical_rect(r: figcraft_geom::Rect, [tl, tr, br, bl]: [(f64, f64); 4]) -> BezPath {
+    use std::f64::consts::{FRAC_PI_2, PI};
+    // Each corner, the direction of its ellipse centre from it, and the angle its quarter starts at.
+    let quarters = [
+        (Point::new(r.x1, r.y0), (-1.0, 1.0), tr, -FRAC_PI_2),
+        (Point::new(r.x1, r.y1), (-1.0, -1.0), br, 0.0),
+        (Point::new(r.x0, r.y1), (1.0, -1.0), bl, FRAC_PI_2),
+        (Point::new(r.x0, r.y0), (1.0, 1.0), tl, PI),
+    ];
+    let mut p = BezPath::new();
+    p.move_to((r.x0 + tl.0, r.y0));
+    for (corner, (sx, sy), (rx, ry), start) in quarters {
+        if rx > 0.0 && ry > 0.0 {
+            let c = Point::new(corner.x + sx * rx, corner.y + sy * ry);
+            p.line_to((c.x + rx * start.cos(), c.y + ry * start.sin()));
+            kurbo::Arc::new(c, (rx, ry), start, FRAC_PI_2, 0.0).to_cubic_beziers(0.01, |a, b, e| p.curve_to(a, b, e));
+        } else {
+            p.line_to(corner);
+        }
+    }
+    p.close_path();
+    p
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -441,6 +555,13 @@ mod tests {
         p.area().abs()
     }
 
+    #[test]
+    fn a_panic_in_the_sweep_is_bad_input() {
+        let r: Result<(), PathOpsError> = sweep(|| panic!("sweep bug"));
+        assert!(matches!(r, Err(PathOpsError::BadInput)));
+        assert!(matches!(sweep(|| Ok(1)), Ok(1)));
+    }
+
     #[test]
     fn union_intersect_subtract_exclude() {
         let a = sq(0.0, 0.0, 10.0);
@@ -525,6 +646,50 @@ mod tests {
         assert!(arrowhead(&BezPath::new(), StrokeCap::LineArrow, 1.0, true).is_none());
     }
 
+    #[test]
+    fn equal_point_joins_keep_the_layer_stroke_and_differing_ones_apply() {
+        let mut path = BezPath::new();
+        path.move_to((0.0, 0.0));
+        path.line_to((10.0, 10.0));
+        path.line_to((20.0, 0.0));
+        let net = VectorNetwork {
+            vertices: vec![
+                figcraft_doc::Vertex { cap: Some(StrokeCap::Square), ..figcraft_doc::Vertex::new(0.0, 0.0) },
+                figcraft_doc::Vertex { x: 10.0, y: 10.0, radius: 2.0, join: Some(StrokeJoin::Miter), ..figcraft_doc::Vertex::new(10.0, 10.0) },
+                figcraft_doc::Vertex { cap: Some(StrokeCap::Square), ..figcraft_doc::Vertex::new(20.0, 0.0) },
+            ],
+            segments: vec![figcraft_doc::Segment::line(0, 1), figcraft_doc::Segment::line(1, 2)],
+            ..Default::default()
+        };
+        let props = StrokeProps { weight: 4.0, ..Default::default() };
+        let inherited = stroke_outline_of(&path, &props, false, Some(&net));
+        let mut without_join = net.clone();
+        without_join.vertices[1].join = None;
+        let baseline = stroke_outline_of(&path, &props, false, Some(&without_join));
+        assert_eq!(inherited, baseline);
+
+        let different_layer = StrokeProps { join: StrokeJoin::Bevel, ..props };
+        let explicit = stroke_outline_of(&path, &different_layer, false, Some(&net));
+        let layer_only = stroke_outline_of(&path, &different_layer, false, Some(&without_join));
+        assert_ne!(explicit, layer_only);
+    }
+
+    #[test]
+    fn equal_joins_do_not_break_closed_stroke_runs() {
+        let path = sq(0.0, 0.0, 20.0);
+        let mut net = VectorNetwork::from_points(&[Point::new(0.0, 0.0), Point::new(20.0, 0.0), Point::new(20.0, 20.0), Point::new(0.0, 20.0)], true);
+        for vertex in &mut net.vertices {
+            vertex.join = Some(StrokeJoin::Round);
+        }
+        let props = StrokeProps { join: StrokeJoin::Round, weight: 4.0, ..Default::default() };
+        let styled = stroke_outline_of(&path, &props, true, Some(&net));
+        for vertex in &mut net.vertices {
+            vertex.join = None;
+        }
+        let inherited = stroke_outline_of(&path, &props, true, Some(&net));
+        assert_eq!(styled, inherited);
+    }
+
     #[test]
     fn dashes() {
         let mut line = BezPath::new();
diff --git a/crates/pathops/src/points.rs b/crates/pathops/src/points.rs
index d432da051..05f58216d 100644
--- a/crates/pathops/src/points.rs
+++ b/crates/pathops/src/points.rs
@@ -18,11 +18,17 @@ pub(crate) struct Styled {
 impl Styled {
     /// `None` when no point has a style of its own, or the stroke is dashed, variable or a brush.
     /// shortcut: dashed, variable-width and brush strokes keep the layer's caps and joins at every point; stroke them run by run too if asked for.
+    /// Joins equal to the layer do not require styled runs; stored overrides remain unchanged.
     pub(crate) fn new(net: &VectorNetwork, props: &StrokeProps) -> Option<Styled> {
-        if !net.has_point_styles() || !props.dashes.is_empty() || props.profile().is_some() || props.brush.is_some() {
+        if !net.has_point_styles(props.join) || !props.dashes.is_empty() || props.profile().is_some() || props.brush.is_some() {
             return None;
         }
-        let net = net.rounded().unwrap_or_else(|| net.clone());
+        let mut net = net.rounded().unwrap_or_else(|| net.clone());
+        for vertex in &mut net.vertices {
+            if vertex.join == Some(props.join) {
+                vertex.join = None;
+            }
+        }
         let runs = net.stroke_runs();
         let mut degrees = vec![0usize; net.vertices.len()];
         for s in &net.segments {
diff --git a/crates/pathops/src/rounded_side_strokes_tests.rs b/crates/pathops/src/rounded_side_strokes_tests.rs
new file mode 100644
index 000000000..ee0e82811
--- /dev/null
+++ b/crates/pathops/src/rounded_side_strokes_tests.rs
@@ -0,0 +1,114 @@
+//! Per-side stroke weights on rounded rectangles, drawn like CSS borders: square corners, a bar
+//! along a rounded edge, tapers through corners, alignments, inner corners that no longer fit,
+//! smoothing and degenerate weights.
+
+use figcraft_doc::StrokeAlign;
+use figcraft_geom::kurbo::{BezPath, Point, Shape};
+use figcraft_geom::rounded_rect;
+
+use crate::{rect_side_strokes, rounded_side_strokes};
+
+const W: f64 = 120.0;
+const H: f64 = 60.0;
+
+/// The area of a ring whose hole runs against its outer edge.
+fn area(p: &BezPath) -> f64 {
+    p.area().abs()
+}
+
+fn painted(p: &BezPath, x: f64, y: f64) -> bool {
+    p.winding(Point::new(x, y)) % 2 != 0
+}
+
+#[test]
+fn square_corners_paint_what_rect_side_strokes_paints() {
+    for align in [StrokeAlign::Inside, StrokeAlign::Center, StrokeAlign::Outside] {
+        let sides = [1.0, 2.0, 3.0, 4.0];
+        let a = area(&rounded_side_strokes(W, H, [0.0; 4], 0.0, sides, align));
+        assert!((a - area(&rect_side_strokes(W, H, sides, align))).abs() < 1e-6, "{align:?}: {a}");
+    }
+}
+
+/// `border-l-4 rounded-r-lg`.
+#[test]
+fn a_left_border_on_a_right_rounded_box_is_a_straight_bar() {
+    let bar = rounded_side_strokes(W, H, [0.0, 8.0, 8.0, 0.0], 0.0, [0.0, 0.0, 0.0, 4.0], StrokeAlign::Inside);
+    assert!((area(&bar) - 4.0 * H).abs() < 1e-6, "{}", area(&bar));
+    assert!(painted(&bar, 2.0, 30.0));
+    for (x, y) in [(119.9, 30.0), (117.0, 1.0), (60.0, 0.1), (60.0, 59.9), (4.1, 30.0)] {
+        assert!(!painted(&bar, x, y), "({x}, {y})");
+    }
+}
+
+#[test]
+fn one_weight_on_every_side_is_the_uniform_ring() {
+    let ring = rounded_side_strokes(W, H, [8.0; 4], 0.0, [2.0; 4], StrokeAlign::Inside);
+    let want = area(&rounded_rect(W, H, [8.0; 4], 0.0)) - area(&rounded_rect(W - 4.0, H - 4.0, [6.0; 4], 0.0));
+    assert!((area(&ring) - want).abs() < 1e-6, "{} vs {want}", area(&ring));
+    assert_eq!(ring.winding(Point::new(60.0, 30.0)), 0, "a hole under non-zero too");
+}
+
+#[test]
+fn center_and_outside_grow_the_box_and_its_corners() {
+    for (align, out, inset) in [(StrokeAlign::Center, 1.0, 1.0), (StrokeAlign::Outside, 2.0, 0.0)] {
+        let a = area(&rounded_side_strokes(W, H, [8.0; 4], 0.0, [2.0; 4], align));
+        let outer = area(&rounded_rect(W + 2.0 * out, H + 2.0 * out, [8.0 + out; 4], 0.0));
+        let hole = area(&rounded_rect(W - 2.0 * inset, H - 2.0 * inset, [8.0 - inset; 4], 0.0));
+        assert!((a - (outer - hole)).abs() < 1e-6, "{align:?}: {a} vs {}", outer - hole);
+    }
+}
+
+/// 8 × 7 inner ellipses at the bottom corners.
+#[test]
+fn a_bottom_border_tapers_into_the_bottom_corners() {
+    let bottom = rounded_side_strokes(W, H, [8.0; 4], 0.0, [0.0, 0.0, 1.0, 0.0], StrokeAlign::Inside);
+    assert!(painted(&bottom, 60.0, 59.5) && painted(&bottom, 8.0, 59.5) && painted(&bottom, 112.0, 59.5));
+    for (x, y) in [(60.0, 0.5), (0.5, 30.0), (0.5, 52.0), (119.5, 52.0), (4.0, 4.0)] {
+        assert!(!painted(&bottom, x, y), "({x}, {y})");
+    }
+}
+
+#[test]
+fn a_weight_past_the_radius_leaves_square_inner_corners() {
+    let top = rounded_side_strokes(W, H, [8.0; 4], 0.0, [10.0, 0.0, 0.0, 2.0], StrokeAlign::Inside);
+    assert!(!painted(&top, 2.2, 10.2) && !painted(&top, 119.8, 10.2));
+    assert!(painted(&top, 60.0, 9.8) && painted(&top, 1.8, 30.0));
+}
+
+/// A weight past `w − R` leaves inner corners wider than the inner box: they shrink to fit, so the
+/// hole stays inside the outer edge, across or down.
+#[test]
+fn inner_corners_shrink_to_fit_a_narrow_inner_box() {
+    let wide = rounded_side_strokes(20.0, 20.0, [10.0; 4], 0.0, [0.0, 0.0, 0.0, 12.0], StrokeAlign::Inside);
+    assert!(painted(&wide, 6.0, 10.0) && !painted(&wide, 16.0, 10.0));
+    assert!(!painted(&wide, 17.5, 3.0) && !painted(&wide, 17.5, 17.0), "nothing past the outer edge");
+    let tall = rounded_side_strokes(20.0, 20.0, [10.0; 4], 0.0, [12.0, 0.0, 0.0, 0.0], StrokeAlign::Inside);
+    assert!(painted(&tall, 10.0, 6.0) && !painted(&tall, 10.0, 16.0));
+    assert!(!painted(&tall, 3.0, 17.5) && !painted(&tall, 17.0, 17.5), "nothing past the outer edge");
+    let pill = rounded_side_strokes(30.0, 20.0, [10.0; 4], 0.0, [0.0, 0.0, 0.0, 25.0], StrokeAlign::Inside);
+    assert!(painted(&pill, 12.0, 10.0) && !painted(&pill, 27.0, 10.0));
+    assert!(!painted(&pill, 24.0, 0.5) && !painted(&pill, 24.0, 19.5), "nothing past the outer edge");
+}
+
+#[test]
+fn smoothed_corners_keep_the_stroke_inside_the_fill() {
+    let smooth = rounded_side_strokes(W, H, [16.0; 4], 0.6, [0.0, 0.0, 2.0, 0.0], StrokeAlign::Inside);
+    let fill = rounded_rect(W, H, [16.0; 4], 0.6);
+    let grid = (0..1200).flat_map(|i| (0..600).map(move |j| Point::new(f64::from(i) * 0.1 + 0.05, f64::from(j) * 0.1 + 0.05)));
+    let stray = grid.filter(|pt| painted(&smooth, pt.x, pt.y) && (pt.y < H / 2.0 || fill.winding(*pt) == 0));
+    assert_eq!(stray.count(), 0, "painted outside the fill or along the top");
+    assert!(painted(&smooth, 60.0, 59.5));
+}
+
+#[test]
+fn weights_wider_than_the_box_leave_the_outer_edge() {
+    let full = rounded_side_strokes(20.0, 10.0, [4.0; 4], 0.0, [6.0; 4], StrokeAlign::Inside);
+    assert!((area(&full) - area(&rounded_rect(20.0, 10.0, [4.0; 4], 0.0))).abs() < 1e-6);
+}
+
+#[test]
+fn no_weight_paints_nothing() {
+    assert!(rounded_side_strokes(W, H, [8.0; 4], 0.0, [0.0; 4], StrokeAlign::Inside).elements().is_empty());
+    let junk = [f64::NAN, -4.0, f64::INFINITY, 0.0];
+    assert!(rounded_side_strokes(W, H, [8.0; 4], 0.0, junk, StrokeAlign::Inside).elements().is_empty());
+}
diff --git a/crates/pdf/src/draw.rs b/crates/pdf/src/draw.rs
index 99f4e390f..1ff484090 100644
--- a/crates/pdf/src/draw.rs
+++ b/crates/pdf/src/draw.rs
@@ -116,7 +116,7 @@ pub(crate) fn rule(r: figcraft_render::FillRule) -> FillRule {
 }
 
 /// The renderer's stroke fill rule: even-odd ring paths for aligned strokes, else non-zero.
-fn stroke_rule(n: &Node, closed: bool) -> FillRule {
+pub(crate) fn stroke_rule(n: &Node, closed: bool) -> FillRule {
     if n.stroke.sides.is_some() || (n.stroke.dashes.is_empty() && closed && n.stroke.align != StrokeAlign::Center) {
         FillRule::EvenOdd
     } else {
diff --git a/crates/pdf/src/text.rs b/crates/pdf/src/text.rs
index c425404da..cb2ec7a2e 100644
--- a/crates/pdf/src/text.rs
+++ b/crates/pdf/src/text.rs
@@ -5,7 +5,7 @@ use std::collections::BTreeSet;
 use std::ops::Range;
 use std::sync::Arc;
 
-use figcraft_doc::{Node, NodeKind, StrokeAlign, StrokeProps};
+use figcraft_doc::{Node, NodeKind};
 use figcraft_geom::{Affine, BezPath};
 use figcraft_text::fontdb::FontBytes;
 use figcraft_text::{Face, Glyph, TextLayout};
@@ -16,7 +16,7 @@ use krilla::text::{Font, GlyphId, KrillaGlyph};
 
 use figcraft_color::{GradientKind, Paint, PaintKind};
 
-use crate::draw::{Exporter, above, affine_ok, blend, to_xf, vector_paint};
+use crate::draw::{Exporter, above, affine_ok, blend, stroke_rule, to_xf, vector_paint};
 use crate::raster::Raster;
 
 /// Glyphs of one face and size on one line, written as one text run.
@@ -84,11 +84,11 @@ pub(crate) fn draw_text(ex: &mut Exporter, s: &mut Surface, n: &Node, xf: Affine
         }
     }
     ex.place_inner(s, inner);
-    let props = StrokeProps { align: StrokeAlign::Center, ..n.stroke.clone() };
+    // Glyph outlines are closed: inside and outside strokes clip to them, as on the canvas (#615).
     for outlines in &stroked {
-        let area = figcraft_pathops::stroke_center(outlines, props.weight, &props);
+        let area = figcraft_render::draw::stroke_area(n, outlines, true);
         for p in &n.strokes {
-            ex.fill(s, &area, FillRule::NonZero, p, w, h, gxf);
+            ex.fill(s, &area, stroke_rule(n, true), p, w, h, gxf);
         }
     }
 }
diff --git a/crates/plugin/src/manifest.rs b/crates/plugin/src/manifest.rs
index 48e44e880..4bd3590f0 100644
--- a/crates/plugin/src/manifest.rs
+++ b/crates/plugin/src/manifest.rs
@@ -44,7 +44,7 @@ pub struct Manifest {
     pub main: String,
     /// The plugin API version the plugin was written for (1 when not given; panels and settings
     /// need 2, widgets 3).
-    #[serde(default = "api_version")]
+    #[serde(default = "api_version", deserialize_with = "api_from_number_or_string")]
     pub api: u32,
     #[serde(default)]
     pub permissions: Permissions,
@@ -61,6 +61,25 @@ fn api_version() -> u32 {
     1
 }
 
+/// `api` as a whole number or a version string (`"1.0.0"`, whose major part is the API version).
+fn api_from_number_or_string<'de, D: serde::Deserializer<'de>>(d: D) -> Result<u32, D::Error> {
+    #[derive(Deserialize)]
+    #[serde(untagged)]
+    enum Api {
+        Number(u32),
+        Text(String),
+    }
+    match Api::deserialize(d)? {
+        Api::Number(n) => Ok(n),
+        Api::Text(s) => s
+            .trim()
+            .split('.')
+            .next()
+            .and_then(|major| major.parse().ok())
+            .ok_or_else(|| serde::de::Error::custom(format!("invalid api version `{s}`"))),
+    }
+}
+
 /// What a plugin may do.
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
 pub struct Permissions {
diff --git a/crates/plugin/src/tests.rs b/crates/plugin/src/tests.rs
index 5d094ab4c..a6e2a5875 100644
--- a/crates/plugin/src/tests.rs
+++ b/crates/plugin/src/tests.rs
@@ -462,3 +462,12 @@ fn bad_manifests_are_refused() {
         assert!(Manifest::parse(junk).is_err(), "accepted {}", junk.chars().take(40).collect::<String>());
     }
 }
+
+#[test]
+fn api_may_be_a_version_string() {
+    assert_eq!(manifest(json!({"api": "1.0.0"})).unwrap().api, 1);
+    assert_eq!(manifest(json!({"api": "2"})).unwrap().api, 2);
+    assert_eq!(manifest(json!({"api": 2})).unwrap().api, 2);
+    assert!(manifest(json!({"api": "4.0.0"})).is_err());
+    assert!(manifest(json!({"api": "x"})).is_err());
+}
diff --git a/crates/render/src/bounds_memo_tests.rs b/crates/render/src/bounds_memo_tests.rs
new file mode 100644
index 000000000..4d0b305b4
--- /dev/null
+++ b/crates/render/src/bounds_memo_tests.rs
@@ -0,0 +1,92 @@
+//! Paint bounds worked out once per render: the bounds kept for a layer are the ones worked out
+//! without keeping any, and the largest background blur follows the document's edits.
+
+use super::*;
+use figcraft_doc::{Effect, EffectKind};
+
+#[test]
+fn kept_paint_bounds_are_the_bounds_worked_out_afresh() {
+    // Unclipped frames nested past the 64-level walk, a rectangle at the bottom: bounds asked for
+    // deep first and then from the top, and the other way round, are those worked out alone.
+    let mut d = Document::new("deep");
+    let p = d.first_page().unwrap();
+    let mut chain = Vec::new();
+    let mut parent = p;
+    for k in 0..80 {
+        let f = d.create(parent, NodeKind::Frame, &format!("F{k}"), 1.0, 1.0, 10.0, 10.0).unwrap();
+        d.node_mut(f).unwrap().clip = false;
+        chain.push(f);
+        parent = f;
+    }
+    d.create(parent, NodeKind::Rectangle, "R", 500.0, 0.0, 10.0, 10.0).unwrap();
+    for order in [chain.iter().rev().copied().collect::<Vec<_>>(), chain.clone()] {
+        let memo = draw::Bounds::default();
+        for id in &order {
+            let n = d.node(*id).unwrap();
+            for depth in [0, 20] {
+                let kept = draw::bounds_within(&d, n, depth, None, Some(&memo)).0;
+                assert_eq!(kept, draw::local_paint_bounds(&d, n, depth, None), "{} at depth {depth}", n.name);
+            }
+        }
+    }
+}
+
+#[test]
+fn the_largest_background_blur_follows_edits() {
+    let mut d = Document::new("blur");
+    let p = d.first_page().unwrap();
+    let r = d.create(p, NodeKind::Rectangle, "R", 0.0, 0.0, 10.0, 10.0).unwrap();
+    assert_eq!(max_backdrop_blur(&d), 0.0);
+    let mut blur = Effect::background_blur();
+    if let EffectKind::BackgroundBlur(b) = &mut blur.kind {
+        b.radius = 12.0;
+    }
+    d.node_mut(r).unwrap().effects.push(blur);
+    assert_eq!(max_backdrop_blur(&d), 12.0);
+    // A copy of the document keeps it, and an edit of the copy changes only the copy's.
+    let mut copy = d.clone();
+    if let Some(EffectKind::BackgroundBlur(b)) = copy.node_mut(r).unwrap().effects.first_mut().map(|e| &mut e.kind) {
+        b.radius = 30.0;
+    }
+    assert_eq!(max_backdrop_blur(&copy), 30.0);
+    assert_eq!(max_backdrop_blur(&d), 12.0);
+    copy.node_mut(r).unwrap().effects.clear();
+    assert_eq!(max_backdrop_blur(&copy), 0.0);
+    // A deleted layer's blur no longer counts.
+    d.remove(r).unwrap();
+    assert_eq!(max_backdrop_blur(&d), 0.0);
+}
+
+#[test]
+fn kept_splat_answers_are_the_answers_worked_out_afresh() {
+    use figcraft_color::{ImageScaleMode, Paint};
+    // Groups nested past the 64-level walk, with an image-filled rectangle at the bottom of one
+    // branch and a plain one at the bottom of the other: answers asked for deep-first and
+    // top-first, at depths 0 and 20, are those worked out alone.
+    let mut d = Document::new("deep");
+    let p = d.first_page().unwrap();
+    let mut chain = Vec::new();
+    for image in [false, true] {
+        let mut parent = p;
+        for k in 0..80 {
+            let g = d.create(parent, NodeKind::Frame, &format!("{image} {k}"), 0.0, 0.0, 10.0, 10.0).unwrap();
+            d.node_mut(g).unwrap().clip = false;
+            chain.push(g);
+            parent = g;
+        }
+        let r = d.create(parent, NodeKind::Rectangle, "R", 0.0, 0.0, 10.0, 10.0).unwrap();
+        if image {
+            d.node_mut(r).unwrap().fills = vec![Paint::image("missing", ImageScaleMode::Fill)];
+        }
+    }
+    for order in [chain.iter().rev().copied().collect::<Vec<_>>(), chain.clone()] {
+        let memo = draw::Bounds::default();
+        for id in &order {
+            let n = d.node(*id).unwrap();
+            for depth in [0, 20] {
+                let kept = lod::splattable_within(&d, n, depth, Some(&memo)).0;
+                assert_eq!(kept, lod::splattable(&d, n, depth), "{} at depth {depth}", n.name);
+            }
+        }
+    }
+}
diff --git a/crates/render/src/draw.rs b/crates/render/src/draw.rs
index 7bfafd33b..3718df26a 100644
--- a/crates/render/src/draw.rs
+++ b/crates/render/src/draw.rs
@@ -16,8 +16,9 @@ use crate::{blur, grain, lod, shadow};
 
 /// Shared state for one render.
 #[derive(Clone, Copy)]
-pub struct Ctx<'a> {
-    pub doc: &'a Document,
+/// `'d`: the document's (layers looked up for the render are kept that long), `'a`: the rest.
+pub struct Ctx<'a, 'd> {
+    pub doc: &'d Document,
     /// Device pixels per document unit (for effect radii).
     pub scale: f64,
     pub outline_mode: bool,
@@ -33,8 +34,67 @@ pub struct Ctx<'a> {
     pub under: Option<&'a Under<'a>>,
     /// Seconds into animated GIFs (0: their first frame; only the presenter plays them).
     pub time: f64,
+    /// Paint bounds already worked out in this render.
+    pub bounds: &'a Bounds<'d>,
 }
 
+/// What one render works out about layers with children, which a walk down their subtree finds:
+/// their local paint bounds by greeking scale, and whether they can be splatted (see
+/// [`lod::splattable`]). Culling asks for a node's and then for each of its children's, so without
+/// them every layer's subtree was walked again at each level above it. Each answer keeps how many
+/// levels its walk went down.
+/// It also keeps the layers it looked up: the walks for culling, splatting and drawing go down the
+/// same layers, and in a large document a lookup is a good part of a layer's cost.
+#[derive(Default)]
+pub struct Bounds<'a> {
+    paint: std::cell::RefCell<IdMap<BoundsKey, (Rect, usize)>>,
+    pub(crate) splat: std::cell::RefCell<IdMap<NodeId, (bool, usize)>>,
+    nodes: std::cell::RefCell<IdMap<NodeId, Option<&'a Node>>>,
+}
+
+impl<'a> Bounds<'a> {
+    /// Node `id` of `doc`, looked up once for the render.
+    pub(crate) fn node(&self, doc: &'a Document, id: NodeId) -> Option<&'a Node> {
+        if let Some(n) = self.nodes.borrow().get(&id) {
+            return *n;
+        }
+        let n = doc.node(id);
+        self.nodes.borrow_mut().insert(id, n);
+        n
+    }
+}
+
+/// A hash map keyed by node ids, which need no SipHash: they are counters (or a peer's range of
+/// them), and SipHash took a good part of a render.
+type IdMap<K, V> = HashMap<K, V, std::hash::BuildHasherDefault<IdHash>>;
+
+/// Mixes each word in with a multiply (Fibonacci hashing), so ids that differ in low bits spread.
+#[derive(Default)]
+pub(crate) struct IdHash(u64);
+
+impl Hasher for IdHash {
+    fn finish(&self) -> u64 {
+        self.0
+    }
+    fn write(&mut self, bytes: &[u8]) {
+        for b in bytes {
+            self.write_u64(u64::from(*b));
+        }
+    }
+    fn write_u64(&mut self, v: u64) {
+        self.0 = (self.0.rotate_left(5) ^ v).wrapping_mul(0x9E37_79B9_7F4A_7C15);
+    }
+    fn write_usize(&mut self, v: usize) {
+        self.write_u64(v as u64);
+    }
+}
+
+/// A layer, and the scale its text is greeked at (none: drawn in full).
+type BoundsKey = (NodeId, Option<u64>);
+
+/// Deepest nesting the paint bounds walk follows.
+const MAX_BOUNDS_DEPTH: usize = 64;
+
 pub fn ts_transform(a: Affine) -> Transform {
     let c = a.as_coeffs();
     Transform::from_row(c[0] as f32, c[1] as f32, c[2] as f32, c[3] as f32, c[4] as f32, c[5] as f32)
@@ -102,9 +162,13 @@ pub fn stroke_area(n: &Node, path: &BezPath, closed: bool) -> Arc<BezPath> {
     // Per-side strokes on rectangles/frames.
     if let Some(sides) = props.sides
         && matches!(n.kind, NodeKind::Rectangle | NodeKind::Frame | NodeKind::Component { .. } | NodeKind::Instance { .. })
-        && n.corners.uniform() == Some(0.0)
     {
-        return Arc::new(figcraft_pathops::rect_side_strokes(n.width, n.height, sides, props.align));
+        let c = &n.corners;
+        return Arc::new(if c.uniform() == Some(0.0) {
+            figcraft_pathops::rect_side_strokes(n.width, n.height, sides, props.align)
+        } else {
+            figcraft_pathops::rounded_side_strokes(n.width, n.height, c.radii, c.smoothing, sides, props.align)
+        });
     }
     // Rect/ellipse inside/outside strokes without booleans: an even-odd ring of two outlines.
     if props.dashes.is_empty() && props.profile().is_none() && props.brush.is_none() && closed && props.align != StrokeAlign::Center {
@@ -155,7 +219,7 @@ pub fn stroke_area(n: &Node, path: &BezPath, closed: bool) -> Arc<BezPath> {
     props.dashes.len().hash(&mut h);
     // Points' own caps and joins (vector networks).
     let net = match &n.kind {
-        NodeKind::Vector { network } if network.has_point_styles() => Some(network),
+        NodeKind::Vector { network } if network.has_point_styles(props.join) => Some(network),
         _ => None,
     };
     for v in net.map(|n| n.vertices.as_slice()).unwrap_or_default() {
@@ -279,32 +343,63 @@ fn text_box_bounds(n: &Node) -> Rect {
 /// Local bounds a node paints into (its box grown by stroke/effect reach, plus unclipped children).
 /// Text that overflows its box counts where its glyphs are, so it isn't culled while visible;
 /// text greeked at `greek_scale` (see [`lod::greeked`]) paints only inside [`text_box_bounds`].
-fn local_paint_bounds(doc: &Document, n: &Node, depth: usize, greek_scale: Option<f64>) -> Rect {
+pub(crate) fn local_paint_bounds(doc: &Document, n: &Node, depth: usize, greek_scale: Option<f64>) -> Rect {
+    bounds_within(doc, n, depth, greek_scale, None).0
+}
+
+/// [`local_paint_bounds`], kept in and read from `memo` when there is one. Also returns how many
+/// levels the walk went down, or `None` when the nesting cap cut it short: such bounds depend on
+/// the depth they were asked at and aren't kept, and kept bounds are read only where their levels
+/// still fit under the cap.
+pub(crate) fn bounds_within<'a>(
+    doc: &'a Document,
+    n: &Node,
+    depth: usize,
+    greek_scale: Option<f64>,
+    memo: Option<&Bounds<'a>>,
+) -> (Rect, Option<usize>) {
+    // A layer without children is quicker to work out again than to look up.
+    let memo = memo.filter(|_| !n.children.is_empty());
+    let key = (n.id, greek_scale.map(f64::to_bits));
+    if let Some((r, levels)) = memo.and_then(|m| m.paint.borrow().get(&key).copied())
+        && depth + levels <= MAX_BOUNDS_DEPTH
+    {
+        return (r, Some(levels));
+    }
     let reach = n.paint_reach();
     let mut r = n.local_rect().inflate(reach, reach);
+    let mut levels = Some(0);
     let clips = n.clip && n.kind.is_frame_like();
-    if (!clips || n.kind.bounds_follow_children()) && depth < 64 && !n.hides_contents() {
-        for c in n.children.iter().filter_map(|c| doc.node(*c)) {
-            if !c.visible {
-                continue;
+    if (!clips || n.kind.bounds_follow_children()) && !n.hides_contents() {
+        if depth < MAX_BOUNDS_DEPTH {
+            let mut below = Some(0);
+            for c in n.children.iter().filter_map(|c| memo.map_or_else(|| doc.node(*c), |m| m.node(doc, *c))) {
+                if !c.visible {
+                    continue;
+                }
+                let (cb, c_levels) = bounds_within(doc, c, depth + 1, greek_scale, memo);
+                below = below.zip(c_levels).map(|(b, l)| b.max(l));
+                r = r.union(figcraft_geom::transform_rect_bbox(c.transform, cb));
             }
-            let cb = local_paint_bounds(doc, c, depth + 1, greek_scale);
-            r = r.union(figcraft_geom::transform_rect_bbox(c.transform, cb));
+            levels = below.map(|b| b + 1);
+        } else if !n.children.is_empty() {
+            levels = None;
         }
     }
     // Text can overflow its box.
     if let NodeKind::Text(_) = n.kind {
         r = r.union(text_box_bounds(n).inflate(reach, reach));
-        if greek_scale.is_some_and(|s| lod::greeked(n, s)) {
-            return r;
-        }
-        if let Some((l, dy)) = figcraft_text::layout_node(n)
+        if !greek_scale.is_some_and(|s| lod::greeked(n, s))
+            && let Some((l, dy)) = figcraft_text::layout_node(n)
             && let Some(ink) = l.ink_bounds()
         {
             r = r.union(ink + figcraft_geom::kurbo::Vec2::new(0.0, dy));
         }
     }
-    r
+    if let (Some(m), Some(l)) = (memo, levels) {
+        m.paint.borrow_mut().insert(key, (r, l));
+    }
+    (r, levels)
 }
 
 /// How far (document units) effects that read outside a node's paint bounds reach: blurs, glass,
@@ -367,10 +462,17 @@ const MAX_EFFECT_MARGIN_PX: f64 = 2048.0;
 
 /// Draw node `id` onto `pix`, where `parent_xf` maps the parent's space to `pix` pixels.
 pub fn draw_node(ctx: &Ctx, pix: &mut Pixmap, id: NodeId, parent_xf: Affine, depth: usize) {
+    if let Some(n) = ctx.doc.node(id) {
+        draw_layer(ctx, pix, n, parent_xf, depth);
+    }
+}
+
+/// [`draw_node`] for a node already looked up.
+fn draw_layer(ctx: &Ctx, pix: &mut Pixmap, n: &Node, parent_xf: Affine, depth: usize) {
+    let id = n.id;
     if depth > crate::MAX_EXPORT_DEPTH || ctx.skip.contains(&id) {
         return;
     }
-    let Some(n) = ctx.doc.node(id) else { return };
     let outline = ctx.outline_mode || ctx.outlined.contains(&id);
     if n.is_mask || n.opacity <= 0.0 && n.visible {
         return;
@@ -385,7 +487,7 @@ pub fn draw_node(ctx: &Ctx, pix: &mut Pixmap, id: NodeId, parent_xf: Affine, dep
     }
     let xf = parent_xf * n.transform;
     let (pw, ph) = (pix.width(), pix.height());
-    let local = local_paint_bounds(ctx.doc, n, 0, ctx.lod.then_some(ctx.scale));
+    let local = bounds_within(ctx.doc, n, 0, ctx.lod.then_some(ctx.scale), Some(ctx.bounds)).0;
     let dev = device_rect(xf, local);
     // Effects that read outside (blur) need a margin when culling. Absurd effects (a spread or
     // blur of millions of pixels) keep a sane layer: what lies further off reads as empty.
@@ -398,7 +500,7 @@ pub fn draw_node(ctx: &Ctx, pix: &mut Pixmap, id: NodeId, parent_xf: Affine, dep
         draw_outline(&Ctx { outline_mode: true, ..*ctx }, pix, n, xf, depth);
         return;
     }
-    if ctx.lod && dev.width().max(dev.height()) < lod::TINY_PX && lod::splattable(ctx.doc, n, 0) {
+    if ctx.lod && dev.width().max(dev.height()) < lod::TINY_PX && lod::splattable_within(ctx.doc, n, 0, Some(ctx.bounds)).0 {
         lod::splat_subtree(ctx, pix, n, xf, None, 1.0, depth);
         return;
     }
@@ -621,11 +723,11 @@ fn draw_content(ctx: &Ctx, pix: &mut Pixmap, n: &Node, xf: Affine, depth: usize,
                 f(pix);
             }
             if n.has_visible_stroke() {
-                let props = figcraft_doc::StrokeProps { align: StrokeAlign::Center, ..n.stroke.clone() };
+                // Glyph outlines are closed: inside and outside strokes clip to them (#615).
                 for path in keys.iter().filter_map(|k| by_style.get(k)) {
-                    let s = figcraft_pathops::stroke_center(path, props.weight, &props);
+                    let s = stroke_area(n, path, true);
                     if let Some(ts) = ts_path(&s) {
-                        fill_with(pix, &ts, &n.strokes, w, h, gxf, FillRule::Winding, ctx, None);
+                        fill_with(pix, &ts, &n.strokes, w, h, gxf, stroke_rule(n, true), ctx, None);
                     }
                 }
             }
@@ -672,13 +774,15 @@ fn draw_content(ctx: &Ctx, pix: &mut Pixmap, n: &Node, xf: Affine, depth: usize,
 
 fn draw_children(ctx: &Ctx, pix: &mut Pixmap, n: &Node, xf: Affine, depth: usize) {
     let kids = &n.children;
-    for run in ctx.doc.paint_runs(n) {
-        let Some(&c) = kids.get(run.start) else { continue };
-        if ctx.doc.node(c).is_some_and(|cn| cn.is_mask && cn.visible) {
+    // Each child looked up once: in a large document a lookup is a good part of a layer's cost.
+    let nodes: Vec<Option<&Node>> = kids.iter().map(|c| ctx.bounds.node(ctx.doc, *c)).collect();
+    for run in Document::paint_runs_of(&nodes, n.layout.as_ref().is_some_and(|l| l.reverse_z)) {
+        let (Some(&c), Some(Some(cn))) = (kids.get(run.start), nodes.get(run.start)) else { continue };
+        if cn.is_mask && cn.visible {
             // Everything above the mask (until the next mask) is clipped by its alpha.
             draw_masked(ctx, pix, c, kids.get(run.start + 1..run.end).unwrap_or(&[]), xf, depth);
         } else {
-            draw_node(ctx, pix, c, xf, depth + 1);
+            draw_layer(ctx, pix, cn, xf, depth + 1);
         }
     }
 }
diff --git a/crates/render/src/lib.rs b/crates/render/src/lib.rs
index 9969a597d..2a9110766 100644
--- a/crates/render/src/lib.rs
+++ b/crates/render/src/lib.rs
@@ -90,7 +90,7 @@ fn new_pixmap(w: u32, h: u32) -> Option<Pixmap> {
 /// The largest backdrop radius (background blur, glass: see [`figcraft_doc::Effect::backdrop_radius`])
 /// in the document (0 without any).
 pub(crate) fn max_backdrop_blur(doc: &Document) -> f64 {
-    doc.nodes().flat_map(|n| n.effects.iter()).map(figcraft_doc::Effect::backdrop_radius).fold(0.0, f64::max)
+    doc.max_backdrop_radius()
 }
 
 /// How far (device pixels) a background blur of `radius` reads its backdrop at `scale`.
@@ -170,6 +170,7 @@ pub fn render_view_single(doc: &Document, page: NodeId, view: &View, opts: &Opti
         pix.fill(paint::ts_color(bg));
     }
     let lod = opts.lod && !opts.outline_mode && view.scale <= lod::MAX_SCALE;
+    let bounds = draw::Bounds::default();
     let ctx = draw::Ctx {
         doc,
         scale: view.scale,
@@ -180,6 +181,7 @@ pub fn render_view_single(doc: &Document, page: NodeId, view: &View, opts: &Opti
         lod,
         under: None,
         time: 0.0,
+        bounds: &bounds,
     };
     let xf = view.transform();
     let Some(p) = doc.node(page) else { return Some(pix) };
@@ -201,6 +203,7 @@ pub fn render_nodes_into(doc: &Document, ids: &[NodeId], view: &View, pix: &mut
 
 /// [`render_nodes_into`] `time` seconds into animated GIFs.
 fn nodes_into(doc: &Document, ids: &[NodeId], view: &View, pix: &mut Pixmap, time: f64) {
+    let bounds = draw::Bounds::default();
     let ctx = draw::Ctx {
         doc,
         scale: view.scale,
@@ -211,6 +214,7 @@ fn nodes_into(doc: &Document, ids: &[NodeId], view: &View, pix: &mut Pixmap, tim
         lod: false,
         under: None,
         time,
+        bounds: &bounds,
     };
     for id in ids {
         draw::draw_node(&ctx, pix, *id, view.transform() * parent_transform(doc, *id), 0);
@@ -434,6 +438,8 @@ mod band_tests;
 #[cfg(test)]
 mod boolean_cache_tests;
 #[cfg(test)]
+mod bounds_memo_tests;
+#[cfg(test)]
 mod effect_order_tests;
 #[cfg(test)]
 mod effects_behaviour_tests;
diff --git a/crates/render/src/lod.rs b/crates/render/src/lod.rs
index 6d7425857..a5b3ddc14 100644
--- a/crates/render/src/lod.rs
+++ b/crates/render/src/lod.rs
@@ -60,18 +60,47 @@ fn text_paints<'a>(n: &'a Node, t: &'a TextData) -> impl Iterator<Item = &'a Pai
 /// Whether the subtree of `n` can be splatted: no image or pattern paints (their colours aren't known
 /// without sampling them) and no masks (which change what their siblings show).
 pub fn splattable(doc: &Document, n: &Node, depth: usize) -> bool {
+    splattable_within(doc, n, depth, None).0
+}
+
+/// [`splattable`], kept in and read from `memo` when there is one (layers with children only).
+/// Also returns how many levels the walk went down, or `None` when the nesting cap decided it: such
+/// answers depend on the depth they were asked at and aren't kept, and kept answers are read only
+/// where their levels still fit under the cap.
+pub(crate) fn splattable_within<'a>(doc: &'a Document, n: &Node, depth: usize, memo: Option<&crate::draw::Bounds<'a>>) -> (bool, Option<usize>) {
     if depth > MAX_DEPTH {
-        return false;
+        return (false, None);
+    }
+    let memo = memo.filter(|_| !n.children.is_empty());
+    if let Some((ok, levels)) = memo.and_then(|m| m.splat.borrow().get(&n.id).copied())
+        && depth + levels <= MAX_DEPTH
+    {
+        return (ok, Some(levels));
     }
     let image = |p: &Paint| p.visible && matches!(p.kind, PaintKind::Image(_) | PaintKind::Pattern(_));
     let own = match &n.kind {
         NodeKind::Text(t) => text_paints(n, t).any(image),
         _ => n.fills.iter().any(image),
     };
-    if own || n.strokes.iter().any(image) {
-        return false;
+    let (mut ok, mut below) = (!(own || n.strokes.iter().any(image)), Some(0));
+    if ok {
+        for c in n.children.iter().filter_map(|c| memo.map_or_else(|| doc.node(*c), |m| m.node(doc, *c))).filter(|c| c.visible) {
+            if c.is_mask {
+                ok = false;
+                break;
+            }
+            let (c_ok, c_levels) = splattable_within(doc, c, depth + 1, memo);
+            below = below.zip(c_levels).map(|(b, l)| b.max(l + 1));
+            if !c_ok {
+                ok = false;
+                break;
+            }
+        }
     }
-    n.children.iter().filter_map(|c| doc.node(*c)).filter(|c| c.visible).all(|c| !c.is_mask && splattable(doc, c, depth + 1))
+    if let (Some(m), Some(l)) = (memo, below) {
+        m.splat.borrow_mut().insert(n.id, (ok, l));
+    }
+    (ok, below)
 }
 
 /// A paint's average colour as straight RGBA (alpha times the paint's opacity); `None` for
@@ -199,7 +228,7 @@ pub fn splat_subtree(ctx: &Ctx, pix: &mut Pixmap, n: &Node, xf: Affine, clip: Op
         } else {
             clip
         };
-        for c in n.paint_order().filter_map(|c| ctx.doc.node(c)) {
+        for c in n.paint_order().filter_map(|c| ctx.bounds.node(ctx.doc, c)) {
             splat_subtree(ctx, pix, c, xf * c.transform, clip, alpha, depth + 1);
         }
     }
diff --git a/crates/render/src/lod_tests.rs b/crates/render/src/lod_tests.rs
index de8b52b40..a573ee7cc 100644
--- a/crates/render/src/lod_tests.rs
+++ b/crates/render/src/lod_tests.rs
@@ -154,6 +154,7 @@ fn exports_never_use_lod() {
     crate::render_nodes_into(&d, &[card], &v, &mut exact);
     assert_eq!(png.data(), exact.data());
     let mut preview = Pixmap::new(v.width, v.height).unwrap();
+    let bounds = crate::draw::Bounds::default();
     let ctx = crate::draw::Ctx {
         doc: &d,
         scale,
@@ -164,6 +165,7 @@ fn exports_never_use_lod() {
         lod: true,
         under: None,
         time: 0.0,
+        bounds: &bounds,
     };
     let parent = d.world_transform(p);
     crate::draw::draw_node(&ctx, &mut preview, card, v.transform() * parent, 0);
diff --git a/crates/render/src/paint_behaviour_tests.rs b/crates/render/src/paint_behaviour_tests.rs
index f4bad2ca2..30c583d03 100644
--- a/crates/render/src/paint_behaviour_tests.rs
+++ b/crates/render/src/paint_behaviour_tests.rs
@@ -630,3 +630,35 @@ fn changing_the_colour_profile_converts_or_keeps_values() {
     let seen = draw(&kept);
     assert!(seen[0] > before[0] && seen[2] < before[2], "kept values look more saturated: {seen:?} vs {before:?}");
 }
+
+// ---- strokes on text ----
+
+#[test]
+fn text_strokes_follow_their_alignment() {
+    // #615: as on other shapes (and in SVG export), an inside stroke stays in the glyphs, a centre
+    // one reaches half its weight past them and an outside one all of it.
+    figcraft_text::scan_system_fonts();
+    let left_edge = |align: StrokeAlign| -> Option<u32> {
+        let (mut d, p) = page();
+        let mut td = figcraft_doc::TextData::new("I");
+        td.style.font_size = 120.0;
+        let t = d.create(p, NodeKind::Text(td), "T", 60.0, 30.0, 1.0, 1.0).unwrap();
+        let n = d.get_mut(t).unwrap();
+        n.fills.clear();
+        n.strokes = vec![Paint::solid(hex("#000000"))];
+        n.stroke.weight = 12.0;
+        n.stroke.align = align;
+        let (w, h) = figcraft_text::auto_size(n)?;
+        (n.width, n.height) = (w, h);
+        let pix = render(&d);
+        (0..200).find(|x| (0..200).any(|y| px(&pix, *x, y)[0] < 128))
+    };
+    let (Some(inside), Some(centre), Some(outside)) =
+        (left_edge(StrokeAlign::Inside), left_edge(StrokeAlign::Center), left_edge(StrokeAlign::Outside))
+    else {
+        eprintln!("no font to draw text with; skipping");
+        return;
+    };
+    assert!((5..=7).contains(&(inside - centre)), "centre reaches half the weight past inside: {inside} → {centre}");
+    assert!((5..=7).contains(&(centre - outside)), "outside reaches the rest: {centre} → {outside}");
+}
diff --git a/crates/render/src/pattern.rs b/crates/render/src/pattern.rs
index bfcf8e328..2489766cd 100644
--- a/crates/render/src/pattern.rs
+++ b/crates/render/src/pattern.rs
@@ -9,7 +9,7 @@ use figcraft_doc::{Document, NodeId};
 use figcraft_geom::Affine;
 use tiny_skia::{FilterQuality, Pixmap, SpreadMode, Transform};
 
-use crate::draw::{Ctx, draw_node};
+use crate::draw::{Bounds, Ctx, draw_node};
 use crate::paint::Prepared;
 
 /// The largest side of a cell's pixmap; a cell showing larger is drawn coarser.
@@ -46,6 +46,7 @@ pub fn cell_pixmap(doc: &Document, pt: &PatternPaint, w: f64, h: f64, scale: f64
     let (pw, ph) = ((cell.size.0 * k).ceil().clamp(1.0, MAX_CELL_PX), (cell.size.1 * k).ceil().clamp(1.0, MAX_CELL_PX));
     let (kx, ky) = (pw / cell.size.0, ph / cell.size.1);
     let mut pix = Pixmap::new(pw as u32, ph as u32)?;
+    let bounds = Bounds::default();
     let ctx = Ctx {
         doc,
         scale: kx.max(ky) * cell.scale,
@@ -56,6 +57,7 @@ pub fn cell_pixmap(doc: &Document, pt: &PatternPaint, w: f64, h: f64, scale: f64
         lod: false,
         under: None,
         time,
+        bounds: &bounds,
     };
     let unrotated = src.transform.inverse();
     nested(|| {
diff --git a/crates/render/src/tests.rs b/crates/render/src/tests.rs
index 554881536..a5a598316 100644
--- a/crates/render/src/tests.rs
+++ b/crates/render/src/tests.rs
@@ -129,6 +129,27 @@ fn strokes_align() {
     assert_eq!(px(&pix, 30, 8)[0], 0xF5);
 }
 
+#[test]
+fn side_strokes_follow_rounded_corners() {
+    // border-l-4 rounded-r-lg: a straight 4 px bar on the left, nothing on the other edges.
+    let mut d = figcraft_doc::Document::new("t");
+    let p = d.first_page().unwrap();
+    let f = d.create(p, NodeKind::Frame, "F", 10.0, 10.0, 120.0, 60.0).unwrap();
+    let n = d.get_mut(f).unwrap();
+    n.fills = vec![Paint::solid(Color::WHITE)];
+    n.corners.radii = [0.0, 8.0, 8.0, 0.0];
+    n.strokes = vec![Paint::solid(Color::BLACK)];
+    n.stroke.align = StrokeAlign::Inside;
+    n.stroke.sides = Some([0.0, 0.0, 0.0, 4.0]);
+    let pix = render_view(&d, p, &view(150, 80), &Options::default()).unwrap();
+    for x in 10..14 {
+        assert_eq!(px(&pix, x, 40), [0, 0, 0, 255], "x {x}");
+    }
+    for (x, y) in [(14, 40), (129, 40), (126, 12), (126, 67), (70, 10), (70, 69)] {
+        assert_eq!(px(&pix, x, y), [255, 255, 255, 255], "({x}, {y})");
+    }
+}
+
 #[test]
 fn mask_clips_siblings() {
     let mut d = figcraft_doc::Document::new("t");
diff --git a/crates/svg/src/import/mod.rs b/crates/svg/src/import/mod.rs
index fdae71560..521146fb1 100644
--- a/crates/svg/src/import/mod.rs
+++ b/crates/svg/src/import/mod.rs
@@ -377,15 +377,38 @@ fn path(cx: &mut Ctx, p: &usvg::Path, parent: NodeId, base: Affine) {
                 return;
             }
             path.apply_affine(Affine::translate((-bb.x0, -bb.y0)));
-            let mut network = VectorNetwork::from_path(&path);
             let rule = if fill.is_some_and(|f| f.rule() == usvg::FillRule::EvenOdd) { WindingRule::EvenOdd } else { WindingRule::NonZero };
-            for r in &mut network.regions {
-                r.winding = rule;
+            let vector = |path: &BezPath, filled: bool| {
+                let mut network = VectorNetwork::from_path(path);
+                for r in &mut network.regions {
+                    r.winding = rule;
+                }
+                if !filled {
+                    network.regions.clear();
+                }
+                NodeKind::Vector { network }
+            };
+            let at = Affine::translate((bb.x0, bb.y0));
+            // Fill closes every subpath; a stroke only those that close themselves. A filled
+            // and stroked path with a really open subpath becomes a fill layer and a stroke layer.
+            let tol = CLOSE_TOLERANCE * bb.width().max(bb.height());
+            let (snapped, closed) = (closed_for_fill(&path, tol, false), closed_for_fill(&path, tol, true));
+            if let (Some(_), Some(_)) = (fill, stroke)
+                && snapped != closed
+            {
+                let fill_only =
+                    Node::new(cx.doc.alloc_id(), vector(&closed, true), format!("{} fill", layer_name(p.id(), "Vector")), bb.width(), bb.height());
+                let stroke_only = Node::new(cx.doc.alloc_id(), vector(&snapped, false), layer_name(p.id(), "Vector"), bb.width(), bb.height());
+                let mut layers = [paint_path(cx, p, fill_only, at, world, true, false), paint_path(cx, p, stroke_only, at, world, false, true)];
+                if p.paint_order() == usvg::PaintOrder::StrokeAndFill {
+                    layers.reverse();
+                }
+                for n in layers {
+                    cx.add(n, parent);
+                }
+                return;
             }
-            if fill.is_none() {
-                network.regions.clear();
-            }
-            (NodeKind::Vector { network }, Affine::translate((bb.x0, bb.y0)), bb.width(), bb.height(), 0.0)
+            (vector(if fill.is_some() { &closed } else { &path }, fill.is_some()), at, bb.width(), bb.height(), 0.0)
         }
     };
     let fallback = match kind {
@@ -395,12 +418,18 @@ fn path(cx: &mut Ctx, p: &usvg::Path, parent: NodeId, base: Affine) {
         _ => "Vector",
     };
     let mut n = Node::new(cx.doc.alloc_id(), kind, layer_name(p.id(), fallback), w, h);
-    n.transform = transform;
     n.corners.radii = [radius; 4];
-    let target = Target { to_node: transform.inverse() * world, size: (w, h) };
-    n.fills = fill.and_then(|f| paint::paint(cx, f.paint(), f.opacity().get(), target)).into_iter().collect();
+    let n = paint_path(cx, p, n, transform, world, true, true);
+    cx.add(n, parent);
+}
+
+/// Layer `n` of path `p` placed at `transform`, with the path's fill and / or stroke.
+fn paint_path(cx: &mut Ctx, p: &usvg::Path, mut n: Node, transform: Affine, world: Affine, with_fill: bool, with_stroke: bool) -> Node {
+    n.transform = transform;
+    let target = Target { to_node: transform.inverse() * world, size: (n.width, n.height) };
+    n.fills = p.fill().filter(|_| with_fill).and_then(|f| paint::paint(cx, f.paint(), f.opacity().get(), target)).into_iter().collect();
     n.strokes.clear();
-    if let Some(s) = stroke {
+    if let Some(s) = p.stroke().filter(|_| with_stroke) {
         n.strokes = paint::paint(cx, s.paint(), s.opacity().get(), target).into_iter().collect();
         n.stroke = stroke_props(s, length_scale(world));
         // A stroke painted under the fill shows only its outer half.
@@ -409,7 +438,54 @@ fn path(cx: &mut Ctx, p: &usvg::Path, parent: NodeId, base: Affine) {
             n.stroke.weight /= 2.0;
         }
     }
-    cx.add(n, parent);
+    n
+}
+
+/// How far (as a share of the path's larger side) a subpath may end from its start and still be
+/// closed onto it: exporters that round coordinates leave closed outlines this far apart.
+const CLOSE_TOLERANCE: f64 = 1e-3;
+
+/// `path` with the subpaths that end within `tol` of their start closed onto it and, with `all`
+/// (SVG fills every subpath as if closed), every other subpath of two or more segments closed
+/// with a straight segment.
+fn closed_for_fill(path: &BezPath, tol: f64, all: bool) -> BezPath {
+    use figcraft_geom::kurbo::PathEl;
+    let mut out = BezPath::new();
+    let mut sub: Vec<PathEl> = Vec::new();
+    let flush = |sub: &mut Vec<PathEl>, out: &mut BezPath| {
+        let start = match sub.first() {
+            Some(PathEl::MoveTo(p)) => *p,
+            _ => {
+                sub.clear();
+                return;
+            }
+        };
+        let open = !matches!(sub.last(), Some(PathEl::ClosePath));
+        let segments = sub.len() - 1;
+        if open && segments >= 2 {
+            let near = sub.last().and_then(|e| e.end_point()).is_some_and(|end| (end - start).hypot() <= tol);
+            if near && let Some(last) = sub.last_mut() {
+                match last {
+                    PathEl::LineTo(p) | PathEl::QuadTo(_, p) | PathEl::CurveTo(_, _, p) => *p = start,
+                    PathEl::MoveTo(_) | PathEl::ClosePath => {}
+                }
+            }
+            if near || all {
+                sub.push(PathEl::ClosePath);
+            }
+        }
+        for e in sub.drain(..) {
+            out.push(e);
+        }
+    };
+    for e in path.elements() {
+        if matches!(e, PathEl::MoveTo(_)) {
+            flush(&mut sub, &mut out);
+        }
+        sub.push(*e);
+    }
+    flush(&mut sub, &mut out);
+    out
 }
 
 /// A recognised primitive placed by `world`: its kind, transform, size and corner radius. `None`
diff --git a/crates/svg/src/lib.rs b/crates/svg/src/lib.rs
index a68130175..38abc14ea 100644
--- a/crates/svg/src/lib.rs
+++ b/crates/svg/src/lib.rs
@@ -79,6 +79,8 @@ struct W<'a> {
     clip: Option<String>,
     /// `id` attributes written so far.
     used_ids: std::collections::BTreeSet<String>,
+    /// The next `_k` suffix to try per base id, so repeated names don't rescan from `_2`.
+    next_suffix: std::collections::HashMap<String, usize>,
 }
 
 /// ` clip-path="url(#…)"` for a clip path id (else nothing).
@@ -150,8 +152,16 @@ fn blend_style(b: figcraft_color::BlendMode) -> String {
     }
 }
 
+/// `s` escaped for XML text and attribute values; characters XML 1.0 forbids (control characters
+/// other than tab, newline and carriage return, U+FFFE and U+FFFF) are left out.
 fn esc(s: &str) -> String {
-    s.replace('&', "&amp;").replace('<', "&lt;").replace('>', "&gt;").replace('"', "&quot;")
+    s.chars()
+        .filter(|&c| !matches!(c, '\u{0}'..='\u{8}' | '\u{b}' | '\u{c}' | '\u{e}'..='\u{1f}' | '\u{fffe}' | '\u{ffff}'))
+        .collect::<String>()
+        .replace('&', "&amp;")
+        .replace('<', "&lt;")
+        .replace('>', "&gt;")
+        .replace('"', "&quot;")
 }
 
 fn hex(c: Color) -> String {
@@ -160,8 +170,13 @@ fn hex(c: Color) -> String {
 
 impl W<'_> {
     fn id(&mut self, prefix: &str) -> String {
-        self.next += 1;
-        format!("{prefix}{}", self.next)
+        loop {
+            self.next += 1;
+            let id = format!("{prefix}{}", self.next);
+            if self.used_ids.insert(id.clone()) {
+                return id;
+            }
+        }
     }
 
     /// `fill="..." [fill-opacity]` for a paint on a w×h box; `None` when it paints nothing.
@@ -549,7 +564,15 @@ impl W<'_> {
     fn unique_id(&mut self, name: &str) -> String {
         let base: String = name.chars().take(200).map(|c| if c.is_whitespace() || c.is_control() { '_' } else { c }).collect();
         let base = if base.is_empty() { "layer".to_string() } else { base };
-        let id = (1..).map(|k| if k == 1 { base.clone() } else { format!("{base}_{k}") }).find(|i| !self.used_ids.contains(i)).unwrap_or(base);
+        let next = self.next_suffix.entry(base.clone()).or_insert(1);
+        let id = loop {
+            let k = *next;
+            *next += 1;
+            let candidate = if k == 1 { base.clone() } else { format!("{base}_{k}") };
+            if !self.used_ids.contains(&candidate) {
+                break candidate;
+            }
+        };
         self.used_ids.insert(id.clone());
         id
     }
@@ -586,7 +609,8 @@ impl W<'_> {
                         }
                         let end = glyphs.get(j).map_or(line.char_end, |g| g.char_start).max(start).min(chars.len());
                         let text: String = chars.get(start.min(end)..end).unwrap_or(&[]).iter().collect();
-                        let text = st.case.apply(text.trim_end_matches(['\n', '\r']));
+                        let prev = start.checked_sub(1).and_then(|k| chars.get(k)).copied();
+                        let text = st.case.apply_after(text.trim_end_matches(['\n', '\r']), prev);
                         let own = match layout.styles.get(style).and_then(|s| s.fills.as_ref()) {
                             Some(fills) => {
                                 let a = fills.iter().find_map(|p| self.paint_attr(p, n.width, n.height)).unwrap_or_else(|| "fill=\"none\"".into());
@@ -601,7 +625,8 @@ impl W<'_> {
                     continue;
                 }
                 let text: String = chars.get(line.char_start..line.char_end.min(chars.len())).unwrap_or(&[]).iter().collect();
-                let text = st.case.apply(text.trim_end_matches(['\n', '\r']));
+                let prev = line.char_start.checked_sub(1).and_then(|k| chars.get(k)).copied();
+                let text = st.case.apply_after(text.trim_end_matches(['\n', '\r']), prev);
                 let (x, y) = layout.glyphs.get(line.glyph_start).map_or((0.0, line.baseline), |g| (g.x, g.y));
                 let _ = write!(spans, "<tspan x=\"{}\" y=\"{}\">{}</tspan>", num(x), num(y), esc(&text));
             }
@@ -638,7 +663,7 @@ impl W<'_> {
             || k.brush.is_some()
             || k.cap_start.is_arrow()
             || k.cap_end.is_arrow()
-            || matches!(&n.kind, NodeKind::Vector { network } if network.has_point_styles())
+            || matches!(&n.kind, NodeKind::Vector { network } if network.has_point_styles(k.join))
             || !(w.is_finite() && w > 0.0)
         {
             return None;
@@ -1002,6 +1027,7 @@ pub fn try_export_svg(doc: &Document, ids: &[NodeId], opts: &SvgOptions) -> Resu
         mask: None,
         clip: None,
         used_ids: Default::default(),
+        next_suffix: Default::default(),
     };
     for id in ids {
         let parent_xf = doc.node(*id).and_then(|n| n.parent).map(|p| doc.world_transform(p)).unwrap_or(Affine::IDENTITY);
diff --git a/crates/svg/src/tests.rs b/crates/svg/src/tests.rs
index b15cd999d..3936c37c2 100644
--- a/crates/svg/src/tests.rs
+++ b/crates/svg/src/tests.rs
@@ -115,3 +115,135 @@ fn text_run_fill_survives_live_text_export() {
     assert!(svg.contains("#000000"), "{svg}");
     assert!(svg.contains("fill=\"#00FF00\"") && svg.contains(">b</tspan>") && svg.contains(">a</tspan>"), "{svg}");
 }
+
+#[test]
+fn title_case_does_not_restart_words_across_fill_runs_in_live_text() {
+    use figcraft_doc::{StyleRun, TextCase, TextData};
+    figcraft_text::scan_system_fonts();
+    let mut d = Document::new("t");
+    let page = d.first_page().unwrap();
+    let mut text = TextData::new("hello");
+    text.style.font_size = 24.0;
+    text.style.case = TextCase::Title;
+    let mut style = text.style.clone();
+    style.fills = Some(vec![Paint::solid(Color::from_hex("00FF00").unwrap())]);
+    text.runs.push(StyleRun { start: 2, end: 3, style });
+    text.normalize();
+    let id = d.create(page, NodeKind::Text(text), "Text", 0.0, 0.0, 200.0, 40.0).unwrap();
+    d.get_mut(id).unwrap().fills = vec![Paint::solid(Color::BLACK)];
+    let svg = export_svg(&d, &[id], &SvgOptions { outline_text: false, ..SvgOptions::default() }).unwrap();
+    assert!(svg.contains(">He</tspan>") && svg.contains(">l</tspan>") && svg.contains(">lo</tspan>"), "{svg}");
+}
+
+/// Control characters in text (a pasted vertical-tab soft break, U+0001) are not allowed in XML:
+/// live-text export must leave them out so the SVG still parses, for plain and per-run spans.
+#[test]
+fn live_text_export_drops_xml_forbidden_control_characters() {
+    use figcraft_doc::{StyleRun, TextData};
+    figcraft_text::scan_system_fonts();
+    for styled in [false, true] {
+        let mut d = Document::new("t");
+        let page = d.first_page().unwrap();
+        let mut text = TextData::new("line one\u{b}line two\u{1}");
+        text.style.font_size = 24.0;
+        if styled {
+            let mut style = text.style.clone();
+            style.fills = Some(vec![Paint::solid(Color::from_hex("00FF00").unwrap())]);
+            text.runs.push(StyleRun { start: 5, end: 12, style });
+            text.normalize();
+        }
+        let id = d.create(page, NodeKind::Text(text), "Text", 0.0, 0.0, 600.0, 40.0).unwrap();
+        d.get_mut(id).unwrap().fills = vec![Paint::solid(Color::BLACK)];
+        let svg = export_svg(&d, &[id], &SvgOptions { outline_text: false, ..SvgOptions::default() }).unwrap();
+        assert!(!svg.contains('\u{b}') && !svg.contains('\u{1}'), "{svg:?}");
+        assert!(svg.contains("line") && svg.contains("two"), "{svg}");
+        let mut d2 = Document::new("t2");
+        let p2 = d2.first_page().unwrap();
+        assert!(import_svg(&mut d2, svg.as_bytes(), p2, 0.0, 0.0, "x").is_ok(), "{svg:?}");
+    }
+}
+
+#[test]
+fn side_strokes_on_rounded_corners_export_as_their_area() {
+    // border-l-4 rounded-r-lg: the stroke path is the 4 px bar (60 px tall), drawn even-odd.
+    use figcraft_geom::Shape;
+    let mut d = Document::new("t");
+    let p = d.first_page().unwrap();
+    let f = d.create(p, NodeKind::Frame, "F", 0.0, 0.0, 120.0, 60.0).unwrap();
+    let n = d.get_mut(f).unwrap();
+    n.corners.radii = [0.0, 8.0, 8.0, 0.0];
+    n.strokes = vec![Paint::solid(Color::from_hex("FF0000").unwrap())];
+    n.stroke.align = figcraft_doc::StrokeAlign::Inside;
+    n.stroke.sides = Some([0.0, 0.0, 0.0, 4.0]);
+    let svg = export_svg(&d, &[f], &SvgOptions::default()).unwrap();
+    let stroke = svg.split("<path").find(|e| e.contains("#FF0000")).unwrap();
+    assert!(stroke.contains("fill-rule=\"evenodd\""), "{stroke}");
+    let data = stroke.split("d=\"").nth(1).and_then(|s| s.split('"').next()).unwrap();
+    let area = figcraft_geom::BezPath::from_svg(data).unwrap().area().abs();
+    assert!((area - 240.0).abs() < 0.01, "{area}");
+}
+
+#[test]
+fn point_joins_equal_to_the_layer_join_keep_a_plain_stroke() {
+    use figcraft_doc::{StrokeJoin, VectorNetwork};
+    use figcraft_geom::kurbo::Point;
+    let svg_with = |join: StrokeJoin| {
+        let mut network = VectorNetwork::from_points(&[Point::new(0.0, 0.0), Point::new(50.0, 50.0), Point::new(100.0, 0.0)], false);
+        for v in &mut network.vertices {
+            v.join = Some(StrokeJoin::Miter);
+        }
+        if let Some(v) = network.vertices.get_mut(1) {
+            v.join = Some(join);
+        }
+        let mut d = Document::new("t");
+        let p = d.first_page().unwrap();
+        let v = d.create(p, NodeKind::Vector { network }, "V", 0.0, 0.0, 100.0, 50.0).unwrap();
+        let n = d.get_mut(v).unwrap();
+        n.strokes = vec![Paint::solid(Color::from_hex("000000").unwrap())];
+        n.stroke.weight = 2.0;
+        n.stroke.join = StrokeJoin::Miter;
+        export_svg(&d, &[v], &SvgOptions::default()).unwrap()
+    };
+    assert!(svg_with(StrokeJoin::Miter).contains("stroke-width=\"2\""), "equal joins stay a stroke");
+    assert!(!svg_with(StrokeJoin::Round).contains("stroke-width="), "a differing join is drawn as an outline");
+}
+
+#[test]
+fn unique_id_is_linear_for_repeated_names() {
+    let d = Document::new("t");
+    let opts = SvgOptions::default();
+    let mut w = W {
+        doc: &d,
+        roots: &[],
+        page: Affine::IDENTITY,
+        defs: String::new(),
+        body: String::new(),
+        next: 0,
+        opts: &opts,
+        mask: None,
+        clip: None,
+        used_ids: Default::default(),
+        next_suffix: Default::default(),
+    };
+    assert_eq!(w.unique_id("a"), "a");
+    assert_eq!(w.unique_id("a_3"), "a_3");
+    assert_eq!(w.unique_id("a"), "a_2");
+    assert_eq!(w.unique_id("a"), "a_4");
+    let start = std::time::Instant::now();
+    for _ in 0..30_000 {
+        w.unique_id("Rectangle");
+    }
+    assert_eq!(w.unique_id("Rectangle"), "Rectangle_30001");
+    assert!(start.elapsed() < std::time::Duration::from_secs(2), "unique_id is quadratic: {:?}", start.elapsed());
+}
+
+#[test]
+fn layer_ids_never_clash_with_generated_ids() {
+    let mut d = Document::new("t");
+    let p = d.first_page().unwrap();
+    let f = d.create(p, NodeKind::Frame, "clip1", 0.0, 0.0, 100.0, 100.0).unwrap();
+    d.get_mut(f).unwrap().clip = true;
+    d.create(f, NodeKind::Rectangle, "R", 0.0, 0.0, 50.0, 50.0).unwrap();
+    let svg = export_svg(&d, &[f], &SvgOptions { include_ids: true, ..SvgOptions::default() }).unwrap();
+    assert_eq!(svg.matches("id=\"clip1\"").count(), 1, "{svg}");
+}
diff --git a/crates/svg/tests/corpus.rs b/crates/svg/tests/corpus.rs
index 35f6f9f45..24803c40e 100644
--- a/crates/svg/tests/corpus.rs
+++ b/crates/svg/tests/corpus.rs
@@ -243,6 +243,27 @@ fn groups_keep_their_ids_and_transforms_bake_into_shapes() {
     assert_eq!(layer(&d, f, "d").kind.type_name(), "VECTOR");
 }
 
+#[test]
+fn fills_close_open_subpaths() {
+    let (d, f) = imported("open_subpaths");
+    let loops = |n: &figcraft_doc::Node| match &n.kind {
+        NodeKind::Vector { network } => network.regions.iter().map(|r| r.loops.len()).sum::<usize>(),
+        _ => 0,
+    };
+    // One filled layer: all four subpaths are fill loops, the 0.001 gap and the triangle included.
+    let filled = layer(&d, f, "filled");
+    assert_eq!((filled.kind.type_name(), loops(filled), filled.strokes.len()), ("VECTOR", 4, 0));
+    // Filled and stroked with an open triangle: a fill layer under the stroke, which stays open.
+    let (fill, stroke) = (layer(&d, f, "stroked fill"), layer(&d, f, "stroked"));
+    assert_eq!((loops(fill), fill.fills.len(), fill.strokes.len()), (2, 1, 0));
+    assert_eq!((loops(stroke), stroke.fills.len(), stroke.strokes.len()), (0, 0, 1));
+    // Only near-closed ends: one layer, closed, stroke and all.
+    let near = layer(&d, f, "near");
+    assert_eq!((loops(near), near.fills.len(), near.strokes.len()), (1, 1, 1));
+    let order: Vec<&str> = d.node(f).unwrap().children.iter().filter_map(|c| d.node(*c)).map(|n| n.name.as_str()).collect();
+    assert_eq!(order, ["filled", "stroked fill", "stroked", "near", "under", "under fill"], "paint order: fill then stroke, or the stroke first");
+}
+
 #[test]
 fn basic_shapes_stay_rectangles_ellipses_and_lines() {
     let (d, f) = imported("primitives");
diff --git a/crates/svg/tests/corpus/open_subpaths.svg b/crates/svg/tests/corpus/open_subpaths.svg
new file mode 100644
index 000000000..daed50b7d
--- /dev/null
+++ b/crates/svg/tests/corpus/open_subpaths.svg
@@ -0,0 +1,28 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="120">
+  <!-- Fill closes every subpath (SVG painting: "fill ... as if a closepath"). Top row, one filled
+       path: closed with Z; back on its start without Z; 0.001 short of its start without Z (what
+       PDF exports rounded to three decimals write); an open triangle. Bottom row, filled and
+       stroked: 0.001 short (closed, stroke and all); an open triangle (stroked open). Third row,
+       filled and stroked: only 0.001 short (one layer); an open triangle with its stroke under
+       the fill. -->
+  <path id="filled" fill="#000000" d="M10 10h20v20h-20z M50 10h20v20h-20v-20 M90 10h20v20h-20v-19.999 M130 10h20v20"/>
+  <path id="stroked" fill="#000000" stroke="#ff0000" stroke-width="2" d="M10 50h20v20h-20v-19.999 M130 50h20v20"/>
+  <path id="near" fill="#000000" stroke="#ff0000" stroke-width="2" d="M50 90h20v20h-20v-19.999"/>
+  <path id="under" fill="#000000" stroke="#ff0000" stroke-width="2" paint-order="stroke" d="M130 90h20v20"/>
+  <!-- probe 20 20 #000000ff -->
+  <!-- probe 60 20 #000000ff -->
+  <!-- probe 100 20 #000000ff -->
+  <!-- probe 145 15 #000000ff -->
+  <!-- probe 135 25 #00000000 -->
+  <!-- probe 20 60 #000000ff -->
+  <!-- probe 10 60 #ff0000ff -->
+  <!-- probe 140 50 #ff0000ff -->
+  <!-- probe 145 55 #000000ff -->
+  <!-- probe 135 65 #00000000 -->
+  <!-- probe 60 100 #000000ff -->
+  <!-- probe 50 100 #ff0000ff -->
+  <!-- probe 140 89 #ff0000ff -->
+  <!-- probe 140 90 #000000ff -->
+  <!-- probe 145 95 #000000ff -->
+  <!-- probe 135 105 #00000000 -->
+</svg>
diff --git a/crates/text/build.rs b/crates/text/build.rs
index d02defefe..05dfc6533 100644
--- a/crates/text/build.rs
+++ b/crates/text/build.rs
@@ -65,9 +65,10 @@ fn craft_fonts(dir: &std::path::Path, manifest_rel: &str) -> Result<String, Stri
         if cjk && std::env::var_os("FIGCRAFT_EMBED_CJK").is_none() {
             continue;
         }
-        // Web builds have a size budget: Inter, plus Noto Sans CJK (every CJK script, for CJK UI
-        // text) when asked.
-        if wasm && *family != "Inter" && !cjk {
+        // Web builds have a size budget: Inter, Noto Sans Georgian (small, for the Georgian UI), only the
+        // SemiBold wordmark, and optionally Noto Sans CJK (every CJK script, for CJK UI text).
+        let wordmark = *family == "Archivo" && *style == "SemiBold";
+        if wasm && !matches!(*family, "Inter" | "Noto Sans Georgian") && !wordmark && !cjk {
             continue;
         }
         let path = dir.join(file).canonicalize().map_err(|e| format!("{file}: {e}"))?;
diff --git a/crates/text/src/breaks.rs b/crates/text/src/breaks.rs
index 3f5458ead..8012de335 100644
--- a/crates/text/src/breaks.rs
+++ b/crates/text/src/breaks.rs
@@ -39,7 +39,7 @@ fn class(c: char) -> Class {
         return Class::Close;
     }
     match c {
-        ' ' | '\t' | '\u{3000}' | '\u{2002}'..='\u{200B}' => Class::Space,
+        ' ' | '\t' | '\u{3000}' | '\u{2002}'..='\u{2006}' | '\u{2008}'..='\u{200B}' => Class::Space,
         '-' | '/' | '\u{2010}' | '\u{2013}' | '\u{2014}' => Class::Hyphen,
         '\u{2E80}'..='\u{2FFF}'
         | '\u{3003}'..='\u{33FF}'
@@ -98,3 +98,15 @@ pub fn grapheme_step(text: &str, index: usize, forward: bool) -> usize {
     }
     at.min(index)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn figure_space_is_non_breaking() {
+        assert!(!break_between('\u{2007}', '0'));
+        assert!(!break_between('1', '\u{2007}'));
+        assert!(!is_space('\u{2007}'));
+    }
+}
diff --git a/crates/text/src/fontdb.rs b/crates/text/src/fontdb.rs
index d5ff41907..604f3eee5 100644
--- a/crates/text/src/fontdb.rs
+++ b/crates/text/src/fontdb.rs
@@ -406,7 +406,7 @@ fn names(f: &skrifa::FontRef) -> (Option<String>, Option<String>) {
 }
 
 /// Families tried, in order, for characters a text's own font lacks.
-const FALLBACK_FAMILIES: [&str; 18] = [
+const FALLBACK_FAMILIES: [&str; 20] = [
     "Inter",
     "Helvetica Neue",
     "Arial",
@@ -416,6 +416,8 @@ const FALLBACK_FAMILIES: [&str; 18] = [
     "BIZ UDPGothic",
     "Hiragino Sans",
     "PingFang SC",
+    "Hiragino Sans GB",
+    "Heiti SC",
     "Noto Sans CJK SC",
     "Microsoft YaHei",
     "Apple SD Gothic Neo",
@@ -442,9 +444,22 @@ pub struct FontDb {
     families: BTreeMap<String, (String, Vec<usize>)>,
     /// System faces known by name but not loaded (lower-case family → entries).
     pending: BTreeMap<String, (String, Vec<Pending>)>,
+    /// System faces read from disk (file, face index), so a rescan only offers new ones.
+    loaded_files: std::collections::BTreeSet<(std::path::PathBuf, u32)>,
+    /// Font files added as bytes (hash and length → families), so loading one again adds nothing.
+    loaded_bytes: std::collections::HashMap<(u64, usize), Vec<String>>,
     system_scanned: bool,
 }
 
+/// What a later walk of the font folders found ([`rescan_system_fonts`]).
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct Rescan {
+    /// Families that were unknown before.
+    pub added: Vec<String>,
+    /// Every family that gained faces: the new ones and those with styles installed since.
+    pub changed: Vec<String>,
+}
+
 static DB: OnceLock<RwLock<FontDb>> = OnceLock::new();
 /// Set by [`scan_system_fonts_on_demand`].
 static ON_DEMAND: AtomicBool = AtomicBool::new(false);
@@ -578,6 +593,7 @@ impl FontDb {
             };
             if let Some(face) = Face::from_bytes(FontBytes::Shared(bytes), e.index, None, Some(&e.style)) {
                 self.add(face);
+                self.loaded_files.insert((e.path, e.index));
             }
         }
     }
@@ -668,6 +684,35 @@ impl FontDb {
         self.faces.len()
     }
 
+    /// Offer the families of a later walk of the font folders: new families become pending, a
+    /// family not loaded yet takes the walk's files, and a loaded family keeps its faces and gets
+    /// the files it hasn't read (styles installed since) as pending, read when it is next used.
+    fn merge_rescan(&mut self, found: BTreeMap<String, (String, Vec<Pending>)>) -> Rescan {
+        let mut out = Rescan::default();
+        for (k, (display, entries)) in found {
+            if self.families.contains_key(&k) {
+                let waiting = self.pending.get(&k).map(|(_, v)| v.clone()).unwrap_or_default();
+                let new: Vec<Pending> = entries
+                    .into_iter()
+                    .filter(|e| {
+                        !self.loaded_files.contains(&(e.path.clone(), e.index)) && !waiting.iter().any(|w| w.path == e.path && w.index == e.index)
+                    })
+                    .collect();
+                if !new.is_empty() {
+                    out.changed.push(display.clone());
+                    self.pending.entry(k).or_insert_with(|| (display, Vec::new())).1.extend(new);
+                }
+                continue;
+            }
+            if !self.pending.contains_key(&k) {
+                out.added.push(display.clone());
+            }
+            out.changed.push(display.clone());
+            self.pending.insert(k, (display, entries));
+        }
+        out
+    }
+
     /// Index the system font directories (desktop only): family names are read now, faces loaded
     /// when first used. Safe to call more than once.
     pub fn scan_system(&mut self) {
@@ -691,11 +736,17 @@ fn system_font_dirs() -> Vec<std::path::PathBuf> {
     let mut v: Vec<std::path::PathBuf> = Vec::new();
     #[cfg(target_os = "macos")]
     {
+        // Subfolders (`Supplemental`) are walked too.
         v.push("/System/Library/Fonts".into());
         v.push("/Library/Fonts".into());
         if let Some(h) = std::env::var_os("HOME") {
             v.push(std::path::PathBuf::from(h).join("Library/Fonts"));
         }
+        // Fonts the system downloads (PingFang and other CJK faces on current versions) live in
+        // its asset store; `Assets` is the older versions' store.
+        for store in ["/System/Library/AssetsV2", "/System/Library/Assets"] {
+            v.extend(font_asset_dirs(std::path::Path::new(store)));
+        }
     }
     #[cfg(target_os = "windows")]
     {
@@ -714,6 +765,15 @@ fn system_font_dirs() -> Vec<std::path::PathBuf> {
     v
 }
 
+/// The font folders (`com_apple_MobileAsset_Font*`, each holding `<id>.asset/AssetData/*.ttc`) in
+/// the macOS asset store `store`: only these are walked, not the store's voices, dictionaries and
+/// models.
+#[cfg(any(target_os = "macos", test))]
+fn font_asset_dirs(store: &std::path::Path) -> Vec<std::path::PathBuf> {
+    let Ok(rd) = std::fs::read_dir(store) else { return Vec::new() };
+    rd.flatten().filter(|e| e.file_name().to_str().is_some_and(|n| n.starts_with("com_apple_MobileAsset_Font"))).map(|e| e.path()).collect()
+}
+
 // Fontconfig's default configuration uses $XDG_DATA_HOME/fonts for user fonts.
 // Ignore relative XDG paths, as required by the XDG Base Directory Specification.
 #[cfg(all(unix, not(target_os = "macos")))]
@@ -759,13 +819,19 @@ fn scan_dir(dir: &std::path::Path, depth: usize, out: &mut BTreeMap<String, (Str
         // Very large files are indexed all the same (Apple Color Emoji is ~180 MB and is where the
         // system's colour emoji live): `index_bytes` reads headers and name tables out of a zeroed
         // buffer, so only those parts are ever touched.
-        let Some(bytes) = usize::try_from(meta.len()).ok().filter(|l| *l <= 256 * 1024 * 1024).and_then(|l| index_bytes(&path, l)) else { continue };
+        if meta.len() > MAX_FONT_FILE {
+            continue;
+        }
+        let Some(bytes) = usize::try_from(meta.len()).ok().and_then(|l| index_bytes(&path, l)) else { continue };
         for (index, family, style) in faces_in(&bytes) {
             out.entry(family.to_lowercase()).or_insert_with(|| (family.clone(), Vec::new())).1.push(Pending { path: path.clone(), index, style });
         }
     }
 }
 
+/// The largest font file read (CJK collections run to ~120 MB, Apple Color Emoji ~180 MB).
+pub const MAX_FONT_FILE: u64 = 256 * 1024 * 1024;
+
 /// The parts of a font file the scan reads: headers, table directories and `name` tables, at their
 /// offsets in a zeroed buffer of the file's length (reading whole files was most of the scan).
 fn index_bytes(path: &std::path::Path, len: usize) -> Option<Vec<u8>> {
@@ -835,6 +901,11 @@ pub fn family_names() -> Vec<String> {
     db().read().unwrap_or_else(std::sync::PoisonError::into_inner).families()
 }
 
+/// The global db has `family` (embedded, loaded or indexed; any case).
+pub fn has_family(family: &str) -> bool {
+    db().read().unwrap_or_else(std::sync::PoisonError::into_inner).has_family(family)
+}
+
 /// Style names of a family in the global db.
 pub fn family_styles(family: &str) -> Vec<String> {
     db().write().unwrap_or_else(std::sync::PoisonError::into_inner).styles(family)
@@ -865,12 +936,71 @@ pub fn scan_system_fonts() {
     });
 }
 
+/// Walk the system font folders again, for fonts installed while the app runs (the first scan is
+/// once per process): the families that were unknown before, and every family that gained faces.
+/// Before the first scan this is that scan; a no-op on the web or with `FIGCRAFT_NO_SYSTEM_FONTS`.
+pub fn rescan_system_fonts() -> Rescan {
+    #[cfg(not(target_arch = "wasm32"))]
+    if !system_fonts_opted_out() {
+        if SCANNED.get().is_none() {
+            let before: std::collections::BTreeSet<String> =
+                raw_db().read().unwrap_or_else(std::sync::PoisonError::into_inner).families().into_iter().collect();
+            scan_system_fonts();
+            let added: Vec<String> = family_names().into_iter().filter(|f| !before.contains(f)).collect();
+            return Rescan { changed: added.clone(), added };
+        }
+        let mut found: BTreeMap<String, (String, Vec<Pending>)> = BTreeMap::new();
+        for dir in system_font_dirs() {
+            scan_dir(&dir, 0, &mut found);
+        }
+        let rescan = raw_db().write().unwrap_or_else(std::sync::PoisonError::into_inner).merge_rescan(found);
+        if !rescan.changed.is_empty() {
+            crate::clear_layout_cache();
+        }
+        return rescan;
+    }
+    Rescan::default()
+}
+
+/// Load font file bytes (every face of a collection) into the global db, for a font that isn't
+/// installed. Returns the families of its faces (none: not a font file); the same file again
+/// returns them without adding its faces twice.
+pub fn load_font_bytes(bytes: Vec<u8>) -> Vec<String> {
+    use std::hash::{Hash, Hasher};
+    let mut h = std::collections::hash_map::DefaultHasher::new();
+    bytes.hash(&mut h);
+    let key = (h.finish(), bytes.len());
+    let mut db = db().write().unwrap_or_else(std::sync::PoisonError::into_inner);
+    if let Some(families) = db.loaded_bytes.get(&key) {
+        return families.clone();
+    }
+    let faces = db.add_bytes(bytes);
+    let mut families: Vec<String> = faces.iter().map(|f| f.family.clone()).collect();
+    families.dedup();
+    if !families.is_empty() {
+        db.loaded_bytes.insert(key, families.clone());
+        drop(db);
+        crate::clear_layout_cache();
+    }
+    families
+}
+
 /// `FIGCRAFT_NO_SYSTEM_FONTS` is set (and not `0`): renders use only the embedded fonts.
 #[cfg(not(target_arch = "wasm32"))]
 fn system_fonts_opted_out() -> bool {
     std::env::var_os("FIGCRAFT_NO_SYSTEM_FONTS").is_some_and(|v| !v.is_empty() && v != "0")
 }
 
+/// Every font text can use is known: the system fonts were indexed, or there are none to index
+/// (opted out, or the web). Until then a family the scan would find counts as missing.
+pub fn installed_fonts_known() -> bool {
+    #[cfg(not(target_arch = "wasm32"))]
+    if !system_fonts_opted_out() {
+        return system_fonts_scanned();
+    }
+    true
+}
+
 /// Index the system fonts the first time the font database is used (headless apps: a run that
 /// lays out no text never pays for the scan). The desktop app scans in the background instead.
 pub fn scan_system_fonts_on_demand() {
diff --git a/crates/text/src/fontdb_tests.rs b/crates/text/src/fontdb_tests.rs
index ea762be6f..f2456d28b 100644
--- a/crates/text/src/fontdb_tests.rs
+++ b/crates/text/src/fontdb_tests.rs
@@ -70,6 +70,44 @@ fn the_scan_reads_names_like_a_whole_file_read() {
     }
 }
 
+#[test]
+fn macos_font_assets_are_found_in_the_asset_store() {
+    // A store laid out like macOS's: fonts downloaded on demand sit in `<id>.asset/AssetData`
+    // folders under `com_apple_MobileAsset_Font*`; other assets are never walked. Untested on a Mac.
+    struct TempDir(std::path::PathBuf);
+    impl Drop for TempDir {
+        fn drop(&mut self) {
+            let _ = std::fs::remove_dir_all(&self.0);
+        }
+    }
+    let tmp = TempDir(std::env::temp_dir().join(format!("figcraft-font-assets-{}", std::process::id())));
+    let store = tmp.0.join("AssetsV2");
+    let fonts = store.join("com_apple_MobileAsset_Font7");
+    let data = |kind: &std::path::Path| kind.join("0f1e2d.asset").join("AssetData");
+    for dir in [data(&fonts), data(&store.join("com_apple_MobileAsset_VoiceServices"))] {
+        std::fs::create_dir_all(dir).unwrap();
+    }
+    // A file under a font-like name is listed but walks to nothing.
+    std::fs::write(store.join("com_apple_MobileAsset_Font7.plist"), b"not a folder").unwrap();
+    let found = font_asset_dirs(&store);
+    assert!(found.contains(&fonts) && !found.iter().any(|d| d.ends_with("com_apple_MobileAsset_VoiceServices")), "{found:?}");
+    assert!(font_asset_dirs(&tmp.0.join("missing")).is_empty());
+    // With an installed font to copy in (none on CI), the scan finds it only in the font folder.
+    let installed = system_font_dirs()
+        .into_iter()
+        .find_map(|d| std::fs::read_dir(d).into_iter().flatten().flatten().map(|e| e.path()).find(|p| p.extension().is_some_and(|x| x == "ttf")));
+    let Some(font) = installed else { return };
+    for kind in ["com_apple_MobileAsset_Font7", "com_apple_MobileAsset_VoiceServices"] {
+        std::fs::copy(&font, data(&store.join(kind)).join("Font.ttf")).unwrap();
+    }
+    let mut pending = BTreeMap::new();
+    for dir in found {
+        scan_dir(&dir, 0, &mut pending);
+    }
+    let paths: Vec<_> = pending.values().flat_map(|(_, p)| p.iter().map(|p| p.path.clone())).collect();
+    assert!(!paths.is_empty() && paths.iter().all(|p| p.starts_with(&fonts)), "{paths:?}");
+}
+
 #[cfg(unix)]
 #[test]
 fn the_scan_skips_named_pipes() {
@@ -179,3 +217,49 @@ fn user_font_dirs_preserve_non_utf8_paths() {
     assert_eq!(dirs[0].as_os_str().as_bytes(), b"/home/\xff/.fonts");
     assert_eq!(dirs[1].as_os_str().as_bytes(), b"/data/\xfe/fonts");
 }
+
+/// A rescan offers new families and the styles installed since, and never a file twice.
+#[test]
+fn a_rescan_offers_fonts_installed_since() {
+    let entry = |s: &str| Pending { path: format!("no-such-dir/{s}.ttf").into(), index: 0, style: s.into() };
+    let mut db = pending(&["Regular"]);
+    let found = |fams: &[(&str, &[&str])]| -> BTreeMap<String, (String, Vec<Pending>)> {
+        fams.iter().map(|(f, styles)| (f.to_lowercase(), ((*f).to_string(), styles.iter().map(|s| entry(s)).collect()))).collect()
+    };
+    // A new family is added; a pending one takes the walk's files (a new style); both changed.
+    let r = db.merge_rescan(found(&[("CJK UI", &["Regular", "Bold"]), ("Brand Sans", &["Regular"])]));
+    assert_eq!(r.added, ["Brand Sans"]);
+    assert_eq!(r.changed, ["Brand Sans", "CJK UI"]);
+    assert!(db.has_family("brand sans"));
+    assert_eq!(left(&db), ["Regular", "Bold"]);
+    // A loaded family keeps its faces and gets only the files it hasn't read, once.
+    db.families.insert("brand sans".into(), ("Brand Sans".into(), Vec::new()));
+    db.pending.remove("brand sans");
+    db.loaded_files.insert(("no-such-dir/Regular.ttf".into(), 0));
+    let same = db.merge_rescan(found(&[("Brand Sans", &["Regular"])]));
+    assert_eq!(same, Rescan::default());
+    assert!(!db.pending.contains_key("brand sans"));
+    let bold = db.merge_rescan(found(&[("Brand Sans", &["Regular", "Black"])]));
+    assert_eq!((bold.added.len(), bold.changed), (0, vec!["Brand Sans".to_string()]));
+    let waiting = |db: &FontDb| db.pending.get("brand sans").map(|(_, v)| v.iter().map(|e| e.style.clone()).collect::<Vec<_>>()).unwrap_or_default();
+    assert_eq!(waiting(&db), ["Black"]);
+    assert_eq!(db.merge_rescan(found(&[("Brand Sans", &["Regular", "Black"])])), Rescan::default());
+    assert_eq!(waiting(&db), ["Black"]);
+}
+
+/// Font file bytes add their faces once; junk adds nothing.
+#[test]
+fn font_bytes_load_into_the_db() {
+    assert!(load_font_bytes(b"not a font".to_vec()).is_empty());
+    assert!(load_font_bytes(Vec::new()).is_empty());
+    // With the embedded fonts (absent on CI builds without craft-fonts): a file's family is added,
+    // and loading the same file again returns it without adding its faces twice.
+    if let Some(f) = CRAFT_FONTS.first() {
+        let families = load_font_bytes(f.bytes.to_vec());
+        assert_eq!(families.len(), 1);
+        assert!(families.iter().all(|f| has_family(f)));
+        let faces = db().read().unwrap().face_count();
+        assert_eq!(load_font_bytes(f.bytes.to_vec()), families);
+        assert_eq!(db().read().unwrap().face_count(), faces);
+    }
+}
diff --git a/crates/text/src/layout.rs b/crates/text/src/layout.rs
index 37092da86..f844b5710 100644
--- a/crates/text/src/layout.rs
+++ b/crates/text/src/layout.rs
@@ -82,6 +82,9 @@ pub struct Line {
     pub x: f64,
     /// The line ends a paragraph (hard break or end of text).
     pub para_end: bool,
+    /// The line ends with a line break char: a newline, or a line separator (U+2028) that breaks
+    /// the line inside its paragraph.
+    pub break_after: bool,
     /// The paragraph runs right to left (its first strong character is right-to-left).
     pub rtl: bool,
 }
@@ -157,6 +160,15 @@ fn deco_len(m: DecorationLength, size: f64, auto: f64) -> f64 {
     if v.is_finite() { v } else { auto }
 }
 
+/// The line separator (U+2028): a line break inside a paragraph, as `.fig` files store a soft
+/// break (imported text keeps it; typed text has newlines only).
+const LINE_SEPARATOR: char = '\u{2028}';
+
+/// A char that ends its line: a newline (which also ends the paragraph) or a line separator.
+fn is_line_break(c: char) -> bool {
+    c == '\n' || c == LINE_SEPARATOR
+}
+
 /// Opening punctuation, which hangs outside a line's start.
 fn opens(c: char) -> bool {
     matches!(c, '"' | '\'' | '\u{201C}' | '\u{2018}' | '\u{201E}' | '\u{201A}' | '\u{00AB}' | '\u{2039}' | '(' | '[' | '{' | '\u{00BF}' | '\u{00A1}')
@@ -332,7 +344,7 @@ pub fn layout(text: &TextData, box_width: Option<f64>, box_height: Option<f64>)
     }
     // Colour emoji are their own, large faces (Apple Color Emoji is ~180 MB): they are read only
     // for a text with emoji, or with characters nothing above covers.
-    let covered = |c: char| c == '\n' || faces.iter().flatten().any(|f| f.has_char(c)) || fallbacks.iter().any(|f| f.has_char(c));
+    let covered = |c: char| is_line_break(c) || faces.iter().flatten().any(|f| f.has_char(c)) || fallbacks.iter().any(|f| f.has_char(c));
     let emoji = if chars.iter().any(|c| is_emoji(*c) || !covered(*c)) { dbw.emoji_fallbacks() } else { Vec::new() };
     fallbacks.extend(emoji.iter().cloned());
     drop(dbw);
@@ -370,7 +382,7 @@ pub fn layout(text: &TextData, box_width: Option<f64>, box_height: Option<f64>)
                 {
                     return f.clone();
                 }
-                if c == '\n' || primary.has_char(c) {
+                if is_line_break(c) || primary.has_char(c) {
                     return primary.clone();
                 }
                 let fallbacks = style_fallbacks.get(st_idx).unwrap_or(&fallbacks);
@@ -382,13 +394,15 @@ pub fn layout(text: &TextData, box_width: Option<f64>, box_height: Option<f64>)
             let mut seg_end = seg_start + 1;
             while seg_end < *end
                 && chars.get(seg_end).is_some_and(|c| {
-                    *c != '\n' && first != '\n' && (!cluster_start.get(seg_end).copied().unwrap_or(true) || face_for(*c).id == face.id)
+                    !is_line_break(*c)
+                        && !is_line_break(first)
+                        && (!cluster_start.get(seg_end).copied().unwrap_or(true) || face_for(*c).id == face.id)
                 })
                 && level_at(seg_end) == level
             {
                 seg_end += 1;
             }
-            if first == '\n' {
+            if is_line_break(first) {
                 items.push(Item {
                     face: face.clone(),
                     coords: no_coords(),
@@ -401,7 +415,7 @@ pub fn layout(text: &TextData, box_width: Option<f64>, box_height: Option<f64>)
                     char_start: seg_start,
                     char_end: seg_start + 1,
                     style: st_idx,
-                    ch: '\n',
+                    ch: first,
                     level,
                 });
             } else {
@@ -465,6 +479,17 @@ pub fn layout(text: &TextData, box_width: Option<f64>, box_height: Option<f64>)
             para += 1;
             continue;
         }
+        // A line separator (a soft break) breaks the line inside its paragraph: no
+        // paragraph spacing and no new list marker after it.
+        if it.ch == LINE_SEPARATOR {
+            lines.push((line_start, i + 1, false, para));
+            i += 1;
+            line_start = i;
+            x = 0.0;
+            last_break = None;
+            para_first_line = false;
+            continue;
+        }
         let line_indent = line_indent_of(para, para_first_line, it.char_start);
         let w = it.adv;
         // Hanging punctuation takes no room inside the box.
@@ -491,7 +516,8 @@ pub fn layout(text: &TextData, box_width: Option<f64>, box_height: Option<f64>)
         }
         i += 1;
     }
-    if line_start < items.len() || lines.is_empty() || lines.last().is_some_and(|l| l.2) {
+    let break_after = |e: usize| e.checked_sub(1).and_then(|i| items.get(i)).is_some_and(|it| is_line_break(it.ch));
+    if line_start < items.len() || lines.is_empty() || lines.last().is_some_and(|l| l.2 || break_after(l.1)) {
         lines.push((line_start, items.len(), true, para));
     }
 
@@ -546,7 +572,7 @@ pub fn layout(text: &TextData, box_width: Option<f64>, box_height: Option<f64>)
         let baseline = y + (lh - (asc + desc)) / 2.0 + asc;
         // Trailing spaces don't count for width/alignment.
         let mut vis_end = *e;
-        while vis_end > *s && items.get(vis_end - 1).is_some_and(|it| it.is_space() || it.ch == '\n') {
+        while vis_end > *s && items.get(vis_end - 1).is_some_and(|it| it.is_space() || is_line_break(it.ch)) {
             vis_end -= 1;
         }
         // Letter spacing separates glyphs: none after the line's last visible one.
@@ -563,7 +589,9 @@ pub fn layout(text: &TextData, box_width: Option<f64>, box_height: Option<f64>)
         // Justify: extra space per gap.
         let gaps = items.get(*s..vis_end).unwrap_or(&[]).iter().filter(|it| it.is_space()).count();
         let justify_extra = match (text.align_h, wrap) {
-            (TextAlignH::Justified, Some(maxw)) if !para_end && gaps > 0 => ((maxw - line_indent + hang_l + hang_r - width) / gaps as f64).max(0.0),
+            (TextAlignH::Justified, Some(maxw)) if !para_end && !break_after(*e) && gaps > 0 => {
+                ((maxw - line_indent + hang_l + hang_r - width) / gaps as f64).max(0.0)
+            }
             _ => 0.0,
         };
         // Where the visible text ends once justified.
@@ -574,7 +602,7 @@ pub fn layout(text: &TextData, box_width: Option<f64>, box_height: Option<f64>)
             .get(vis_end..*e)
             .unwrap_or(&[])
             .iter()
-            .filter(|it| it.ch != '\n')
+            .filter(|it| !is_line_break(it.ch))
             .map(|it| it.adv + if it.is_space() { justify_extra } else { 0.0 })
             .sum();
         let mut pen = if rtl_line { -trailing } else { line_indent - hang_l };
@@ -649,7 +677,7 @@ pub fn layout(text: &TextData, box_width: Option<f64>, box_height: Option<f64>)
             (0..line_items.len()).collect()
         };
         for it in order.iter().filter_map(|k| line_items.get(*k)) {
-            if it.ch == '\n' {
+            if is_line_break(it.ch) {
                 continue;
             }
             let size = styles.get(it.style).map(|st| sanitize_size(st.font_size)).unwrap_or(12.0) * it.scale;
@@ -687,6 +715,7 @@ pub fn layout(text: &TextData, box_width: Option<f64>, box_height: Option<f64>)
             width: width + line_indent - hang_l - hang_r,
             x: 0.0,
             para_end: *para_end,
+            break_after: break_after(*e),
             rtl: rtl_line,
         });
         y += lh;
@@ -827,8 +856,8 @@ pub fn layout(text: &TextData, box_width: Option<f64>, box_height: Option<f64>)
 }
 
 /// The markers of a text's paragraphs ("" for plain ones). Numbers count the items of one list at
-/// one level, restarting after a plain paragraph, a shallower item or the other kind of list;
-/// levels go 1. a. i. and • ◦ ▪, then round again.
+/// one level, restarting after a plain paragraph, a shallower item or the other kind of list,
+/// from the first item's start number; levels go 1. a. i. and • ◦ ▪, then round again.
 pub(crate) fn list_markers(lists: &[ParaList]) -> Vec<String> {
     const BULLETS: [&str; 3] = ["\u{2022}", "\u{25E6}", "\u{25AA}"];
     let mut count = [(ListStyle::None, 0usize); figcraft_doc::MAX_LIST_INDENT as usize + 1];
@@ -844,7 +873,8 @@ pub(crate) fn list_markers(lists: &[ParaList]) -> Vec<String> {
                 *c = (ListStyle::None, 0);
             }
             let Some(c) = count.get_mut(d) else { return String::new() };
-            *c = if c.0 == pl.list { (pl.list, c.1 + 1) } else { (pl.list, 1) };
+            let first = usize::try_from(pl.start_offset).unwrap_or(usize::MAX).saturating_add(1);
+            *c = if c.0 == pl.list { (pl.list, c.1.saturating_add(1)) } else { (pl.list, first) };
             match (pl.list, d % 3) {
                 (ListStyle::Numbered, 1) => format!("{}.", alpha(c.1)),
                 (ListStyle::Numbered, 2) => format!("{}.", roman(c.1)),
@@ -1005,6 +1035,18 @@ fn is_emoji(c: char) -> bool {
     matches!(c, '\u{1F1E6}'..='\u{1F1FF}' | '\u{1F300}'..='\u{1FAFF}')
 }
 
+/// The lower case of the capital sigma at `i`: the final form ς or σ, chosen from the letters
+/// around it in the whole text (as lower-casing the whole string would), not from the lone char.
+fn lower_sigma(chars: &[char], i: usize) -> char {
+    // Enough context to step over any realistic run of combining marks next to the sigma.
+    const CONTEXT: usize = 32;
+    let before: String = chars.get(i.saturating_sub(CONTEXT)..i).unwrap_or(&[]).iter().collect();
+    let after: String = chars.iter().skip(i + 1).take(CONTEXT).collect();
+    let lower = format!("{before}\u{3A3}{after}").to_lowercase();
+    // Only the sigma's lower case depends on context, so the text before it keeps its length.
+    lower.get(before.to_lowercase().len()..).and_then(|s| s.chars().next()).unwrap_or('σ')
+}
+
 /// One run of chars shaped with a single face and style.
 struct Segment<'a> {
     start: usize,
@@ -1035,6 +1077,8 @@ fn shape_segment(chars: &[char], seg: &Segment, face: &Arc<Face>, features: &[Fe
             for u in c.to_uppercase() {
                 mapped.push((u, src, true));
             }
+        } else if style.case == TextCase::Lower && *c == 'Σ' {
+            mapped.push((lower_sigma(chars, src), src, false));
         } else {
             let mut buf = [0u8; 4];
             for u in style.case.apply_after(c.encode_utf8(&mut buf), prev).chars() {
@@ -1141,16 +1185,12 @@ impl TextLayout {
     pub fn caret(&self, index: usize) -> (f64, usize) {
         for (li, line) in self.lines.iter().enumerate() {
             let last_line = li + 1 == self.lines.len();
+            // A caret at a line's end belongs to the next line, whether the line wraps or ends with a
+            // line break (before the break it is still on this line: past its glyphs).
             let in_line = index >= line.char_start && (index < line.char_end || (last_line && index <= line.char_end));
-            // A caret at the end of a soft-wrapped line belongs to the next line.
-            if !(in_line || index == line.char_end && line.para_end && !last_line) {
+            if !in_line {
                 continue;
             }
-            if index == line.char_end && line.para_end && !last_line {
-                // Before the newline: end of this line.
-                let x = self.line_end_x(line);
-                return (x, li);
-            }
             let gl = self.glyphs.get(line.glyph_start..line.glyph_end).unwrap_or(&[]);
             for g in gl {
                 if g.char_end == g.char_start {
@@ -1178,8 +1218,8 @@ impl TextLayout {
         if !line.rtl && !gl.iter().any(|g| g.rtl) {
             return None;
         }
-        // The caret can't sit after a paragraph's newline on its own line.
-        let end = if line.para_end && li + 1 < self.lines.len() { line.char_end.saturating_sub(1) } else { line.char_end };
+        // The caret can't sit after a line's break on its own line.
+        let end = if line.break_after && li + 1 < self.lines.len() { line.char_end.saturating_sub(1) } else { line.char_end };
         let next = (line.char_start..=end.max(line.char_start))
             .filter(|i| *i != index)
             .map(|i| (i, self.caret(i).0))
@@ -1190,6 +1230,12 @@ impl TextLayout {
         Some(next.unwrap_or(if right != line.rtl { index + 1 } else { index.saturating_sub(1) }))
     }
 
+    /// Left edge of a left-to-right line's first char (its end when it has none).
+    fn line_start_x(&self, line: &Line) -> f64 {
+        let gl = self.glyphs.get(line.glyph_start..line.glyph_end).unwrap_or(&[]);
+        gl.iter().find(|g| g.char_end > g.char_start).map_or_else(|| self.line_end_x(line), |g| g.x)
+    }
+
     /// Where a line's text ends: its right edge, or its left edge for a right-to-left paragraph.
     fn line_end_x(&self, line: &Line) -> f64 {
         let glyphs = self.glyphs.get(line.glyph_start..line.glyph_end).unwrap_or(&[]).iter().filter(|g| g.char_end > g.char_start);
@@ -1240,7 +1286,7 @@ impl TextLayout {
             }
         }
         let last_line = li + 1 == self.lines.len();
-        let end = if line.para_end && !last_line { line.char_end.saturating_sub(1).max(line.char_start) } else { line.char_end };
+        let end = if line.break_after && !last_line { line.char_end.saturating_sub(1).max(line.char_start) } else { line.char_end };
         // Right of a right-to-left line is its start.
         if line.rtl { line.char_start } else { end }
     }
@@ -1250,7 +1296,16 @@ impl TextLayout {
         let (a, b) = (start.min(end), start.max(end));
         let mut out = Vec::new();
         for (li, line) in self.lines.iter().enumerate() {
-            if b <= line.char_start || a > line.char_end || (a == line.char_end && li + 1 < self.lines.len()) {
+            let last = li + 1 == self.lines.len();
+            // The empty line after a trailing break has no chars, but a selection reaching the
+            // end of the text covers it: it shows a paragraph-break mark at the line's start.
+            let trailing_empty = last && a < b && b >= line.char_start && line.char_start == line.char_end;
+            if (b <= line.char_start && !trailing_empty) || a > line.char_end || (a == line.char_end && !last) {
+                continue;
+            }
+            if trailing_empty {
+                let x = self.line_end_x(line);
+                out.push(Rect::new(x, line.top, x + 4.0, line.top + line.height));
                 continue;
             }
             let gl = self.glyphs.get(line.glyph_start..line.glyph_end).unwrap_or(&[]);
@@ -1258,10 +1313,11 @@ impl TextLayout {
                 out.extend(Self::mixed_selection(gl, a, b, line));
                 continue;
             }
-            let (x0, _) = self.caret(a.max(line.char_start));
+            // From the line's own start.
+            let x0 = if a <= line.char_start { self.line_start_x(line) } else { self.caret(a).0 };
             let x1 = if b >= line.char_end {
                 // The last line has no paragraph break to show, so it ends at its glyphs.
-                self.line_end_x(line) + if line.para_end && li + 1 < self.lines.len() && b > line.char_end.saturating_sub(1) { 4.0 } else { 0.0 }
+                self.line_end_x(line) + if line.break_after && !last && b > line.char_end.saturating_sub(1) { 4.0 } else { 0.0 }
             } else {
                 self.caret(b).0
             };
diff --git a/crates/text/src/lib.rs b/crates/text/src/lib.rs
index 27456d824..50cd28dd5 100644
--- a/crates/text/src/lib.rs
+++ b/crates/text/src/lib.rs
@@ -16,8 +16,9 @@ mod onpath;
 pub use breaks::grapheme_step;
 pub use color::{ColorBitmap, ColorInk, ColorLayer};
 pub use fontdb::{
-    Axis, CRAFT_FONTS, Coords, Face, FontDb, NamedInstance, axis_label, db, face_with_char, family_names, family_styles, find_face, no_coords,
-    scan_system_fonts, scan_system_fonts_on_demand, system_fonts_scanned,
+    Axis, CRAFT_FONTS, Coords, Face, FontDb, NamedInstance, Rescan, axis_label, db, face_with_char, family_names, family_styles, find_face,
+    has_family, installed_fonts_known, load_font_bytes, no_coords, rescan_system_fonts, scan_system_fonts, scan_system_fonts_on_demand,
+    system_fonts_scanned,
 };
 pub use layout::{Decoration, Glyph, Line, TextLayout, layout};
 pub use onpath::OnPath;
@@ -150,6 +151,8 @@ mod behaviour_tests;
 #[cfg(test)]
 mod cache_tests;
 #[cfg(test)]
+mod line_separator_tests;
+#[cfg(test)]
 mod list_tests;
 #[cfg(test)]
 mod metrics_tests;
diff --git a/crates/text/src/line_separator_tests.rs b/crates/text/src/line_separator_tests.rs
new file mode 100644
index 000000000..13f91786c
--- /dev/null
+++ b/crates/text/src/line_separator_tests.rs
@@ -0,0 +1,97 @@
+//! A line separator (U+2028: a soft break in `.fig` files, kept on import) breaks the
+//! line inside its paragraph: no paragraph spacing or new list marker after it, and no glyph (#852).
+
+use super::*;
+use figcraft_doc::{LineHeight, ListStyle, TextAutoResize, TextData};
+
+const EPS: f64 = 1e-6;
+
+/// A 20 px text on 30 px lines in the default face, or None (skip) on a machine without fonts.
+fn text(s: &str) -> Option<TextData> {
+    scan_system_fonts();
+    let f = db().write().unwrap().default_face()?;
+    let mut t = TextData::new(s);
+    (t.style.font_family, t.style.font_style) = (f.family.clone(), f.style.clone());
+    t.style.font_size = 20.0;
+    t.style.line_height = LineHeight::Pixels(30.0);
+    t.auto_resize = TextAutoResize::WidthAndHeight;
+    Some(t)
+}
+
+/// The chars of each line.
+fn line_texts(t: &TextData, l: &TextLayout) -> Vec<String> {
+    let chars: Vec<char> = t.characters.chars().collect();
+    l.lines.iter().map(|ln| chars.get(ln.char_start..ln.char_end).unwrap_or(&[]).iter().collect::<String>()).collect()
+}
+
+#[test]
+fn breaks_the_line_but_not_the_paragraph() {
+    let Some(mut t) = text("one\u{2028}two\nthree") else { return };
+    t.paragraph_spacing = 10.0;
+    let l = layout(&t, None, None);
+    assert_eq!(line_texts(&t, &l), ["one\u{2028}", "two\n", "three"]);
+    assert!(!l.lines[0].para_end && l.lines[0].break_after);
+    assert!(l.lines[1].para_end && l.lines[1].break_after);
+    assert!(!l.lines[2].break_after);
+    // Paragraph spacing after the newline only: 30, then 30 + 10.
+    assert!((l.lines[1].top - 30.0).abs() < EPS && (l.lines[2].top - 70.0).abs() < EPS, "{} {}", l.lines[1].top, l.lines[2].top);
+    // The separator draws nothing.
+    assert!(l.glyphs.iter().all(|g| !(g.char_start..g.char_end).contains(&3)));
+}
+
+#[test]
+fn before_a_newline_or_at_the_end_it_leaves_an_empty_line() {
+    // "Hi,⏎¶Season" in #852: an empty line between the two.
+    let Some(t) = text("Hi,\u{2028}\nSeason") else { return };
+    let l = layout(&t, None, None);
+    assert_eq!(line_texts(&t, &l), ["Hi,\u{2028}", "\n", "Season"]);
+    let Some(t) = text("end\u{2028}") else { return };
+    let l = layout(&t, None, None);
+    assert_eq!(line_texts(&t, &l), ["end\u{2028}", ""]);
+    assert!((l.height - 60.0).abs() < EPS, "{}", l.height);
+}
+
+#[test]
+fn a_list_item_continues_after_it_without_a_new_marker() {
+    let Some(mut t) = text("item\u{2028}more\nnext") else { return };
+    t.list = ListStyle::Bulleted;
+    let l = layout(&t, None, None);
+    assert_eq!(line_texts(&t, &l), ["item\u{2028}", "more\n", "next"]);
+    // Markers are the glyphs that cover no char: one per paragraph.
+    assert_eq!(l.glyphs.iter().filter(|g| g.char_start == g.char_end).count(), 2);
+    // The line after the separator lines up with the item's text, past the bullet.
+    let text_x = |li: usize| l.glyphs.iter().find(|g| g.char_start == l.lines[li].char_start && g.char_end > g.char_start).map(|g| g.x);
+    let (first, cont) = (text_x(0).unwrap(), text_x(1).unwrap());
+    assert!(first > 0.0 && (first - cont).abs() < 1e-3, "{first} {cont}");
+}
+
+#[test]
+fn carets_and_clicks_treat_it_like_a_newline() {
+    let (Some(sep), Some(nl)) = (text("ab\u{2028}cd"), text("ab\ncd")) else { return };
+    let (ls, ln) = (layout(&sep, None, None), layout(&nl, None, None));
+    for i in 0..=5 {
+        assert_eq!(ls.caret(i), ln.caret(i), "caret before char {i}");
+    }
+    for line in &ln.lines {
+        for x in [-10.0, 5.0, line.width + 50.0] {
+            assert_eq!(ls.hit(x, line.top + 5.0), ln.hit(x, line.top + 5.0), "click at {x} on the line at {}", line.top);
+        }
+    }
+    // Before the separator: the end of the first line; after it: the start of the second.
+    assert_eq!(ls.caret(2).1, 0);
+    assert!(ls.caret(2).0 > 0.0);
+    assert_eq!(ls.caret(3), (0.0, 1));
+    // A click right of the first line lands before the separator, not after it.
+    assert_eq!(ls.hit(ls.lines[0].width + 50.0, ls.lines[0].top + 5.0), 2);
+}
+
+#[test]
+fn a_selection_across_it_shows_the_break_like_a_newline() {
+    let (Some(sep), Some(nl)) = (text("ab\u{2028}cd"), text("ab\ncd")) else { return };
+    let (ls, ln) = (layout(&sep, None, None), layout(&nl, None, None));
+    let (before, across) = (ls.selection_rects(0, 2), ls.selection_rects(0, 5));
+    assert_eq!((before.len(), across.len()), (1, 2));
+    // Reaching past the separator adds the 4 px break mark at the first line's end.
+    assert!((across[0].width() - before[0].width() - 4.0).abs() < EPS, "{} {}", across[0].width(), before[0].width());
+    assert_eq!(across, ln.selection_rects(0, 5));
+}
diff --git a/crates/text/src/tail_tests.rs b/crates/text/src/tail_tests.rs
index 890b254de..2d0ad22b7 100644
--- a/crates/text/src/tail_tests.rs
+++ b/crates/text/src/tail_tests.rs
@@ -43,7 +43,32 @@ fn starts(l: &TextLayout) -> Vec<(f64, Option<f64>)> {
 }
 
 fn pl(list: ListStyle, indent: u8) -> ParaList {
-    ParaList { list, indent }
+    ParaList { list, indent, start_offset: 0 }
+}
+
+fn from(list: ListStyle, indent: u8, start_offset: u32) -> ParaList {
+    ParaList { list, indent, start_offset }
+}
+
+#[test]
+fn numbered_lists_count_from_their_start() {
+    use ListStyle::{Bulleted as B, None as P, Numbered as N};
+    let cases: Vec<(Vec<ParaList>, Vec<&str>, &str)> = vec![
+        (vec![from(N, 0, 1)], vec!["2."], "a one-item list started at 2 (#686)"),
+        (vec![from(N, 0, 3), pl(N, 0), pl(N, 0)], vec!["4.", "5.", "6."], "the items after the first count on from it"),
+        (vec![from(N, 0, 3), from(N, 0, 3), from(N, 0, 3)], vec!["4.", "5.", "6."], "items that go on counting ignore their own start"),
+        (vec![from(N, 0, 1), pl(P, 0), from(N, 0, 1)], vec!["2.", "", "2."], "a list after a plain paragraph starts from its own start"),
+        (vec![pl(N, 0), from(N, 1, 1), pl(N, 1)], vec!["1.", "b.", "c."], "a nested level starts from its first item's start"),
+        (vec![from(B, 0, 4), pl(B, 0)], vec!["\u{2022}", "\u{2022}"], "bullets have no number"),
+        (vec![from(N, 0, 4_000), pl(N, 2)], vec!["4001.", "i."], "big starts"),
+    ];
+    for (lists, want, why) in cases {
+        assert_eq!(list_markers(&lists), want, "{why}");
+    }
+    // The largest start never overflows, on 32-bit targets too.
+    let max = list_markers(&[from(N, 0, u32::MAX), pl(N, 0), pl(N, 0)]);
+    assert_eq!(max.len(), 3);
+    assert!(max.iter().all(|m| m.starts_with("429496729")), "{max:?}");
 }
 
 #[test]
diff --git a/crates/text/src/tests.rs b/crates/text/src/tests.rs
index e34f0110f..4475fbbce 100644
--- a/crates/text/src/tests.rs
+++ b/crates/text/src/tests.rs
@@ -437,3 +437,85 @@ fn selection_through_text_end_stays_inside_auto_width_box() {
     let first = r.first().map_or(f64::NAN, |r| r.x1);
     assert!(first > l.caret(5).0 + 1.0, "{first}");
 }
+
+/// The selection rect drawn on line `li` of `l`, if any.
+fn rect_on(l: &TextLayout, rects: &[figcraft_geom::Rect], li: usize) -> Option<figcraft_geom::Rect> {
+    let top = l.lines.get(li)?.top;
+    rects.iter().find(|r| (r.y0 - top).abs() < 1e-6).copied()
+}
+
+#[test]
+fn select_all_highlights_an_empty_last_line() {
+    if !have_fonts() {
+        return;
+    }
+    // "Hello\n": the trailing break leaves an empty second line (#665).
+    let l = layout(&TextData::new("Hello\n"), None, None);
+    assert_eq!(l.lines.len(), 2);
+    let Some(r) = rect_on(&l, &l.selection_rects(0, 6), 1) else { panic!("no highlight on the empty last line") };
+    // A paragraph-break mark at the line's start, not at the end of "Hello" above.
+    assert!(r.x0.abs() < 1e-6 && (r.width() - 4.0).abs() < 1e-6, "{r:?}");
+    assert!(rect_on(&l, &l.selection_rects(5, 6), 1).is_some());
+    // Selecting part of the first line, or a caret, leaves the empty line alone.
+    assert!(l.selection_rects(0, 1).iter().all(|r| r.y0 < l.lines[1].top - 1e-6), "{:?}", l.selection_rects(0, 1));
+    assert!(l.selection_rects(6, 6).is_empty());
+    // A right-to-left paragraph marks its empty last line too.
+    let rtl = layout(&TextData::new("\u{5E9}\u{5DC}\u{5D5}\u{5DD}\n"), None, None);
+    let Some(r) = rect_on(&rtl, &rtl.selection_rects(0, 5), 1) else { panic!("no highlight on the empty right-to-left line") };
+    assert!(r.x0.abs() < 1e-6 && (r.width() - 4.0).abs() < 1e-6, "{r:?}");
+}
+
+#[test]
+fn selection_after_a_line_break_starts_at_the_line_start() {
+    if !have_fonts() {
+        return;
+    }
+    // Not at the end of the line above, where `caret` puts the index after the break.
+    let l = layout(&TextData::new("Hello\nworld"), None, None);
+    let Some(r) = rect_on(&l, &l.selection_rects(0, 11), 1) else { panic!("no highlight on the second line") };
+    assert!(r.x0.abs() < 1e-6 && r.x1 > l.caret(10).0, "{r:?}");
+    // An empty line in the middle shows its break mark at its start.
+    let m = layout(&TextData::new("Hello\n\nworld"), None, None);
+    let Some(r) = rect_on(&m, &m.selection_rects(0, 12), 1) else { panic!("no highlight on the empty line") };
+    assert!(r.x0.abs() < 1e-6 && (r.width() - 4.0).abs() < 1e-6, "{r:?}");
+    // A break followed by text still doesn't highlight the next line's start.
+    assert!(rect_on(&l, &l.selection_rects(0, 6), 1).is_none());
+}
+
+#[test]
+fn the_caret_after_a_line_break_sits_on_the_next_line() {
+    if !have_fonts() {
+        return;
+    }
+    // Before the break: the end of its line; after it: the start of the next (after Enter, the
+    // caret shows on the new line, and Up/Down count from there).
+    let l = layout(&TextData::new("ab\ncd"), None, None);
+    assert_eq!(l.caret(2).1, 0);
+    assert!(l.caret(2).0 > 0.0);
+    assert_eq!(l.caret(3), (0.0, 1));
+    // A trailing break: the caret sits on the empty last line.
+    let l = layout(&TextData::new("ab\n"), None, None);
+    assert_eq!(l.caret(3), (0.0, 1));
+}
+
+#[test]
+fn lower_case_writes_final_sigma() {
+    if !have_fonts() {
+        return;
+    }
+    let gids = |t: &TextData| layout(t, None, None).glyphs.iter().map(|g| (g.gid, g.char_start)).collect::<Vec<_>>();
+    let want = gids(&TextData::new("οδος ας"));
+    let Some(face) = layout(&TextData::new("ς"), None, None).glyphs.first().map(|g| g.face.clone()) else { return };
+    if face.glyph_for('σ') == face.glyph_for('ς') {
+        eprintln!("face has no distinct final sigma; skipping");
+        return;
+    }
+    let mut t = TextData::new("ΟΔΟΣ ΑΣ");
+    t.style.case = figcraft_doc::TextCase::Lower;
+    assert_eq!(gids(&t), want, "one run");
+    // The word split across two styled runs: the final form is still chosen from the whole text.
+    let mut other = t.style.clone();
+    other.font_size += 4.0;
+    t.runs.push(figcraft_doc::StyleRun { start: 3, end: 4, style: other });
+    assert_eq!(gids(&t).iter().map(|g| g.0).collect::<Vec<_>>(), want.iter().map(|g| g.0).collect::<Vec<_>>(), "split runs");
+}
diff --git a/crates/ui-egui/Cargo.toml b/crates/ui-egui/Cargo.toml
index 65a3592d8..09cd22263 100644
--- a/crates/ui-egui/Cargo.toml
+++ b/crates/ui-egui/Cargo.toml
@@ -22,6 +22,7 @@ egui = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 log = { workspace = true }
+chrono = { workspace = true }
 base64 = { workspace = true }
 image = { workspace = true }
 egui_extras = { workspace = true }
diff --git a/crates/ui-egui/locales/bn.toml b/crates/ui-egui/locales/bn.toml
new file mode 100644
index 000000000..bc7c948c9
--- /dev/null
+++ b/crates/ui-egui/locales/bn.toml
@@ -0,0 +1,1786 @@
+# FigCraft interface strings: বাংলা, ইংরেজি থেকে অনূদিত।
+#
+# কীগুলো কোডে ব্যবহৃত ইংরেজি টেক্সট (`tr("…")`, `trf`, `trn`, `tr_noop`); মানগুলো অনূদিত,
+# বহুবচন এন্ট্রি ({ one, other }) ছাড়া। কমান্ডের লেবেল ইঞ্জিন থেকে আসে।
+# `cargo test -p figcraft-ui-egui i18n` অনুপস্থিত ও অব্যবহৃত কী তালিকাভুক্ত করে। docs/translating.md দেখুন।
+
+[meta]
+name = "বাংলা"
+status = "draft — needs native review"
+
+[ui]
+"% of all commits" = "সমস্ত কমিটের শতাংশ"
+"(no longer published)" = "(প্রকাশিত নয়)"
+"({n} warnings: some entries were skipped)" = { one = "({n}টি সতর্কতা: কিছু এন্ট্রি বাদ দেওয়া হয়েছে)", other = "({n}টি সতর্কতা: কিছু এন্ট্রি বাদ দেওয়া হয়েছে)" }
+"+ Create variable" = "+ ভেরিয়েবল তৈরি করুন"
+".fig (experimental)" = ".fig (পরীক্ষামূলক)"
+"1…9, 0" = "১…৯, ০"
+"@{login}: {prs} PRs, {commits} commits, +{added} / −{deleted} lines (Δ {delta}), +{bin_added} / −{bin_deleted} binary assets, {first} – {last}" = "@{login}: {prs}টি PR, {commits}টি কমিট, +{added} / −{deleted} লাইন (Δ {delta}), +{bin_added} / −{bin_deleted} বাইনারি অ্যাসেট, {first} – {last}"
+"A collection of this file with these modes and variables: override their values per mode and add variables of its own" = "এই মোড এবং ভেরিয়েবল সহ এই ফাইলের একটি সংগ্রহ: প্রতি মোডে তাদের মান ওভাররাইড করুন এবং এর নিজস্ব ভেরিয়েবল যোগ করুন"
+"A .figcraft file with this name already exists. Choose its full name to confirm replacement." = "এই নামের একটি .figcraft ফাইল ইতিমধ্যে বিদ্যমান। প্রতিস্থাপন নিশ্চিত করতে এর সম্পূর্ণ নাম বেছে নিন।"
+"A layer on its own aligns to its frame: select more layers, or one in a frame" = "একটি লেয়ার একা তার ফ্রেমের সাথে সারিবদ্ধ হয়: আরও লেয়ার নির্বাচন করুন, বা ফ্রেমে থাকা একটি লেয়ার নির্বাচন করুন"
+"A responsive product page: hero, features, figures, a quote and a footer" = "একটি রেসপনসিভ প্রোডাক্ট পেজ: হিরো, ফিচার, ফিগার, একটি উদ্ধৃতি এবং একটি ফুটার"
+"A spring plays until it settles: its mass, stiffness and damping set how long" = "একটি স্প্রিং স্থির হওয়া পর্যন্ত চলে: এর ভর, দৃঢ়তা (stiffness) এবং ড্যাম্পিং নির্ধারণ করে কতক্ষণ চলবে"
+"A title, an agenda, a big figure, a chart and a closing slide" = "একটি শিরোনাম, একটি আলোচ্যসূচি, একটি বড় ফিগার, একটি চার্ট এবং একটি সমাপ্তি স্লাইড"
+"A to Z" = "A থেকে Z"
+"About" = "সম্পর্কিত"
+"About FigCraft" = "FigCraft সম্পর্কে"
+"About this server" = "এই সার্ভার সম্পর্কে"
+"Action" = "অ্যাকশন"
+"Actions" = "অ্যাকশনসমূহ"
+"Actions for {name}" = "{name}-এর জন্য অ্যাকশন"
+"Actions…" = "অ্যাকশনসমূহ..."
+"Active" = "সক্রিয়"
+"Actual size (100%)" = "প্রকৃত আকার (১০০%)"
+"Add a category" = "একটি বিভাগ যোগ করুন"
+"Add a comment" = "একটি মন্তব্য যোগ করুন"
+"Add a description" = "একটি বিবরণ যোগ করুন"
+"Add a frame (F) or a shape (R) to get started" = "শুরু করতে একটি ফ্রেম (F) বা শেপ (R) যোগ করুন"
+"Add a layer or component to tile first" = "প্রথমে টাইল করার জন্য একটি লেয়ার বা কম্পোনেন্ট যোগ করুন"
+"Add a note for developers" = "ডেভেলপারদের জন্য একটি নোট যোগ করুন"
+"Add action" = "অ্যাকশন যোগ করুন"
+"Add actions for when no condition holds" = "কোনো শর্ত পূর্ণ না হলে তার জন্য অ্যাকশন যোগ করুন"
+"Add an annotation for developers" = "ডেভেলপারদের জন্য একটি অ্যানোটেশন যোগ করুন"
+"Add another condition" = "আরেকটি শর্ত যোগ করুন"
+"Add auto layout" = "অটো লেআউট যোগ করুন"
+"Add background behind overlay" = "ওভারলে-এর পেছনে ব্যাকগ্রাউন্ড যোগ করুন"
+"Add content to this slot" = "এই স্লটে কন্টেন্ট যোগ করুন"
+"Add dev resource" = "ডেভ রিসোর্স যোগ করুন"
+"Add effect" = "ইফেক্ট যোগ করুন"
+"Add export setting" = "এক্সপোর্ট সেটিংস যোগ করুন"
+"Add fill" = "ফিল যোগ করুন"
+"Add interaction" = "ইন্টারঅ্যাকশন যোগ করুন"
+"Add layout grid" = "লেআউট গ্রিড যোগ করুন"
+"Add library" = "লাইব্রেরি যোগ করুন"
+"Add library file…" = "লাইব্রেরি ফাইল যোগ করুন..."
+"Add max height" = "সর্বোচ্চ উচ্চতা যোগ করুন"
+"Add max width" = "সর্বোচ্চ প্রস্থ যোগ করুন"
+"Add min height" = "সর্বনিম্ন উচ্চতা যোগ করুন"
+"Add min width" = "সর্বনিম্ন প্রস্থ যোগ করুন"
+"Add mode" = "মোড যোগ করুন"
+"Add new page" = "নতুন পেজ যোগ করুন"
+"Add or update collections from a variables JSON" = "একটি ভেরিয়েবল JSON থেকে সংগ্রহ যোগ বা আপডেট করুন"
+"Add properties to make instances configurable" = "ইনস্ট্যান্সগুলোকে কনফিগারযোগ্য করতে প্রপার্টি যোগ করুন"
+"Add reaction" = "রিঅ্যাকশন যোগ করুন"
+"Add starting point" = "শুরু করার বিন্দু যোগ করুন"
+"Add stroke" = "স্ট্রোক যোগ করুন"
+"Add variant" = "ভ্যারিয়েন্ট যোগ করুন"
+"Add variant with a new value" = "একটি নতুন মান সহ ভ্যারিয়েন্ট যোগ করুন"
+"Added" = "যোগ করা হয়েছে"
+"Added the library \"{name}\"" = "\"{name}\" লাইব্রেরি যোগ করা হয়েছে"
+"Adding to {name}" = "{name}-এ যোগ করা হচ্ছে"
+"Adjust" = "সামঞ্জস্য করুন"
+"Adjustment presets" = "অ্যাডজাস্টমেন্ট প্রিসেট"
+"Advanced" = "উন্নত"
+"Advanced stroke" = "উন্নত স্ট্রোক"
+"After delay" = "বিলম্বের পর"
+"After delay {ms}ms" = "{ms}ms বিলম্বের পর"
+"Align" = "সারিবদ্ধ করুন"
+"Align bottom" = "নিচে সারিবদ্ধ করুন"
+"Align center" = "কেন্দ্রে সারিবদ্ধ করুন"
+"Align horizontal centers" = "অনুভূমিক কেন্দ্র বরাবর সারিবদ্ধ করুন"
+"Align left" = "বামে সারিবদ্ধ করুন"
+"Align middle" = "মাঝামাঝি সারিবদ্ধ করুন"
+"Align right" = "ডানে সারিবদ্ধ করুন"
+"Align text baselines" = "টেক্সট বেসলাইন সারিবদ্ধ করুন"
+"Align top" = "উপরে সারিবদ্ধ করুন"
+"Align vertical centers" = "উল্লম্ব কেন্দ্র বরাবর সারিবদ্ধ করুন"
+"Alignment" = "সারিবদ্ধকরণ"
+"All" = "সব"
+"All categories" = "সব বিভাগ"
+"All comments" = "সব মন্তব্য"
+"All components" = "সব কম্পোনেন্ট"
+"All fonts" = "সব ফন্ট"
+"All supported properties" = "সমর্থিত সব প্রপার্টি"
+"All the fonts this file uses are installed" = "এই ফাইলে ব্যবহৃত সব ফন্ট ইনস্টল করা আছে"
+"All variables" = "সব ভেরিয়েবল"
+"Alpha" = "আলফা"
+"Alphabetical" = "বর্ণানুক্রমিক"
+"Alt+drag" = "Alt+ড্র্যাগ"
+"An analytics screen on a grid: figures, charts drawn from vectors and a table" = "গ্রিডের উপর একটি অ্যানালিটিক্স স্ক্রিন: ফিগার, ভেক্টর থেকে আঁকা চার্ট এবং একটি টেবিল"
+"An invite link that opens FigCraft and joins" = "একটি আমন্ত্রণ লিংক যা FigCraft খুলে যুক্ত হয়"
+"Anchor" = "অ্যাঙ্কর"
+"Android" = "অ্যান্ড্রয়েড"
+"Angular" = "অ্যাঙ্গুলার"
+"Animation" = "অ্যানিমেশন"
+"Annotations" = "অ্যানোটেশন"
+"Annotations shown on the canvas" = "ক্যানভাসে অ্যানোটেশনগুলো দেখানো হচ্ছে"
+"Another server, or one that needs its key. The usual server is set in Preferences." = "অন্য একটি সার্ভার, অথবা যার কী প্রয়োজন। সাধারণ সার্ভারটি প্রেফারেন্সেসে সেট করা আছে।"
+"Any status" = "যেকোনো স্ট্যাটাস"
+"Anyone on your network with this code can edit the file, while this app stays open." = "এই অ্যাপ খোলা থাকা অবস্থায় আপনার নেটওয়ার্কে এই কোড জানা যেকোনো ব্যক্তি ফাইলটি এডিট করতে পারবেন।"
+"Anyone with the edit link can change the file; the view link only lets people look. The links carry their secrets: share them like passwords. `figcraft-server links` makes more and revokes them." = "এডিট লিংক থাকা যেকোনো ব্যক্তি ফাইলটি পরিবর্তন করতে পারবেন; ভিউ লিংক শুধু দেখতে দেয়। লিংকগুলো গোপন তথ্য বহন করে: পাসওয়ার্ডের মতো এগুলো শেয়ার করুন। `figcraft-server links` কমান্ড দিয়ে আরও তৈরি ও বাতিল করা যায়।"
+"Anyone with this code can edit the file." = "এই কোড জানা যেকোনো ব্যক্তি ফাইলটি এডিট করতে পারবেন।"
+"Anyone with this code can look at the file, not change it." = "এই কোড জানা যেকোনো ব্যক্তি ফাইলটি দেখতে পারবেন, পরিবর্তন করতে পারবেন না।"
+"Appearance" = "চেহারা"
+"Apply a component property" = "একটি কম্পোনেন্ট প্রপার্টি প্রয়োগ করুন"
+"Apply variable" = "ভেরিয়েবল প্রয়োগ করুন"
+"Apply variable to text" = "টেক্সটে ভেরিয়েবল প্রয়োগ করুন"
+"Apply variable to visibility" = "দৃশ্যমানতায় ভেরিয়েবল প্রয়োগ করুন"
+"Apps" = "অ্যাপস"
+"Apr" = "এপ্রিল"
+"Arc" = "আর্ক"
+"Arc ratio" = "আর্ক অনুপাত"
+"Arc start" = "আর্ক শুরু"
+"Arc sweep" = "আর্ক সুইপ"
+"Archive" = "আর্কাইভ"
+"Archived" = "আর্কাইভ করা হয়েছে"
+"Arrange" = "সাজান"
+"Arrow" = "তীর"
+"Arrow at the end" = "শেষে তীর"
+"As typed" = "যেমনটি টাইপ করা হয়েছে"
+"Asking the server…" = "সার্ভারকে জিজ্ঞাসা করা হচ্ছে..."
+"Assets" = "অ্যাসেট"
+"Aug" = "আগস্ট"
+"Auto" = "অটো"
+"Auto (space around)" = "অটো (চারপাশে স্পেস)"
+"Auto (space between)" = "অটো (মাঝখানে স্পেস)"
+"Auto (space evenly)" = "অটো (সমানভাবে স্পেস)"
+"Auto ({mode})" = "অটো ({mode})"
+"Auto columns" = "অটো কলাম"
+"Auto gap" = "অটো গ্যাপ"
+"Auto height" = "অটো উচ্চতা"
+"Auto layout" = "অটো লেআউট"
+"Auto rows" = "অটো সারি"
+"Auto width" = "অটো প্রস্থ"
+"Back to the FigCraft server" = "FigCraft সার্ভারে ফিরে যান"
+"Back to the font's value" = "ফন্টের মানে ফিরে যান"
+"Back" = "পেছনে"
+"Back to Ready for dev" = "ডেভের জন্য প্রস্তুত অবস্থায় ফিরে যান"
+"Back to Ready for dev: the next change compares with how it is now" = "ডেভের জন্য প্রস্তুত অবস্থায় ফিরে যান: পরবর্তী পরিবর্তনটি বর্তমান অবস্থার সাথে তুলনা করবে"
+"Back to assets" = "অ্যাসেটে ফিরে যান"
+"Back to current" = "বর্তমানে ফিরে যান"
+"Back to styles" = "স্টাইলে ফিরে যান"
+"Back to the canvas from a focused region" = "ফোকাসড অঞ্চল থেকে ক্যানভাসে ফিরে যান"
+"Back to the current version" = "বর্তমান সংস্করণে ফিরে যান"
+"Back to the values the font style implies" = "ফন্ট স্টাইল নির্দেশিত মানে ফিরে যান"
+"Background" = "ব্যাকগ্রাউন্ড"
+"Background blur" = "ব্যাকগ্রাউন্ড ব্লার"
+"Basics" = "মৌলিক বিষয়"
+"Before" = "আগে"
+"Bend" = "বাঁক"
+"Bevel" = "বেভেল"
+"Binary assets added" = "বাইনারি অ্যাসেট যোগ করা হয়েছে"
+"Binary assets removed" = "বাইনারি অ্যাসেট সরানো হয়েছে"
+"Black & white" = "কালো ও সাদা"
+"Bleed" = "ব্লিড"
+"Bleed marks" = "ব্লিড মার্ক"
+"Bleed marks need a bleed" = "ব্লিড মার্কের জন্য ব্লিড প্রয়োজন"
+"Blend" = "ব্লেন্ড"
+"Blend mode" = "ব্লেন্ড মোড"
+"Blue" = "নীল"
+"Blur" = "ব্লার"
+"Boolean" = "বুলিয়ান"
+"Boolean groups" = "বুলিয়ান গ্রুপ"
+"Both directions" = "উভয় দিক"
+"Bottom" = "নিচে"
+"Bottom left radius" = "নিচের বাম ব্যাসার্ধ"
+"Bottom right radius" = "নিচের ডান ব্যাসার্ধ"
+"Branch" = "ব্রাঞ্চ"
+"Branch archived" = "ব্রাঞ্চ আর্কাইভ করা হয়েছে"
+"Branch merged" = "ব্রাঞ্চ মার্জ করা হয়েছে"
+"Branch name" = "ব্রাঞ্চের নাম"
+"Branch of {file}" = "{file}-এর ব্রাঞ্চ"
+"Branch of {file} · merged or archived" = "{file}-এর ব্রাঞ্চ · মার্জ বা আর্কাইভ করা হয়েছে"
+"Branch updated from main" = "প্রধান (main) থেকে ব্রাঞ্চ আপডেট করা হয়েছে"
+"Branch {name}" = "ব্রাঞ্চ {name}"
+"Branches" = "ব্রাঞ্চসমূহ"
+"Bound to {name}. Click to detach the variable." = "{name}-এর সাথে আবদ্ধ। ভেরিয়েবলটি বিচ্ছিন্ন করতে ক্লিক করুন।"
+"Bring forward" = "সামনে আনুন"
+"Bring the main file's changes into the branch" = "প্রধান ফাইলের পরিবর্তনগুলো ব্রাঞ্চে নিয়ে আসুন"
+"Bring to front" = "সবার সামনে আনুন"
+"Bristle" = "ব্রিসল"
+"Browse" = "ব্রাউজ করুন"
+"Brush" = "ব্রাশ"
+"Brush rotation jitter" = "ব্রাশ ঘূর্ণন জিটার"
+"Brush scatter" = "ব্রাশ স্ক্যাটার"
+"Brush size jitter" = "ব্রাশ সাইজ জিটার"
+"Brush spacing" = "ব্রাশ স্পেসিং"
+"Bulleted list" = "বুলেটেড তালিকা"
+"C or Shift+C" = "C বা Shift+C"
+"C or ⇧C" = "C বা ⇧C"
+"CMYK colour" = "CMYK রঙ"
+"Can view" = "দেখতে পারেন"
+"Check" = "টিক"
+"Checking the fonts installed on this computer…" = "এই কম্পিউটারে ইনস্টল করা ফন্টগুলো চেক করা হচ্ছে..."
+"Checking the server…" = "সার্ভার চেক করা হচ্ছে..."
+"Chevron" = "শেভরন"
+"Clear from this list" = "এই তালিকা থেকে মুছে ফেলুন"
+"Code or invite link" = "কোড বা আমন্ত্রণ লিংক"
+"Color profile: {name}" = "কালার প্রোফাইল: {name}"
+"Colour and text styles, Light and Dark variables, buttons, inputs and cards" = "রঙ ও টেক্সট স্টাইল, লাইট এবং ডার্ক ভেরিয়েবল, বোতাম, ইনপুট এবং কার্ড"
+"Connector" = "সংযোগকারী"
+"Convert to frame" = "ফ্রেম রূপান্তর করুন"
+"Convert to section" = "সেকশনে রূপান্তর করুন"
+"CSS custom properties…" = "CSS কাস্টম প্রপার্টি..."
+"Can edit" = "এডিট করতে পারেন"
+"Can't read this library: {e}" = "এই লাইব্রেরি পড়া যাচ্ছে না: {e}"
+"Cancel" = "বাতিল"
+"Canvas" = "ক্যানভাস"
+"Canvas stacking" = "ক্যানভাস স্ট্যাকিং"
+"Cap height to baseline" = "বেসলাইনে ক্যাপ হাইট"
+"Case" = "কেস"
+"Case-sensitive forms" = "কেস-সেন্সিটিভ ফর্ম"
+"Categories" = "বিভাগসমূহ"
+"Center" = "কেন্দ্র"
+"Change alias" = "অ্যালিয়াস পরিবর্তন করুন"
+"Change resolved" = "পরিবর্তন সমাধান করা হয়েছে"
+"Change style" = "স্টাইল পরিবর্তন করুন"
+"Change to" = "এতে পরিবর্তন করুন"
+"Change to needs a layer inside a variant" = "পরিবর্তন করার জন্য ভ্যারিয়েন্টের ভেতরে একটি লেয়ার প্রয়োজন"
+"Changed" = "পরিবর্তিত"
+"Changed on both sides: keep one" = "উভয় দিকেই পরিবর্তিত হয়েছে: একটি রাখুন"
+"Changes on main" = "প্রধান (main)-এ পরিবর্তন"
+"Changes on the branch" = "ব্রাঞ্চে পরিবর্তন"
+"Changes unknown" = "পরিবর্তন অজ্ঞাত"
+"Choose React, Leptos, SwiftUI or Compose above to connect this component to its code." = "এই কম্পোনেন্টটিকে কোডের সাথে যুক্ত করতে উপরে React, Leptos, SwiftUI বা Compose বেছে নিন।"
+"Choose another profile to change it." = "পরিবর্তন করতে অন্য একটি প্রোফাইল বেছে নিন।"
+"Choose collection" = "সংগ্রহ (collection) বেছে নিন"
+"Choose image" = "ছবি বেছে নিন"
+"Choose mode" = "মোড বেছে নিন"
+"Choose variable" = "ভেরিয়েবল বেছে নিন"
+"Circle" = "বৃত্ত"
+"Clear recent" = "সাম্প্রতিকগুলো মুছে ফেলুন"
+"Click + to replace mixed content" = "মিশ্র কন্টেন্ট প্রতিস্থাপন করতে + এ ক্লিক করুন"
+"Click anywhere on the canvas to leave one." = "একটি রাখতে ক্যানভাসের যেকোনো জায়গায় ক্লিক করুন।"
+"Click or drag to merge · {alt} removes" = "মার্জ করতে ক্লিক বা ড্র্যাগ করুন · {alt} সরায়"
+"Click or drag to remove · {alt} merges" = "সরাতে ক্লিক বা ড্র্যাগ করুন · {alt} মার্জ করে"
+"Click to record a key" = "একটি কি রেকর্ড করতে ক্লিক করুন"
+"Clip content" = "ক্লিপ কন্টেন্ট"
+"Clip to shape" = "শেপে ক্লিপ করুন"
+"Close" = "বন্ধ করুন"
+"Close overlay" = "ওভারলে বন্ধ করুন"
+"Close preview" = "প্রিভিউ বন্ধ করুন"
+"Close tab" = "ট্যাব বন্ধ করুন"
+"Close version history" = "সংস্করণ ইতিহাস বন্ধ করুন"
+"Close when clicking outside" = "বাইরে ক্লিক করলে বন্ধ করুন"
+"Code" = "কোড"
+"Code syntax" = "কোড সিনট্যাক্স"
+"Collapse" = "সংকুচিত করুন"
+"Collapse panel" = "প্যানেল সংকুচিত করুন"
+"Collection" = "সংগ্রহ"
+"Collections" = "সংগ্রহসমূহ"
+"Color" = "রঙ"
+"Color burn" = "কালার বার্ন"
+"Color dodge" = "কালার ডজ"
+"Color format" = "কালার ফরম্যাট"
+"Color profile" = "কালার প্রোফাইল"
+"Color styles" = "কালার স্টাইল"
+"Color values in this file are in this color space." = "এই ফাইলের রঙের মানগুলো এই কালার স্পেসে রয়েছে।"
+"Color variables" = "কালার ভেরিয়েবল"
+"Colour" = "রঙ"
+"Column" = "কলাম"
+"Column gap" = "কলাম গ্যাপ"
+"Column sizes" = "কলামের আকার"
+"Column span" = "কলাম স্প্যান"
+"Columns" = "কলামসমূহ"
+"Columns {count}" = "কলাম {count}"
+"Comment" = "মন্তব্য"
+"Comments" = "মন্তব্যসমূহ"
+"Commits" = "কমিটসমূহ"
+"Company" = "কোম্পানি"
+"Compare changes" = "পরিবর্তন তুলনা করুন"
+"Compatibility notes" = "সঙ্গতি নোট (Compatibility notes)"
+"Completed" = "সম্পন্ন"
+"Component" = "কম্পোনেন্ট"
+"Component name" = "কম্পোনেন্টের নাম"
+"Component property" = "কম্পোনেন্ট প্রপার্টি"
+"Component set" = "কম্পোনেন্ট সেট"
+"Component sets" = "কম্পোনেন্ট সেটসমূহ"
+"Components" = "কম্পোনেন্টস"
+"Conditional" = "শর্তসাপেক্ষ"
+"Confetti" = "কনফেটি"
+"Conflicts" = "দ্বন্দ্ব (Conflicts)"
+"Connect to code" = "কোডের সাথে সংযুক্ত করুন"
+"Connected" = "সংযুক্ত"
+"Connected to code: {from}" = "কোডের সাথে সংযুক্ত: {from}"
+"Connection lost, reconnecting (attempt {attempt})…" = "সংযোগ বিচ্ছিন্ন হয়েছে, পুনরায় সংযোগ স্থাপন করা হচ্ছে (চেষ্টা {attempt})..."
+"Constrain proportions" = "অনুপাত ঠিক রাখুন"
+"Constraints" = "সীমাবদ্ধতা (Constraints)"
+"Content" = "কন্টেন্ট"
+"Contents hidden" = "কন্টেন্ট লুকানো আছে"
+"Contents only" = "শুধু কন্টেন্ট"
+"Contextual alternates" = "প্রসঙ্গভিত্তিক বিকল্প"
+"Contrast" = "কনট্রাস্ট (Contrast)"
+"Contributors" = "অবদানকারীগণ"
+"Contributors: {people} · Commits: {commits}" = "অবদানকারী: {people} · কমিট: {commits}"
+"Controller" = "কন্ট্রোলার"
+"Cool" = "কুল"
+"Copied as CSS" = "CSS হিসেবে কপি করা হয়েছে"
+"Copied as PNG" = "PNG হিসেবে কপি করা হয়েছে"
+"Copied as SVG" = "SVG হিসেবে কপি করা হয়েছে"
+"Copied as text" = "টেক্সট হিসেবে কপি করা হয়েছে"
+"Copied {value}" = "{value} কপি করা হয়েছে"
+"Copy" = "কপি করুন"
+"Copy as" = "যেভাবে কপি করবেন"
+"Copy as CSS" = "CSS হিসেবে কপি করুন"
+"Copy as PNG" = "PNG হিসেবে কপি করুন"
+"Copy as SVG" = "SVG হিসেবে কপি করুন"
+"Copy code" = "কোড কপি করুন"
+"Copy link" = "লিংক কপি করুন"
+"Copy the {label}" = "{label} কপি করুন"
+"Copy {value}" = "{value} কপি করুন"
+"Corner radius" = "কোণার ব্যাসার্ধ (Corner radius)"
+"Corner smoothing" = "কোণা মসৃণকরণ"
+"Couldn't download the variables" = "ভেরিয়েবলগুলো ডাউনলোড করা যায়নি"
+"Couldn't reach {server}: showing what this computer remembers." = "{server}-এ পৌঁছানো যায়নি: এই কম্পিউটার যা মনে রেখেছে তা দেখানো হচ্ছে।"
+"Couldn't save automatically: {error}" = "স্বয়ংক্রিয়ভাবে সেভ করা যায়নি: {error}"
+"Count" = "গণনা"
+"Create" = "তৈরি করুন"
+"Create a variable collection first" = "প্রথমে একটি ভেরিয়েবল সংগ্রহ তৈরি করুন"
+"Create a variable first" = "প্রথমে একটি ভেরিয়েবল তৈরি করুন"
+"Create alias" = "অ্যালিয়াস তৈরি করুন"
+"Create branch" = "ব্রাঞ্চ তৈরি করুন"
+"Create collection" = "সংগ্রহ তৈরি করুন"
+"Create component" = "কম্পোনেন্ট তৈরি করুন"
+"Create component property" = "কম্পোনেন্ট প্রপার্টি তৈরি করুন"
+"Create components, styles or variables to publish them as a library." = "লাইব্রেরি হিসেবে প্রকাশ করতে কম্পোনেন্ট, স্টাইল বা ভেরিয়েবল তৈরি করুন।"
+"Create property…" = "প্রপার্টি তৈরি করুন..."
+"Create style" = "স্টাইল তৈরি করুন"
+"Create style from the selected text" = "নির্বাচিত টেক্সট থেকে স্টাইল তৈরি করুন"
+"Created" = "তৈরি করা হয়েছে"
+"Crop" = "ক্রপ"
+"Crop marks" = "ক্রপ মার্ক"
+"Ctrl+arrows" = "Ctrl+অ্যারো"
+"Ctrl+click" = "Ctrl+ক্লিক"
+"Ctrl+scroll" = "Ctrl+স্ক্রল"
+"Current name" = "বর্তমান নাম"
+"Current version" = "বর্তমান সংস্করণ"
+"Cursor chat" = "কার্সার চ্যাট"
+"Custom" = "কাস্টম"
+"Custom size" = "কাস্টম আকার"
+"Cut" = "কাট করুন"
+"Dark" = "ডার্ক"
+"Darken" = "ডার্কেন"
+"Dash" = "ড্যাশ"
+"Dashboard" = "ড্যাশবোর্ড"
+"Date created" = "তৈরির তারিখ"
+"Dec" = "ডিসেম্বর"
+"Decoration style" = "সজ্জা স্টাইল (Decoration style)"
+"Decoration" = "সজ্জা"
+"Deep select" = "ডিপ সিলেক্ট"
+"Default" = "ডিফল্ট"
+"Default content" = "ডিফল্ট কন্টেন্ট"
+"Default value (the top-left variant)" = "ডিফল্ট মান (উপরের-বাম ভ্যারিয়েন্ট)"
+"Delay" = "বিলম্ব"
+"Delete" = "ডিলিট করুন"
+"Delete category (its annotations stay)" = "বিভাগ ডিলিট করুন (এর অ্যানোটেশনগুলো থেকে যাবে)"
+"Delete collection" = "সংগ্রহ ডিলিট করুন"
+"Delete group" = "গ্রুপ ডিলিট করুন"
+"Delete mode" = "মোড ডিলিট করুন"
+"Delete page" = "পেজ ডিলিট করুন"
+"Delete preset" = "প্রিসেট ডিলিট করুন"
+"Delete property" = "প্রপার্টি ডিলিট করুন"
+"Delete the style (layers keep their values)" = "স্টাইল ডিলিট করুন (লেয়ারগুলো তাদের মান ধরে রাখবে)"
+"Delete thread" = "থ্রেড ডিলিট করুন"
+"Delete variable" = "ভেরিয়েবল ডিলিট করুন"
+"Delete “{name}”? This can't be undone." = "“{name}” ডিলিট করবেন? এটি আর ফেরানো যাবে না।"
+"Density" = "ঘনত্ব"
+"Depth" = "গভীরতা"
+"Describe how and when to use this component" = "এই কম্পোনেন্টটি কীভাবে এবং কখন ব্যবহার করতে হবে তা বর্ণনা করুন"
+"Describe what changed" = "কী পরিবর্তিত হয়েছে তা বর্ণনা করুন"
+"Description" = "বিবরণ"
+"Description (optional)" = "বিবরণ (ঐচ্ছিক)"
+"Design" = "ডিজাইন"
+"Design panel" = "ডিজাইন প্যানেল"
+"Design system starter" = "ডিজাইন সিস্টেম স্টার্টার"
+"Desktop" = "ডেস্কটপ"
+"Destination" = "গন্তব্য"
+"Detach alias" = "অ্যালিয়াস বিচ্ছিন্ন করুন"
+"Detach instance" = "ইনস্ট্যান্স বিচ্ছিন্ন করুন"
+"Detach property" = "প্রপার্টি বিচ্ছিন্ন করুন"
+"Detach style" = "স্টাইল বিচ্ছিন্ন করুন"
+"Detach styles" = "স্টাইলগুলো বিচ্ছিন্ন করুন"
+"Detach variable" = "ভেরিয়েবল বিচ্ছিন্ন করুন"
+"Details" = "বিস্তারিত"
+"Dev Mode" = "ডেভ মোড"
+"Dev resources" = "ডেভ রিসোর্স"
+"Development" = "ডেভেলপমেন্ট"
+"Device" = "ডিভাইস"
+"Device at 100%" = "১০০%-এ ডিভাইস"
+"Diamond" = "ডায়মন্ড"
+"Difference" = "পার্থক্য"
+"Dimensions" = "মাত্রা (Dimensions)"
+"Direction" = "দিক"
+"Disconnect from code" = "কোড থেকে সংযোগ বিচ্ছিন্ন করুন"
+"Dispersion" = "বিচ্ছুরণ"
+"Display name" = "প্রদর্শিত নাম"
+"Dissolve" = "ডিসলভ"
+"Distribute and tidy" = "বণ্টন ও পরিপাটি করুন"
+"Distribute horizontal spacing" = "অনুভূমিক ব্যবধান বিতরণ করুন"
+"Distribute vertical spacing" = "উল্লম্ব ব্যবধান বিতরণ করুন"
+"Divider" = "ডিভাইডার"
+"Don't Save" = "সংরক্ষণ করবেন না"
+"Don't truncate" = "ট্রাঙ্কেট করবেন না"
+"Done" = "সম্পন্ন"
+"Done editing" = "সম্পাদনা শেষ"
+"Dots" = "বিন্দুসমূহ"
+"Dotted" = "ডটেড"
+"Down" = "নিচে"
+"Drafts" = "ড্রাফট"
+"Drag the stroke to add a width point" = "প্রস্থ বিন্দু যোগ করতে স্ট্রোকে ড্র্যাগ করুন"
+"Draw" = "আঁকুন"
+"Draw a frame" = "একটি ফ্রেম আঁকুন"
+"Drawing tools" = "অঙ্কন টুলস"
+"Drop a .figcraft, .fig, .json, .svg or image file." = "একটি .figcraft, .fig, .json, .svg বা ছবির ফাইল ড্রপ করুন।"
+"Drop to import" = "ইম্পোর্ট করতে ড্রপ করুন"
+"Drop to open" = "খুলতে ড্রপ করুন"
+"Drop shadow" = "ড্রপ শ্যাডো"
+"Dual-licensed MIT OR Apache-2.0. Made by the ArtCraft team and community." = "ডুয়াল-লাইসেন্সকৃত MIT বা Apache-2.0। ArtCraft টিম এবং কমিউনিটি দ্বারা তৈরি।"
+"Duo" = "ডুও"
+"Duplicate" = "প্রতিলিপি তৈরি করুন (Duplicate)"
+"Duplicate by dragging" = "ড্র্যাগ করে ডুপ্লিকেট করুন"
+"Duplicate mode" = "মোড ডুপ্লিকেট করুন"
+"Duplicate page" = "পেজ ডুপ্লিকেট করুন"
+"Edit" = "এডিট"
+"Edit as an expression" = "এক্সপ্রেশন হিসেবে এডিট করুন"
+"Edit colour" = "রঙ এডিট করুন"
+"Edit comment" = "মন্তব্য এডিট করুন"
+"Edit dev resource" = "ডেভ রিসোর্স এডিট করুন"
+"Edit link" = "লিংক এডিট করুন"
+"Edit link copied" = "এডিট লিংক কপি করা হয়েছে"
+"Edit style" = "স্টাইল এডিট করুন"
+"Edit variable" = "ভেরিয়েবল এডিট করুন"
+"Edit with the builder" = "বিল্ডার দিয়ে এডিট করুন"
+"Edited {when}" = "{when} এডিট করা হয়েছে"
+"Effect settings" = "ইফেক্ট সেটিংস"
+"Effect styles" = "ইফেক্ট স্টাইল"
+"Effects" = "ইফেক্টসমূহ"
+"Elbow" = "কোণযুক্ত"
+"Ellipse" = "উপবৃত্ত"
+"Ellipses" = "উপবৃত্তসমূহ"
+"Else" = "অন্যথায় (Else)"
+"Else if" = "অন্যথায় যদি (Else if)"
+"Embedded profile" = "এমবেডেড প্রোফাইল"
+"Empty" = "খালি"
+"End" = "শেষ"
+"End point" = "শেষ বিন্দু"
+"Ends the session; everyone keeps their copy" = "সেশন শেষ করে; সবাই তাদের কপি নিজের কাছে রাখে"
+"Enter" = "এন্টার"
+"Enter the address of a figcraft-server and press Browse to see the plugins it offers." = "একটি figcraft-সার্ভারের ঠিকানা দিন এবং এটি যে প্লাগইনগুলো অফার করে তা দেখতে ব্রাউজ টিপুন।"
+"Enter to save · Esc to cancel" = "সেভ করতে Enter · বাতিল করতে Esc"
+"Eraser" = "ইরেজার"
+"Esc" = "Esc"
+"Essential" = "অত্যাবশ্যকীয়"
+"Every conflict has a choice." = "প্রতিটি দ্বন্দ্বেরই একটি সমাধান বা পছন্দ থাকে।"
+"Every top-level frame already starts a flow" = "প্রতিটি শীর্ষ-স্তরের ফ্রেম ইতিমধ্যে একটি ফ্লো শুরু করে"
+"Exact opacity (4 then 5: 45%)" = "সঠিক অস্বচ্ছতা (4 তারপর 5: 45%)"
+"Exclude" = "বাদ দিন"
+"Excluded" = "বাদ দেওয়া হয়েছে"
+"Excluded from layout" = "লেআউট থেকে বাদ দেওয়া হয়েছে"
+"Excludes" = "বাদ দেয়"
+"Exclusion" = "এক্সক্লুশন"
+"Exit focus view (Esc)" = "ফোকাস ভিউ থেকে বের হন (Esc)"
+"Expand" = "প্রসারিত করুন"
+"Export" = "এক্সপোর্ট"
+"Export all" = "সব এক্সপোর্ট করুন"
+"Export frames and layers as PNG, JPG, SVG or PDF" = "ফ্রেম এবং লেয়ারগুলোকে PNG, JPG, SVG বা PDF হিসেবে এক্সপোর্ট করুন"
+"Export page as PNG" = "পেজ PNG হিসেবে এক্সপোর্ট করুন"
+"Export settings" = "এক্সপোর্ট সেটিংস"
+"Export variables" = "ভেরিয়েবল এক্সপোর্ট করুন"
+"Export {name}" = "{name} এক্সপোর্ট করুন"
+"Export {n} layers" = { one = "{n}টি লেয়ার এক্সপোর্ট করুন", other = "{n}টি লেয়ার এক্সপোর্ট করুন" }
+"Exported {file}" = "{file} এক্সপোর্ট করা হয়েছে"
+"Exported {name}" = "{name} এক্সপোর্ট করা হয়েছে"
+"Exported {name}; {n} kinds of content were left out" = { one = "{name} এক্সপোর্ট করা হয়েছে; {n} ধরনের কন্টেন্ট বাদ দেওয়া হয়েছে", other = "{name} এক্সপোর্ট করা হয়েছে; {n} ধরনের কন্টেন্ট বাদ দেওয়া হয়েছে" }
+"Exported {n} files" = { one = "{n}টি ফাইল এক্সপোর্ট করা হয়েছে", other = "{n}টি ফাইল এক্সপোর্ট করা হয়েছে" }
+"Export…" = "এক্সপোর্ট..."
+"Expose properties to instances" = "ইনস্ট্যান্সে প্রপার্টি উন্মুক্ত করুন"
+"Exposure" = "এক্সপোজার"
+"Expression" = "এক্সপ্রেশন"
+"Extend collection" = "সংগ্রহ প্রসারিত করুন"
+"Extends \"{name}\": overridden values are marked" = "\"{name}\"-কে প্রসারিত করে: ওভাররাইড করা মানগুলো চিহ্নিত করা আছে"
+"Eye" = "চোখ"
+"F" = "F"
+"Fade" = "ফেড"
+"False" = "মিথ্যা (False)"
+"Feb" = "ফেব্রুয়ারি"
+"Fetching from the server…" = "সার্ভার থেকে ডেটা আনা হচ্ছে..."
+"FigCraft couldn't open its window: {error}" = "FigCraft এর উইন্ডো খুলতে পারেনি: {error}"
+"FigCraft doesn't support every feature of these files yet. The notes list what was left out or changed in the imported copy; the original file is unchanged." = "FigCraft এখনো এই ফাইলগুলোর সব ফিচার সমর্থন করে না। নোটগুলোতে ইম্পোর্ট করা কপিতে যা বাদ দেওয়া হয়েছে বা পরিবর্তন করা হয়েছে তার তালিকা রয়েছে; মূল ফাইলটি অপরিবর্তিত রয়েছে।"
+"File" = "ফাইল"
+"File name" = "ফাইলের নাম"
+"File not found" = "ফাইল পাওয়া যায়নি"
+"File published" = "ফাইল প্রকাশিত হয়েছে"
+"Files aren't end-to-end encrypted: the server's operator can read them." = "ফাইলগুলো এন্ড-টু-এন্ড এনক্রিপ্টেড নয়: সার্ভারের অপারেটর এগুলো পড়তে পারেন।"
+"Files nobody opens for {n} days are deleted." = { one = "যে ফাইল {n} দিন কেউ খোলে না তা ডিলিট করা হয়।", other = "যে ফাইলগুলো {n} দিন কেউ খোলে না সেগুলো ডিলিট করা হয়।" }
+"Fill" = "ফিল"
+"Fill (fr)" = "ফিল (fr)"
+"Fill container" = "কন্টেইনার পূর্ণ করুন"
+"Fill window" = "উইন্ডো পূর্ণ করুন"
+"Fills" = "ফিলসমূহ"
+"Fill|sizing" = "ফিল"
+"Filter and sort" = "ফিল্টার ও সাজান"
+"Find" = "খুঁজুন"
+"Find and replace" = "খুঁজুন ও প্রতিস্থাপন করুন"
+"Find layers" = "লেয়ার খুঁজুন"
+"First" = "প্রথম"
+"First commit" = "প্রথম কমিট"
+"First on top" = "প্রথমে উপরে"
+"Fit" = "ফিট"
+"Fit device to window" = "উইন্ডোতে ডিভাইস ফিট করুন"
+"Fit to contents" = "কন্টেন্ট অনুযায়ী ফিট করুন"
+"Fit to window" = "উইন্ডো অনুযায়ী ফিট করুন"
+"Fit width" = "প্রস্থ ফিট করুন"
+"Fixed" = "নির্দিষ্ট (Fixed)"
+"Fixed gap" = "নির্দিষ্ট গ্যাপ"
+"Fixed size" = "নির্দিষ্ট আকার"
+"Flatten" = "ফ্ল্যাট করুন"
+"Flip" = "উল্টান (Flip)"
+"Flip horizontal" = "অনুভূমিকভাবে উল্টান"
+"Flip text to the other side" = "টেক্সট অন্য পাশে উল্টান"
+"Flip vertical" = "উল্লম্বভাবে উল্টান"
+"Flip width profile" = "প্রস্থ প্রোফাইল উল্টান"
+"Flow starting point" = "ফ্লো শুরুর বিন্দু"
+"Flow starting points" = "ফ্লো শুরুর বিন্দুসমূহ"
+"Flows" = "ফ্লোসমূহ"
+"Focus view" = "ফোকাস ভিউ"
+"Fold autosaves" = "স্বয়ংক্রিয় সেভ ভাঁজ করুন"
+"Folder: click to collapse" = "ফোল্ডার: সংকুচিত করতে ক্লিক করুন"
+"Folder: click to expand" = "ফোল্ডার: প্রসারিত করতে ক্লিক করুন"
+"Follow" = "অনুসরণ করুন"
+"Follow {name}" = "{name}-কে অনুসরণ করুন"
+"Following" = "অনুসরণ করা হচ্ছে"
+"Following {name} · {key} to stop" = "{name}-কে অনুসরণ করা হচ্ছে · থামতে {key} টিপুন"
+"Font" = "ফন্ট"
+"Font not installed" = "ফন্ট ইনস্টল করা নেই"
+"Font size" = "ফন্টের আকার"
+"Font style" = "ফন্ট স্টাইল"
+"Forget on this computer" = "এই কম্পিউটার থেকে মুছে ফেলুন"
+"Four screens of a trail app with components and a prototype flow" = "কম্পোনেন্ট এবং প্রোটোটাইপ ফ্লো সহ ট্রেইল অ্যাপের চারটি স্ক্রিন"
+"Fractions" = "ভগ্নাংশ"
+"Frame" = "ফ্রেম"
+"Frame selection" = "ফ্রেম নির্বাচন"
+"Frame tools" = "ফ্রেম টুলস"
+"Frames" = "ফ্রেমসমূহ"
+"From the library \"{name}\": read-only" = "\"{name}\" লাইব্রেরি থেকে: শুধুমাত্র পড়ার উপযোগী (read-only)"
+"From {name}" = "{name} থেকে"
+"From {server}" = "{server} থেকে"
+"Frost" = "ফ্রস্ট"
+"Gap" = "গ্যাপ"
+"Gap between columns" = "কলামের মধ্যবর্তী গ্যাপ"
+"Gap between items" = "আইটেমের মধ্যবর্তী গ্যাপ"
+"Gap between rows" = "সারির মধ্যবর্তী গ্যাপ"
+"Getting started" = "শুরু করা"
+"Give the address of a server open to the public, or a server's address with its key (`figcraft-server key` prints it)." = "পাবলিকের জন্য উন্মুক্ত কোনো সার্ভারের ঠিকানা দিন, অথবা কী সহ সার্ভারের ঠিকানা দিন (`figcraft-server key` এটি প্রিন্ট করে)।"
+"Glass" = "গ্লাস"
+"Go to main component" = "প্রধান কম্পোনেন্টে যান"
+"Go to {name}" = "{name}-এ যান"
+"Grab bag" = "গ্র্যাব ব্যাগ"
+"Gradient" = "গ্রেডিয়েন্ট"
+"Gray" = "ধূসর"
+"Green" = "সবুজ"
+"Greyscale components and two example screens to sketch a flow with" = "একটি ফ্লো স্কেচ করার জন্য গ্রেস্কেল কম্পোনেন্ট এবং দুটি উদাহরণ স্ক্রিন"
+"Grid" = "গ্রিড"
+"Grid ({size})" = "গ্রিড ({size})"
+"Grid styles" = "গ্রিড স্টাইল"
+"Grid {size}" = "গ্রিড {size}"
+"Group" = "গ্রুপ"
+"Group selection" = "গ্রুপ নির্বাচন"
+"Groups" = "গ্রুপসমূহ"
+"Gutter" = "গাটার"
+"Hand tool" = "হ্যান্ড টুল"
+"Hanging list" = "হ্যাংগিং তালিকা"
+"Hanging punctuation" = "হ্যাংগিং বিরামচিহ্ন"
+"Hard light" = "হার্ড লাইট"
+"Heart" = "হৃদয়"
+"Height" = "উচ্চতা"
+"Help" = "সহায়তা"
+"Help and resources" = "সহায়তা ও রিসোর্স"
+"Help page" = "সহায়তা পেজ"
+"Here: {names}" = "এখানে: {names}"
+"Hidden" = "লুকানো"
+"Hide contents" = "কন্টেন্ট লুকান"
+"Hide from publishing" = "প্রকাশ করা থেকে লুকান"
+"Hide section contents" = "সেকশনের কন্টেন্ট লুকান"
+"Hide these tips (Getting started in the Help menu shows them again)" = "এই টিপসগুলো লুকান (সহায়তা মেনুর 'শুরু করা' অপশনটি এগুলো আবার দেখাবে)"
+"Hide when publishing" = "প্রকাশ করার সময় লুকান"
+"Highlight layers on hover" = "হোভারে লেয়ার হাইলাইট করুন"
+"Highlighter" = "হাইলাইটার"
+"Highlights" = "হাইলাইটস"
+"Hold Alt" = "Alt চেপে ধরে রাখুন"
+"Hold Alt+Z" = "Alt+Z চেপে ধরে রাখুন"
+"Hold Ctrl" = "Ctrl চেপে ধরে রাখুন"
+"Hold Z" = "Z চেপে ধরে রাখুন"
+"Hold ⌃ or ⌘" = "⌃ বা ⌘ চেপে ধরে রাখুন"
+"Hold ⌥" = "⌥ চেপে ধরে রাখুন"
+"Hold ⌥Z" = "⌥Z চেপে ধরে রাখুন"
+"Home" = "হোম"
+"Horizontal" = "অনুভূমিক"
+"Horizontal align" = "অনুভূমিক সারিবদ্ধকরণ"
+"Horizontal hex" = "অনুভূমিক হেক্স"
+"Horizontal padding" = "অনুভূমিক প্যাডিং"
+"Horizontal spacing" = "অনুভূমিক ব্যবধান"
+"Hosted by {operator}" = "হোস্ট করেছেন: {operator}"
+"Hover a layer to see its properties" = "প্রপার্টি দেখতে কোনো লেয়ারের উপর হোভার করুন"
+"Hover other layers to measure the distance" = "দূরত্ব মাপতে অন্য লেয়ারগুলোর উপর হোভার করুন"
+"Hue" = "হিউ (Hue)"
+"Hug" = "হাগ"
+"Hug contents" = "কন্টেন্ট অনুযায়ী হাগ করুন"
+"Icon components on a 24 px grid with keylines and a size preview" = "কিলিন এবং সাইজ প্রিভিউ সহ ২৪ পিক্সেল গ্রিডে আইকন কম্পোনেন্ট"
+"Icon set starter" = "আইকন সেট স্টার্টার"
+"If it keeps happening, please report it at {link} with this message." = "যদি এটি বারবার ঘটতে থাকে, তবে অনুগ্রহ করে এই বার্তা সহ {link}-এ রিপোর্ট করুন।"
+"If" = "যদি (If)"
+"If {condition}" = "যদি {condition}"
+"Ignore auto layout (absolute position)" = "অটো লেআউট উপেক্ষা করুন (অ্যাবসোলিউট পজিশন)"
+"Image" = "ছবি"
+"Images" = "ছবিসমূহ"
+"Import" = "ইম্পোর্ট"
+"Import path" = "ইম্পোর্ট পাথ"
+"Import plugin from manifest" = "মেনিফেস্ট থেকে প্লাগইন ইম্পোর্ট করুন"
+"Import plugin from manifest…" = "মেনিফেস্ট থেকে প্লাগইন ইম্পোর্ট করুন..."
+"Import report" = "ইম্পোর্ট রিপোর্ট"
+"Import variables" = "ভেরিয়েবল ইম্পোর্ট করুন"
+"Imported document" = "ইম্পোর্ট করা ডকুমেন্ট"
+"Imported {name}" = "{name} ইম্পোর্ট করা হয়েছে"
+"Imported {n} new variables, updated {updated}" = { one = "{n}টি নতুন ভেরিয়েবল ইম্পোর্ট করা হয়েছে, {updated} আপডেট করা হয়েছে", other = "{n}টি নতুন ভেরিয়েবল ইম্পোর্ট করা হয়েছে, {updated} আপডেট করা হয়েছে" }
+"Import…" = "ইম্পোর্ট..."
+"In an instance, this comes from the main component" = "একটি ইনস্ট্যান্সে, এটি প্রধান কম্পোনেন্ট থেকে আসে"
+"In the browser you can join sessions the desktop app hosts and files on a FigCraft server. A page opened over https reaches other computers only through wss:// links (a server behind TLS)." = "ব্রাউজারে আপনি ডেস্কটপ অ্যাপের হোস্ট করা সেশন এবং FigCraft সার্ভারের ফাইলে যুক্ত হতে পারবেন। https-এর মাধ্যমে খোলা কোনো পেজ শুধুমাত্র wss:// লিঙ্কের (TLS-এর পেছনের সার্ভার) মাধ্যমে অন্যান্য কম্পিউটারে পৌঁছায়।"
+"Include bounding box" = "বাউন্ডিং বক্স অন্তর্ভুক্ত করুন"
+"Include id attribute" = "id অ্যাট্রিবিউট অন্তর্ভুক্ত করুন"
+"Included" = "অন্তর্ভুক্ত"
+"Included in layout" = "লেআউটে অন্তর্ভুক্ত"
+"Individual corners" = "পৃথক কোণা"
+"Individual strokes" = "পৃথক স্ট্রোক"
+"Ink" = "কালি (Ink)"
+"Inner shadow" = "ইনার শ্যাডো"
+"Inside" = "ভিতরে"
+"Inspect" = "ইন্সপেক্ট"
+"Inspect the layer under the pointer: size, colours, typography" = "পয়েন্টারের নিচের লেয়ারটি ইন্সপেক্ট করুন: আকার, রঙ, টাইপোগ্রাফি"
+"Install plugin" = "প্লাগইন ইনস্টল করুন"
+"Install" = "ইনস্টল করুন"
+"Installed {name}" = "{name} ইনস্টল করা হয়েছে"
+"Installed" = "ইনস্টল করা হয়েছে"
+"Installing…" = "ইনস্টল হচ্ছে..."
+"Instance" = "ইনস্ট্যান্স"
+"Instance properties" = "ইনস্ট্যান্স প্রপার্টি"
+"Instance swap" = "ইনস্ট্যান্স সোয়াপ"
+"Instance swap (no other component)" = "ইনস্ট্যান্স সোয়াপ (অন্য কোনো কম্পোনেন্ট নেই)"
+"Instances" = "ইনস্ট্যান্সসমূহ"
+"Instant" = "তাৎক্ষণিক"
+"Intensity" = "তীব্রতা"
+"Interaction" = "ইন্টারঅ্যাকশন"
+"Interactions" = "ইন্টারঅ্যাকশনসমূহ"
+"Interface design and prototyping. A free, open-source, clean-room design tool written from scratch in Rust, part of the ArtCraft Crafting Apps." = "ইন্টারফেস ডিজাইন এবং প্রোটোটাইপিং। Rust-এ শূন্য থেকে তৈরি একটি ফ্রি, ওপেন-সোর্স, ক্লিন-রুম ডিজাইন টুল, যা ArtCraft Crafting Apps-এর অংশ।"
+"Intersect" = "ছেদ (Intersect)"
+"Intersects" = "ছেদ করে"
+"Invalid color" = "অবৈধ রঙ"
+"Invite link" = "আমন্ত্রণ লিংক"
+"Invite link copied" = "আমন্ত্রণ লিংক কপি করা হয়েছে"
+"It asks permission to:" = "এটি অনুমতি চায়:"
+"Jan" = "জানুয়ারি"
+"Join" = "যুক্ত হোন"
+"Join code copied" = "যুক্তি কোড (Join code) কপি করা হয়েছে"
+"Join code or invite link" = "যুক্ত হওয়ার কোড বা আমন্ত্রণ লিংক"
+"Join live session" = "লাইভ সেশনে যুক্ত হোন"
+"Join us on Discord" = "ডিসকর্ডে আমাদের সাথে যুক্ত হোন"
+"Join with a code" = "কোড দিয়ে যুক্ত হোন"
+"Joined" = "যুক্ত হয়েছেন"
+"Joined {file}" = "{file}-এ যুক্ত হয়েছেন"
+"Joining…" = "যুক্ত হওয়া হচ্ছে..."
+"Join|stroke" = "জয়েন"
+"Jul" = "জুলাই"
+"Jun" = "জুন"
+"Just now" = "এইমাত্র"
+"Justify" = "উভয়মুখী সারিবদ্ধকরণ (Justify)"
+"Keep appearance" = "চেহারা অপরিবর্তিত রাখুন"
+"Keep appearance converts every color value to {profile} so colors look the same. Keep values leaves the numbers as they are, so colors shift." = "চেহারা অপরিবর্তিত রাখলে প্রতিটি রঙের মান {profile}-এ রূপান্তরিত হয় যাতে রঙগুলো একই দেখায়। মান অপরিবর্তিত রাখলে সংখ্যাগুলো যেমন আছে তেমনই থাকে, ফলে রঙ পরিবর্তিত হয়।"
+"Keep tool selected after use" = "ব্যবহারের পরেও টুল নির্বাচিত রাখুন"
+"Keep values" = "মান অপরিবর্তিত রাখুন"
+"Key/Gamepad" = "কি/গেমপ্যাড"
+"Key/Gamepad {key}" = "কি/গেমপ্যাড {key}"
+"Keyboard shortcuts" = "কিবোর্ড শর্টকাট"
+"Kits" = "কিটস"
+"Landing page" = "ল্যান্ডিং পেজ"
+"Language" = "ভাষা"
+"Lasso" = "ল্যাসো"
+"Last" = "শেষ"
+"Last change: {note}" = "শেষ পরিবর্তন: {note}"
+"Last commit" = "শেষ কমিট"
+"Last modified" = "সর্বশেষ সংশোধিত"
+"Last on top" = "প্রথমে নিচে"
+"Layer blur" = "লেয়ার ব্লার"
+"Layer name" = "লেয়ারের নাম"
+"Layers" = "লেয়ারসমূহ"
+"Layers in an instance take their position from the main component" = "ইনস্ট্যান্সের লেয়ারগুলো তাদের অবস্থান প্রধান কম্পোনেন্ট থেকে নেয়"
+"Layout" = "লেআউট"
+"Layout grid" = "লেআউট গ্রিড"
+"Layout grid settings" = "লেআউট গ্রিড সেটিংস"
+"Layout grids" = "লেআউট গ্রিডসমূহ"
+"Leave session" = "সেশন ত্যাগ করুন"
+"Leaves" = "ত্যাগ করে"
+"Left" = "বামে"
+"Left & right" = "বাম ও ডান"
+"Left side" = "বাম পাশ"
+"Left side width" = "বাম পাশের প্রস্থ"
+"Letter case" = "লেটার কেস"
+"Letter spacing" = "অক্ষরের ব্যবধান"
+"Libraries" = "লাইব্রেরিসমূহ"
+"Libraries in this file" = "এই ফাইলের লাইব্রেরিগুলো"
+"Library updates available" = "লাইব্রেরি আপডেট উপলব্ধ আছে"
+"Library: click to collapse" = "লাইব্রেরি: সংকুচিত করতে ক্লিক করুন"
+"Library: click to expand" = "লাইব্রেরি: প্রসারিত করতে ক্লিক করুন"
+"Library: its variables are read-only here; edit them in the library file and publish it" = "লাইব্রেরি: এর ভেরিয়েবলগুলো এখানে শুধুমাত্র পড়ার উপযোগী; লাইব্রেরি ফাইলে গিয়ে এগুলো এডিট করুন এবং প্রকাশ করুন"
+"Light" = "লাইট"
+"Lighten" = "লাইটেন"
+"Light|glass" = "লাইট"
+"Line" = "লাইন"
+"Line arrow" = "লাইন তীর"
+"Line delta" = "লাইন ডেল্টা"
+"Line height" = "লাইনের উচ্চতা"
+"Linear" = "লিনিয়ার"
+"Lines" = "লাইনসমূহ"
+"Lines +/−" = "লাইন +/−"
+"Lines added" = "লাইন যোগ করা হয়েছে"
+"Lines deleted" = "লাইন ডিলিট করা হয়েছে"
+"Link" = "লিংক"
+"Link copied" = "লিংক কপি করা হয়েছে"
+"Link docs, code or tickets for developers." = "ডেভেলপারদের জন্য ডকুমেন্ট, কোড বা টিকিট লিংক করুন।"
+"Link frames on the Prototype tab, then present the flow" = "প্রোটোটাইপ ট্যাবে ফ্রেমগুলো লিংক করুন, এরপর ফ্লো উপস্থাপন করুন"
+"Link this component to its code component: instances then show your real snippet with their values." = "এই কম্পোনেন্টটিকে এর কোড কম্পোনেন্টের সাথে লিংক করুন: ইনস্ট্যান্সগুলো তখন তাদের মানসহ আপনার আসল স্নিপেট দেখাবে।"
+"List spacing" = "তালিকায় ব্যবধান"
+"List style" = "তালিকায় স্টাইল"
+"Live session" = "লাইভ সেশন"
+"Live · {people}" = "লাইভ · {people}"
+"Local components" = "স্থানীয় কম্পোনেন্ট"
+"Local network" = "স্থানীয় নেটওয়ার্ক"
+"Local styles" = "স্থানীয় স্টাইল"
+"Local variables" = "স্থানীয় ভেরিয়েবল"
+"Lock/Unlock" = "লক/আনলক"
+"Locked" = "লক করা"
+"Lowercase" = "ছোট হাতের অক্ষর"
+"Luminance" = "লুমিন্যান্স"
+"Luminosity" = "উজ্জ্বলতা (Luminosity)"
+"Main" = "প্রধান"
+"Main component deleted" = "প্রধান কম্পোনেন্ট ডিলিট করা হয়েছে"
+"Main menu" = "প্রধান মেনু"
+"Make a component" = "একটি কম্পোনেন্ট তৈরি করুন"
+"Make slot" = "স্লট তৈরি করুন"
+"Mar" = "মার্চ"
+"Margin" = "মার্জিন"
+"Mark all as read" = "সব পঠিত হিসেবে চিহ্নিত করুন"
+"Mark as resolved" = "সমাধানকৃত হিসেবে চিহ্নিত করুন"
+"Mark as unread" = "অপঠিত হিসেবে চিহ্নিত করুন"
+"Mark as unresolved" = "অমীমাংসিত হিসেবে চিহ্নিত করুন"
+"Marker" = "মার্কার"
+"Mask" = "মাস্ক"
+"Mass · Stiffness · Damping" = "ভর · দৃঢ়তা · ড্যাম্পিং"
+"Match (empty: the whole name)" = "মেলবন্ধন (খালি: সম্পূর্ণ নাম)"
+"Max H" = "সর্বোচ্চ উচ্চতা"
+"Max W" = "সর্বোচ্চ প্রস্থ"
+"Max lines" = "সর্বোচ্চ লাইন"
+"Maximize" = "বড় করুন"
+"May" = "মে"
+"Measure to the selection" = "নির্বাচন পর্যন্ত পরিমাপ করুন"
+"Merge into main" = "প্রধান ফাইলের সাথে মার্জ করুন"
+"Merge regions" = "অঞ্চলগুলো মার্জ করুন"
+"Merge the branch into the main file (one undo step) and archive it" = "ব্রাঞ্চটিকে প্রধান ফাইলের সাথে মার্জ করুন (একটি আনডু ধাপ) এবং আর্কাইভ করুন"
+"Merged" = "মার্জ করা হয়েছে"
+"Merged PRs" = "মার্জ করা PR"
+"Min H" = "সর্বনিম্ন উচ্চতা"
+"Min W" = "সর্বনিম্ন প্রস্থ"
+"Minimize" = "ছোট করুন"
+"Mirror angle" = "মিরর কোণ"
+"Mirror angle and length" = "মিরর কোণ ও দৈর্ঘ্য"
+"Mirroring" = "মিররিং"
+"Missing" = "অনুপস্থিত"
+"Missing fonts" = "অনুপস্থিত ফন্ট"
+"Missing layer" = "অনুপস্থিত লেয়ার"
+"Missing style" = "অনুপস্থিত স্টাইল"
+"Missing variable" = "অনুপস্থিত ভেরিয়েবল"
+"Miter" = "মাইটার"
+"Miter angle" = "মাইটার কোণ"
+"Mixed" = "মিশ্রিত"
+"Mixed fonts" = "মিশ্র ফন্ট"
+"Mixed interactions: click + to replace them" = "মিশ্র ইন্টারঅ্যাকশন: প্রতিস্থাপন করতে + এ ক্লিক করুন"
+"Mobile app" = "মোবাইল অ্যাপ"
+"Mode" = "মোড"
+"Model" = "মডেল"
+"Models" = "মডেলসমূহ"
+"Mono" = "মোনো"
+"More" = "আরও"
+"More instance actions" = "আরও ইনস্ট্যান্স অ্যাকশন"
+"Mouse down" = "মাউস ডাউন"
+"Mouse enter" = "মাউস এন্টার"
+"Mouse leave" = "মাউস লিভ"
+"Mouse up" = "মাউস আপ"
+"Move along the toolbar or the layer rows" = "টুলবার বা লেয়ার সারির বরাবর সরান"
+"Move" = "সরান"
+"Move column left" = "কলাম বামে সরান"
+"Move column right" = "কলাম ডানে সরান"
+"Move down" = "নিচে সরান"
+"Move in" = "ভিতরে সরান"
+"Move out" = "বাইরে সরান"
+"Move tools" = "সরানোর টুলস"
+"Move up" = "উপরে সরান"
+"Moved to {name}" = "{name}-এ সরানো হয়েছে"
+"Multi" = "মাল্টি"
+"Multiply" = "মাল্টিপ্লাই"
+"Muted" = "মিউটেড"
+"Name" = "নাম"
+"Name (A–Z)" = "নাম (A–Z)"
+"Named instance" = "নামকৃত ইনস্ট্যান্স"
+"Navigate to" = "এতে যান"
+"Nested instance" = "নেস্টেড ইনস্ট্যান্স"
+"New board" = "নতুন বোর্ড"
+"New design file" = "নতুন ডিজাইন ফাইল"
+"Newest first" = "সবচেয়ে নতুন প্রথমে"
+"Next or previous control in the focused region" = "ফোকাসড অঞ্চলের পরবর্তী বা পূর্ববর্তী কন্ট্রোল"
+"Next frame" = "পরবর্তী ফ্রেম"
+"Next ready for dev" = "ডেভের জন্য পরবর্তী প্রস্তুত"
+"Next size option" = "পরবর্তী আকারের বিকল্প"
+"No assets: no export settings, icons or images. Add export settings in the Design tab." = "কোনো অ্যাসেট নেই: কোনো এক্সপোর্ট সেটিংস, আইকন বা ছবি নেই। ডিজাইন ট্যাবে এক্সপোর্ট সেটিংস যোগ করুন।"
+"No boolean variables fit here." = "এখানে কোনো বুলিয়ান ভেরিয়েবল মানানসই নয়।"
+"No boolean variables yet. Create them in Local variables." = "এখনো কোনো বুলিয়ান ভেরিয়েবল নেই। স্থানীয় ভেরিয়েবলে (Local variables) এগুলো তৈরি করুন।"
+"No branches. A branch is a copy of the file to try changes in, then review and merge." = "কোনো ব্রাঞ্চ নেই। ব্রাঞ্চ হলো পরিবর্তনগুলো পরীক্ষা করার জন্য ফাইলের একটি কপি, এরপর পর্যালোচনা করে মার্জ করা হয়।"
+"No category" = "কোনো বিভাগ নেই"
+"No changes" = "কোনো পরিবর্তন নেই"
+"No color styles" = "কোনো কালার স্টাইল নেই"
+"No colour variables fit here." = "এখানে কোনো রঙের ভেরিয়েবল মানানসই নয়।"
+"No colour variables yet. Create them in Local variables." = "এখনো কোনো রঙের ভেরিয়েবল নেই। স্থানীয় ভেরিয়েবলে এগুলো তৈরি করুন।"
+"No comments yet" = "এখনো কোনো মন্তব্য নেই"
+"No compatibility warnings reported" = "কোনো সঙ্গতির সতর্কতা রিপোর্ট করা হয়নি"
+"No components yet. Select layers and press {keys}." = "এখনো কোনো কম্পোনেন্ট নেই। লেয়ার নির্বাচন করুন এবং {keys} টিপুন।"
+"No conflicts." = "কোনো দ্বন্দ্ব নেই।"
+"No contributor data was built into this copy." = "এই কপিতে কোনো অবদানকারীর ডেটা যুক্ত করা হয়নি।"
+"No device" = "কোনো ডিভাইস নেই"
+"No fonts match" = "কোনো ফন্ট মেলে না"
+"No files or templates match your search" = "আপনার অনুসন্ধানের সাথে কোনো ফাইল বা টেমপ্লেট মেলে না"
+"No join code here (the server is older than join codes, or this address can't be put in one): share the link instead." = "এখানে কোনো যুক্ত হওয়ার কোড নেই (সার্ভারটি যুক্ত হওয়ার কোডের চেয়ে পুরনো, অথবা এই ঠিকানাকে কোডে রূপান্তর করা যায় না): পরিবর্তে লিংক শেয়ার করুন।"
+"No layer changes to show." = "দেখানোর মতো কোনো লেয়ার পরিবর্তন নেই।"
+"No libraries yet. Add a .figcraft file that was published as a library, or paste a team library's link." = "এখনো কোনো লাইব্রেরি নেই। লাইব্রেরি হিসেবে প্রকাশিত একটি .figcraft ফাইল যোগ করুন, অথবা টিম লাইব্রেরির লিংক পেস্ট করুন।"
+"No list" = "কোনো তালিকা নেই"
+"No matching comments" = "কোনো মিলছে এমন মন্তব্য নেই"
+"No matching components" = "কোনো মিলছে এমন কম্পোনেন্ট নেই"
+"No matching layers" = "কোনো মিলছে এমন লেয়ার নেই"
+"No matching styles" = "কোনো মিলছে এমন স্টাইল নেই"
+"No matching variables" = "কোনো মিলছে এমন ভেরিয়েবল নেই"
+"No mirroring" = "কোনো মিররিং নেই"
+"No model credits were built into this copy." = "এই কপিতে কোনো মডেল ক্রেডিট যুক্ত করা হয়নি।"
+"No number variables fit here." = "এখানে কোনো নম্বরের ভেরিয়েবল মানানসই নয়।"
+"No number variables yet. Create them in Local variables." = "এখনো কোনো নম্বরের ভেরিয়েবল নেই। স্থানীয় ভেরিয়েবলে এগুলো তৈরি করুন।"
+"No other pages" = "অন্য কোনো পেজ নেই"
+"No paints" = "কোনো পেইন্ট নেই"
+"No plugins on {server}." = "{server}-এ কোনো প্লাগইন নেই।"
+"No plugins yet. Import a development plugin from its figcraft-plugin.json." = "এখনো কোনো প্লাগইন নেই। এর figcraft-plugin.json থেকে একটি ডেভেলপমেন্ট প্লাগইন ইম্পোর্ট করুন।"
+"No preferred components" = "কোনো পছন্দের কম্পোনেন্ট নেই"
+"No preset" = "কোনো প্রিসেট নেই"
+"No saved versions yet. Save a version to mark a point in your work you can come back to." = "এখনো কোনো সংরক্ষিত সংস্করণ নেই। আপনার কাজের এমন একটি পয়েন্ট চিহ্নিত করতে একটি সংস্করণ সংরক্ষণ করুন যেখানে আপনি পরে ফিরে আসতে পারেন।"
+"No scrolling" = "কোনো স্ক্রোলিং নেই"
+"No shortcuts match" = "কোনো শর্টকাট মেলে না"
+"No status" = "কোনো স্ট্যাটাস নেই"
+"No string variables fit here." = "এখানে কোনো স্ট্রিং ভেরিয়েবল মানানসই নয়।"
+"No string variables yet. Create them in Local variables." = "এখনো কোনো স্ট্রিং ভেরিয়েবল নেই। স্থানীয় ভেরিয়েবলে এগুলো তৈরি করুন।"
+"No styles yet." = "এখনো কোনো স্টাইল নেই।"
+"No styles yet. Click + to create one from the selection." = "এখনো কোনো স্টাইল নেই। নির্বাচন থেকে একটি তৈরি করতে + এ ক্লিক করুন।"
+"No templates match your search" = "আপনার অনুসন্ধানের সাথে কোনো টেমপ্লেট মেলে না"
+"No text styles yet. Click + to create one from the selected text." = "এখনো কোনো টেক্সট স্টাইল নেই। নির্বাচিত টেক্সট থেকে একটি তৈরি করতে + এ ক্লিক করুন।"
+"No variables fit here." = "এখানে কোনো ভেরিয়েবল মানানসই নয়।"
+"No variables yet. Create them in Local variables." = "এখনো কোনো ভেরিয়েবল নেই। স্থানীয় ভেরিয়েবলে এগুলো তৈরি করুন।"
+"Nobody else is here yet" = "এখানে আর কেউ নেই"
+"Noise" = "নয়েজ"
+"None" = "কিছুই না"
+"None." = "কিছুই না।"
+"Normal" = "স্বাভাবিক"
+"Not bound" = "আবদ্ধ নয়"
+"Not in a live session" = "লাইভ সেশনে নেই"
+"Not in this font" = "এই ফন্টে নেই"
+"Not properties, kept as written: {names}" = "প্রপার্টি নয়, যেমনটি লেখা হয়েছে তেমনি রাখা হয়েছে: {names}"
+"Not read yet" = "এখনো পড়া হয়নি"
+"Not shared" = "শেয়ার করা হয়নি"
+"Note {n}" = "নোট {n}"
+"Nothing changed since this was marked ready for dev." = "এটি ডেভের জন্য প্রস্তুত হিসেবে চিহ্নিত করার পর থেকে কিছু পরিবর্তিত হয়নি।"
+"Nothing here yet. Set a frame's status to list it." = "এখানে এখনো কিছু নেই। তালিকাভুক্ত করতে একটি ফ্রেমের স্ট্যাটাস সেট করুন।"
+"Nothing online yet. Use Share on a file to put it online and it is listed here." = "অনলাইনে এখনো কিছু নেই। কোনো ফাইল অনলাইনে দিতে শেয়ার ব্যবহার করুন এবং এটি এখানে তালিকাভুক্ত হবে।"
+"Nothing to export" = "এক্সপোর্ট করার মতো কিছু নেই"
+"Nov" = "নভেম্বর"
+"Now" = "এখন"
+"Nudge (Shift: big nudge)" = "নাজ (Shift: বড় নাজ)"
+"Nudge amount" = "নাজ পরিমাণ"
+"Number" = "নম্বর"
+"Number ↑" = "নম্বর ↑"
+"Number ↓" = "নম্বর ↓"
+"Numbered list" = "সাংখ্যিক তালিকা"
+"Object" = "অবজেক্ট"
+"Oct" = "অক্টোবর"
+"Off" = "বন্ধ"
+"Offered first when filling the slot (any content is allowed)" = "স্লট পূর্ণ করার সময় প্রথমে অফার করা হয় (যেকোনো কন্টেন্ট অনুমোদিত)"
+"Offered first when swapping the instance (any component is allowed)" = "ইনস্ট্যান্স সোয়াপ করার সময় প্রথমে অফার করা হয় (যেকোনো কম্পোনেন্ট অনুমোদিত)"
+"Offset" = "অফসেট"
+"Oldest first" = "সবচেয়ে পুরনো প্রথমে"
+"On click" = "ক্লিকে"
+"On drag" = "ড্র্যাগে"
+"On this page" = "এই পেজে"
+"One announcement in five common sizes: square, portrait, story, link and banner" = "পাঁচটি সাধারণ আকারে একটি ঘোষণা: স্কয়ার, পোর্ট্রেট, স্টোরি, লিংক এবং ব্যানার"
+"Online" = "অনলাইন"
+"Online files" = "অনলাইন ফাইলসমূহ"
+"Online sharing is off: files are shared on the local network only." = "অনলাইন শেয়ারিং বন্ধ আছে: ফাইলগুলো শুধুমাত্র স্থানীয় নেটওয়ার্কে শেয়ার করা হচ্ছে।"
+"Only the first changed layers are listed." = "শুধুমাত্র প্রথম পরিবর্তিত লেয়ারগুলো তালিকাভুক্ত করা হয়েছে।"
+"Only the first {n} changed layers are listed." = "শুধুমাত্র প্রথম {n}টি পরিবর্তিত লেয়ার তালিকাভুক্ত করা হয়েছে।"
+"Only your threads" = "শুধুমাত্র আপনার থ্রেড"
+"Opacity" = "অস্বচ্ছতা (Opacity)"
+"Opacity & blend" = "অস্বচ্ছতা ও ব্লেন্ড"
+"Opacity 10%…90%, 0: 100%" = "অস্বচ্ছতা ১০%…৯০%, ০: ১০০%"
+"Open" = "খুলুন"
+"Open .figcraft, .svg or images" = ".figcraft, .svg বা ছবি খুলুন"
+"Open branch" = "ব্রাঞ্চ খুলুন"
+"Open file" = "ফাইল খুলুন"
+"Open files" = "ফাইলসমূহ খুলুন"
+"Open in focus view" = "ফোকাস ভিউতে খুলুন"
+"Open in new window" = "নতুন উইন্ডোতে খুলুন"
+"Open invite links in FigCraft" = "FigCraft-এ আমন্ত্রণ লিংক খুলুন"
+"Open link" = "লিংক খুলুন"
+"Open link {url}" = "লিংক খুলুন {url}"
+"Open overlay" = "ওভারলে খুলুন"
+"Open prototype preview" = "প্রোটোটাইপ প্রিভিউ খুলুন"
+"Open variables ({count})" = "ভেরিয়েবল খুলুন ({count})"
+"Opened as a new document" = "নতুন ডকুমেন্ট হিসেবে খোলা হয়েছে"
+"Opened “{name}” in a new tab" = "নতুন ট্যাবে “{name}” খোলা হয়েছে"
+"Opening the file…" = "ফাইল খোলা হচ্ছে..."
+"Opening {n} files as new files" = { one = "নতুন ফাইল হিসেবে খোলা হচ্ছে", other = "{n}টি ফাইল নতুন ফাইল হিসেবে খোলা হচ্ছে" }
+"Open|comments" = "খুলুন"
+"Options" = "বিকল্পসমূহ"
+"Orange" = "কমলা"
+"Order" = "ক্রম"
+"Other apps may not open every .fig file exported here." = "অন্যান্য অ্যাপ এখানে এক্সপোর্ট করা প্রতিটি .fig ফাইল নাও খুলতে পারে।"
+"Other" = "অন্যান্য"
+"Others lose access and keep their copy; the file stays on the server for you" = "অন্যরা অ্যাক্সেস হারায় এবং তাদের কপি নিজের কাছে রাখে; ফাইলটি আপনার জন্য সার্ভারেই থেকে যায়"
+"Others type this under Share ▸ Join with a code" = "অন্যরা 'Share ▸ Join with a code' এর নিচে এটি টাইপ করে"
+"Outline stroke" = "আউটলাইন স্ট্রোক"
+"Outline text" = "আউটলাইন টেক্সট"
+"Outlines" = "আউটলাইনসমূহ"
+"Outside" = "বাইরে"
+"Overflow" = "ওভারফ্লো"
+"Overlay" = "ওভারলে"
+"Overlay position" = "ওভারলে অবস্থান"
+"Overridden here (the collection it extends has another value)" = "এখানে ওভাররাইড করা হয়েছে (যে সংগ্রহটি এটি প্রসারিত করে তার অন্য একটি মান রয়েছে)"
+"Overrides" = "ওভাররাইডসমূহ"
+"Owner token" = "ওনার টোকেন"
+"Owner token copied" = "ওনার টোকেন কপি করা হয়েছে"
+"PDF print options" = "PDF প্রিন্ট বিকল্প"
+"PDF print settings" = "PDF প্রিন্ট সেটিংস"
+"Padding" = "প্যাডিং"
+"Page" = "পেজ"
+"Pages" = "পেজসমূহ"
+"Pages added to the document" = "ডকুমেন্টে পেজ যোগ করা হয়েছে"
+"Pink" = "গোলাপি"
+"Placed on the current page" = "বর্তমান পেজে রাখা হয়েছে"
+"Pages: {pages}" = "পেজসমূহ: {pages}"
+"Paint bucket" = "পেইন্ট বালতি"
+"Pan the canvas" = "ক্যানভাস প্যান করুন"
+"Pan with nothing selected (Shift: farther)" = "কিছু নির্বাচিত না করে প্যান করুন (Shift: দূরে)"
+"Panels" = "প্যানেলসমূহ"
+"Paper" = "কাগজ"
+"Paragraph indent" = "প্যারাগ্রাফ ইনডেন্ট"
+"Paragraph indent applies to left-aligned text" = "প্যারাগ্রাফ ইনডেন্ট বাম-সারিবদ্ধ টেক্সটের ক্ষেত্রে প্রযোজ্য"
+"Paragraph spacing" = "প্যারাগ্রাফ ব্যবধান"
+"Pass through" = "পাস থ্রু"
+"Paste a link (https://…)" = "একটি লিংক পেস্ট করুন (https://…)"
+"Paste a team library link (a view link)" = "একটি টিম লাইব্রেরি লিংক পেস্ট করুন (ভিউ লিংক)"
+"Paste here" = "এখানে পেস্ট করুন"
+"Paste to replace" = "প্রতিস্থাপন করতে পেস্ট করুন"
+"Pasted design layers; {n} kinds of content were left out" = { one = "ডিজাইন লেয়ার পেস্ট করা হয়েছে; {n} ধরনের কন্টেন্ট বাদ দেওয়া হয়েছে", other = "ডিজাইন লেয়ার পেস্ট করা হয়েছে; {n} ধরনের কন্টেন্ট বাদ দেওয়া হয়েছে" }
+"Pattern" = "প্যাটার্ন"
+"Pattern alignment" = "প্যাটার্ন সারিবদ্ধকরণ"
+"Pattern scale" = "প্যাটার্ন স্কেল"
+"Pattern source" = "প্যাটার্ন উৎস"
+"Pen" = "কলম"
+"Pencil" = "পেন্সিল"
+"People in this file" = "এই ফাইলের লোকজন"
+"People join from anywhere with a code. The file is kept on {server} while you share it." = "কোডের মাধ্যমে যেকোনো স্থান থেকে লোকজন যুক্ত হতে পারে। ফাইলটি শেয়ার করার সময় {server}-এ রাখা হয়।"
+"People on your network join with a code. Nothing goes through a server." = "আপনার নেটওয়ার্কের লোকজন কোডের মাধ্যমে যুক্ত হয়। কোনো সার্ভারের মাধ্যমে কিছু যায় না।"
+"Phone" = "ফোন"
+"Pick color" = "রঙ বাছুন"
+"Pick color (I)" = "রঙ বাছুন (I)"
+"Pick one font family first" = "প্রথমে একটি ফন্ট ফ্যামিলি বাছুন"
+"Pick the Frame tool, then drag on the canvas or choose a device size" = "ফ্রেম টুল বেছে নিন, এরপর ক্যানভাসে ড্র্যাগ করুন অথবা একটি ডিভাইসের আকার বেছে নিন"
+"Pin a property" = "একটি প্রপার্টি পিন করুন"
+"Pinch" = "পিন্চ"
+"Pixel grid" = "পিক্সেল গ্রিড"
+"Pixel preview 1x" = "পিক্সেল প্রিভিউ 1x"
+"Pixel preview 2x" = "পিক্সেল প্রিভিউ 2x"
+"Place a shape or frame (its tool chosen)" = "একটি শেপ বা ফ্রেম রাখুন (এর টুল নির্বাচিত)"
+"Place automatically" = "স্বয়ংক্রিয়ভাবে রাখুন"
+"Place image" = "ছবি রাখুন"
+"Plugin" = "প্লাগইন"
+"Plugins run in FigCraft's sandbox, without files, network or clock. Install only plugins you trust." = "প্লাগইনগুলো ফাইল, নেটওয়ার্ক বা ঘড়ি ছাড়া FigCraft-এর স্যান্ডবক্সে চলে। শুধুমাত্র বিশ্বস্ত প্লাগইন ইনস্টল করুন।"
+"Plugins" = "প্লাগইনসমূহ"
+"Plugins & widgets" = "প্লাগইন ও উইজেট"
+"Plus darker" = "প্লাস অন্ধকার"
+"Plus lighter" = "প্লাস হালকা"
+"Plus one" = "প্লাস ওয়ান"
+"Point" = "বিন্দু"
+"Points" = "বিন্দুসমূহ"
+"Polygon" = "বহুভুজ"
+"Polygons" = "বহুভুজসমূহ"
+"Port" = "পোর্ট"
+"Position" = "অবস্থান"
+"Post" = "পোস্ট"
+"Preferences" = "প্রেফারেন্সেস"
+"Preferred" = "পছন্দসই"
+"Present" = "উপস্থাপন করুন"
+"Present or preview" = "উপস্থাপন বা প্রিভিউ করুন"
+"Present this flow" = "এই ফ্লো উপস্থাপন করুন"
+"Presentation" = "উপস্থাপন"
+"Presentation slides" = "উপস্থাপন স্লাইড"
+"Presenting: comments" = "উপস্থাপন করা হচ্ছে: মন্তব্য"
+"Presenting: cycle the size options" = "উপস্থাপন করা হচ্ছে: আকারের বিকল্পগুলো সাইকেল করুন"
+"Presenting: full screen" = "উপস্থাপন করা হচ্ছে: ফুল স্ক্রিন"
+"Presenting: next frame" = "উপস্থাপন করা হচ্ছে: পরবর্তী ফ্রেম"
+"Presenting: previous frame" = "উপস্থাপন করা হচ্ছে: পূর্ববর্তী ফ্রেম"
+"Presenting: restart" = "উপস্থাপন করা হচ্ছে: পুনরায় শুরু"
+"Preserve scroll position" = "স্ক্রোল অবস্থান সংরক্ষণ করুন"
+"Presets" = "প্রিসেটসমূহ"
+"Press a key…" = "একটি কি টিপুন..."
+"Playground" = "প্লেগ্রাউন্ড"
+"Preview" = "প্রিভিউ"
+"Preview this flow" = "এই ফ্লো প্রিভিউ করুন"
+"Preview this frame" = "এই ফ্রেম প্রিভিউ করুন"
+"Previous frame" = "পূর্ববর্তী ফ্রেম"
+"Previous ready for dev" = "ডেভের জন্য পূর্ববর্তী প্রস্তুত"
+"Progressive" = "প্রোগ্রেসিভ"
+"Properties" = "প্রপার্টিজ"
+"Prototype" = "প্রোটোটাইপ"
+"Prototype preview" = "প্রোটোটাইপ প্রিভিউ"
+"Prototype settings" = "প্রোটোটাইপ সেটিংস"
+"Publish" = "প্রকাশ করুন"
+"Publish changes" = "পরিবর্তন প্রকাশ করুন"
+"Publish to another server…" = "অন্য সার্ভারে প্রকাশ করুন..."
+"Publish to server" = "সার্ভারে প্রকাশ করুন"
+"Published version {v}" = "প্রকাশিত সংস্করণ {v}"
+"Published version {v} to the server" = "সংস্করণ {v} সার্ভারে প্রকাশ করা হয়েছে"
+"Published version {v}: save the file so other files can use it" = "প্রকাশিত সংস্করণ {v}: ফাইলটি সেভ করুন যাতে অন্যান্য ফাইল এটি ব্যবহার করতে পারে"
+"Published · {people}" = "প্রকাশিত · {people}"
+"Publishing to a server needs the desktop app; in the browser you can join a server's files" = "সার্ভারে প্রকাশ করতে ডেস্কটপ অ্যাপ প্রয়োজন; ব্রাউজারে আপনি সার্ভারের ফাইলে যুক্ত হতে পারবেন"
+"Publishing with the server's key." = "সার্ভারের কী দিয়ে প্রকাশ করা হচ্ছে।"
+"Publishing…" = "প্রকাশ করা হচ্ছে..."
+"Push" = "পুশ"
+"Push changes to main component" = "প্রধান কম্পোনেন্টে পরিবর্তন পুশ করুন"
+"Put text on path" = "পাথে টেক্সট রাখুন"
+"Question" = "প্রশ্ন"
+"R" = "R"
+"Radial" = "রেডিয়াল"
+"Radius" = "ব্যাসার্ধ"
+"Ratio" = "অনুপাত"
+"Reading the library…" = "লাইব্রেরি পড়া হচ্ছে..."
+"Ready for dev" = "ডেভের জন্য প্রস্তুত"
+"Real name" = "আসল নাম"
+"Recent" = "সাম্প্রতিক"
+"Recent files" = "সাম্প্রতিক ফাইল"
+"Recents" = "সাম্প্রতিকসমূহ"
+"Recovered {n} unsaved files after the app quit unexpectedly: save them to keep them" = { one = "অ্যাপটি অপ্রত্যাশিতভাবে বন্ধ হয়ে যাওয়ার পর একটি অসংরক্ষিত ফাইল পুনরুদ্ধার করা হয়েছে: এটি রাখতে সেভ করুন", other = "অ্যাপটি অপ্রত্যাশিতভাবে বন্ধ হয়ে যাওয়ার পর {n}টি অসংরক্ষিত ফাইল পুনরুদ্ধার করা হয়েছে: এগুলো রাখতে সেভ করুন" }
+"Rectangle" = "আয়তক্ষেত্র"
+"Rectangles" = "আয়তক্ষেত্রসমূহ"
+"Red" = "লাল"
+"Reduce motion" = "মোশন কমান"
+"Refraction" = "প্রতিসরণ"
+"Regular expression" = "রেগুলার এক্সপ্রেশন"
+"Remove" = "সরান"
+"Remove all" = "সব সরান"
+"Remove annotation" = "অ্যানোটেশন সরান"
+"Remove auto layout" = "অটো লেআউট সরান"
+"Remove dev resource" = "ডেভ রিসোর্স সরান"
+"Remove export setting" = "এক্সপোর্ট সেটিংস সরান"
+"Remove from recents" = "সাম্প্রতিক থেকে সরান"
+"Remove from server" = "সার্ভার থেকে সরান"
+"Remove from server…" = "সার্ভার থেকে সরান..."
+"Remove guide" = "গাইড সরান"
+"Remove interaction" = "ইন্টারঅ্যাকশন সরান"
+"Remove library from this file" = "এই ফাইল থেকে লাইব্রেরি সরান"
+"Remove min and max" = "সর্বনিম্ন এবং সর্বোচ্চ সরান"
+"Remove min and max height" = "সর্বনিম্ন এবং সর্বোচ্চ উচ্চতা সরান"
+"Remove min and max width" = "সর্বনিম্ন এবং সর্বোচ্চ প্রস্থ সরান"
+"Remove regions" = "অঞ্চলগুলো সরান"
+"Remove slot" = "স্লট সরান"
+"Remove starting point" = "শুরু করার বিন্দু সরান"
+"Remove stop" = "স্টপ সরান"
+"Remove text from path" = "পাথ থেকে টেক্সট সরান"
+"Remove the else and its actions" = "else এবং এর অ্যাকশনগুলো সরান"
+"Remove this condition and its actions" = "এই শর্ত এবং এর অ্যাকশনগুলো সরান"
+"Remove this file from the server? It can't be shared or opened from there again. Your copy stays open here." = "সার্ভার থেকে এই ফাইলটি সরাবেন? এটি সেখান থেকে আর শেয়ার বা খোলা যাবে না। আপনার কপিটি এখানে খোলা থাকবে।"
+"Remove {name} from session" = "সেশন থেকে {name}-কে সরান"
+"Remove {name} from {server}?" = "{server} থেকে {name}-কে সরাবেন?"
+"Removed" = "সরে গেছে"
+"Removed from the server" = "সার্ভার থেকে সরানো হয়েছে"
+"Removed since it was marked" = "চিহ্নিত করার পর থেকে সরানো হয়েছে"
+"Rename" = "নাম পরিবর্তন করুন"
+"Rename duplicated layers" = "ডুপ্লিকেট করা লেয়ারের নাম পরিবর্তন করুন"
+"Rename folder" = "ফোল্ডারের নাম পরিবর্তন করুন"
+"Rename group" = "গ্রুপের নাম পরিবর্তন করুন"
+"Rename layers" = "লেয়ারের নাম পরিবর্তন করুন"
+"Rename mode" = "মোডের নাম পরিবর্তন করুন"
+"Rename on the server" = "সার্ভারে নাম পরিবর্তন করুন"
+"Rename on the server…" = "সার্ভারে নাম পরিবর্তন করুন..."
+"Rename page" = "পেজের নাম পরিবর্তন করুন"
+"Rename to" = "নাম পরিবর্তন করে রাখুন"
+"Replace all" = "সব প্রতিস্থাপন করুন"
+"Replace mixed export settings" = "মিশ্র এক্সপোর্ট সেটিংস প্রতিস্থাপন করুন"
+"Replace with" = "এটি দিয়ে প্রতিস্থাপন করুন"
+"Replace with a new interaction" = "একটি নতুন ইন্টারঅ্যাকশন দিয়ে প্রতিস্থাপন করুন"
+"Reply" = "উত্তর দিন"
+"Report" = "রিপোর্ট"
+"Report this file…" = "এই ফাইলটি রিপোর্ট করুন..."
+"Reset" = "রিসেট"
+"Reset adjustments" = "অ্যাডজাস্টমেন্ট রিসেট করুন"
+"Reset all changes" = "সব পরিবর্তন রিসেট করুন"
+"Reset all overrides on this layer" = "এই লেয়ারের সব ওভাররাইড রিসেট করুন"
+"Reset overrides" = "ওভাররাইড রিসেট করুন"
+"Reset slot" = "স্লট রিসেট করুন"
+"Reset this override" = "এই ওভাররাইড রিসেট করুন"
+"Reset to style" = "স্টাইলে রিসেট করুন"
+"Reset to the inherited value" = "উত্তরাধিকারসূত্রে প্রাপ্ত মানে রিসেট করুন"
+"Resize by the nudge amount" = "নাজ পরিমাণ অনুযায়ী আকার পরিবর্তন করুন"
+"Resize frames to the device's screen (or the window without a device): their constraints and auto layout respond" = "ডিভাইসের স্ক্রিনে (বা ডিভাইস ছাড়া উইন্ডোতে) ফ্রেমের আকার পরিবর্তন করুন: তাদের সীমাবদ্ধতা এবং অটো লেআউট সাড়া দেয়"
+"Resize to fit" = "ফিট করতে আকার পরিবর্তন করুন"
+"Resizing" = "আকার পরিবর্তন করা হচ্ছে"
+"Resolve" = "সমাধান করুন"
+"Resolve change" = "পরিবর্তন সমাধান করুন"
+"Resolved" = "সমাধান করা হয়েছে"
+"Resources" = "রিসোর্সসমূহ"
+"Responsive" = "রেসপনসিভ"
+"Restart" = "পুনরায় শুরু করুন"
+"Restore" = "পুনরুদ্ধার করুন"
+"Restore main component" = "প্রধান কম্পোনেন্ট পুনরুদ্ধার করুন"
+"Restore this version" = "এই সংস্করণ পুনরুদ্ধার করুন"
+"Restored “{name}”" = "“{name}” পুনরুদ্ধার করা হয়েছে"
+"Reverse the order" = "ক্রম উল্টে দিন"
+"Reversed triangle" = "উল্টানো ত্রিভুজ"
+"Review and merge" = "পর্যালোচনা ও মার্জ করুন"
+"Ribbon" = "রিবন"
+"Right" = "ডানে"
+"Right side" = "ডান পাশ"
+"Right side width" = "ডান পাশের প্রস্থ"
+"Rotate 90°" = "৯০° ঘোরান"
+"Rotate 90° right" = "ডানে ৯০° ঘোরান"
+"Rotate to landscape" = "ল্যান্ডস্কেপে ঘোরান"
+"Rotate to portrait" = "পোর্ট্রেটে ঘোরান"
+"Rotation" = "ঘূর্ণন"
+"Rotation jitter" = "ঘূর্ণন জিটার"
+"Round" = "গোল"
+"Rounded" = "গোল করা"
+"Rounded rectangle" = "গোলাকার আয়তক্ষেত্র"
+"Row" = "সারি"
+"Row gap" = "সারির গ্যাপ"
+"Row sizes" = "সারির আকার"
+"Row span" = "সারি স্প্যান"
+"Rows" = "সারিগুলো"
+"Rows {count}" = "সারি {count}"
+"Rulers" = "রুলার"
+"Run" = "চালান"
+"Run {label}" = "চালান {label}"
+"Save files automatically" = "স্বয়ংক্রিয়ভাবে ফাইল সেভ করুন"
+"Search templates" = "টেমপ্লেট খুঁজুন"
+"See all templates" = "সব টেমপ্লেট দেখুন"
+"Select layers and they space themselves as their content changes" = "লেয়ার নির্বাচন করুন এবং তাদের কন্টেন্ট পরিবর্তিত হওয়ার সাথে সাথে তারা নিজেদের মধ্যে দূরত্ব বজায় রাখবে"
+"SHA-256: {sha}…" = "SHA-256: {sha}…"
+"Same as layer" = "লেয়ারের মতোই"
+"Saturation" = "স্যাচুরেশন"
+"Save" = "সেভ করুন"
+"Save as" = "এভাবে সেভ করুন"
+"Save as preset…" = "প্রিসেট হিসেবে সেভ করুন..."
+"Save version  {key}" = "সংস্করণ সেভ করুন {key}"
+"Saved" = "সেভ করা হয়েছে"
+"Saved {name}" = "সেভ করা হয়েছে {name}"
+"Say something" = "কিছু বলুন"
+"Scale" = "স্কেল"
+"Scatter" = "স্ক্যাটার"
+"Scoping: where pickers offer it" = "স্কোপিং: যেখানে পিকার এটি অফার করে"
+"Screen" = "স্ক্রিন"
+"Scroll behavior" = "স্ক্রোল আচরণ"
+"Scroll to" = "স্ক্রোল করে যান"
+"Scroll to layer" = "লেয়ারে স্ক্রোল করুন"
+"Scroll with parent" = "প্যারেন্টের সাথে স্ক্রোল করুন"
+"Search plugins" = "প্লাগইন খুঁজুন"
+"Search" = "অনুসন্ধান"
+"Search actions, layers and tools" = "অ্যাকশন, লেয়ার এবং টুল খুঁজুন"
+"Search assets" = "অ্যাসেট খুঁজুন"
+"Search comments" = "মন্তব্য খুঁজুন"
+"Search files and templates" = "ফাইল এবং টেমপ্লেট খুঁজুন"
+"Search results" = "অনুসন্ধানের ফলাফল"
+"Search fonts" = "ফন্ট খুঁজুন"
+"Search layers" = "লেয়ার খুঁজুন"
+"Search shortcuts" = "শর্টকাট খুঁজুন"
+"Section" = "সেকশন"
+"Section color" = "সেকশনের রঙ"
+"Sections" = "সেকশনসমূহ"
+"Select a frame and add a starting point to present it as a flow." = "একটি ফ্রেম নির্বাচন করুন এবং ফ্লো হিসেবে উপস্থাপন করতে একটি শুরুর বিন্দু যোগ করুন।"
+"Select a frame to preview it" = "প্রিভিউ করতে একটি ফ্রেম নির্বাচন করুন"
+"Select a layer to see its properties and code" = "এর প্রপার্টি এবং কোড দেখতে একটি লেয়ার নির্বাচন করুন"
+"Select all" = "সব নির্বাচন করুন"
+"Select all with same" = "একই রকম সব নির্বাচন করুন"
+"Select layer" = "লেয়ার নির্বাচন করুন"
+"Select layers to apply the style to" = "স্টাইল প্রয়োগ করার জন্য লেয়ার নির্বাচন করুন"
+"Select layers with this color" = "এই রঙের লেয়ারগুলো নির্বাচন করুন"
+"Select overlapping shapes" = "overlapping শেপগুলো নির্বাচন করুন"
+"Select points to edit their position, radius and mirroring" = "অবস্থান, ব্যাসার্ধ এবং মিররিং এডিট করতে পয়েন্ট নির্বাচন করুন"
+"Select slot" = "স্লট নির্বাচন করুন"
+"Selection colors" = "নির্বাচনের রঙ"
+"Selection" = "নির্বাচন"
+"Selection box, {w} by {h} at {x}, {y}: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "নির্বাচন বাক্স, {w} × {h}, অবস্থান {x}, {y}: অ্যারো কি দিয়ে সরানো যায়, Shift+arrows বা {cmd}+arrows দিয়ে আকার পরিবর্তন করা যায়, Enter দিয়ে নির্বাচন হয়, Escape দিয়ে বাতিল হয়"
+"Selection box: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "নির্বাচন বাক্স: অ্যারো কি দিয়ে সরানো যায়, Shift+arrows বা {cmd}+arrows দিয়ে আকার পরিবর্তন করা যায়, Enter দিয়ে নির্বাচন হয়, Escape দিয়ে বাতিল হয়"
+"Send backward" = "পেছনে পাঠান"
+"Send report" = "রিপোর্ট পাঠান"
+"Send to back" = "সবার পেছনে পাঠান"
+"Sep" = "সেপ্টেম্বর"
+"Server address (ws://host:47900/)" = "সার্ভার ঠিকানা (ws://host:47900/)"
+"Server address" = "সার্ভারের ঠিকানা"
+"Server for online sharing" = "অনলাইন শেয়ারিংয়ের সার্ভার"
+"Set as default" = "ডিফল্ট হিসেবে সেট করুন"
+"Set variable" = "ভেরিয়েবল সেট করুন"
+"Set variable mode" = "ভেরিয়েবল মোড সেট করুন"
+"Set variable {name}" = "ভেরিয়েবল সেট করুন {name}"
+"Set {name} to {value}" = "{name}-এর মান {value} সেট করুন"
+"Shadows" = "ছায়াসমূহ (Shadows)"
+"Shape" = "শেপ"
+"Shape builder" = "শেপ বিল্ডার"
+"Shape tools" = "শেপ টুলস"
+"Shapes" = "আকৃতি"
+"Share" = "শেয়ার"
+"Share this file" = "এই ফাইলটি শেয়ার করুন"
+"Share with a code" = "কোড দিয়ে শেয়ার করুন"
+"Share: live session, export" = "শেয়ার: লাইভ সেশন, এক্সপোর্ট"
+"Shared" = "শেয়ার করা হয়েছে"
+"Shared: copy its code from the file's menu" = "শেয়ার করা হয়েছে: ফাইলের মেনু থেকে এর কোড কপি করুন"
+"Sharing a file needs the desktop app; here you can join one." = "ফাইল শেয়ার করতে ডেস্কটপ অ্যাপ প্রয়োজন; এখানে আপনি একটিতে যুক্ত হতে পারবেন।"
+"Sharing on the local network (online sharing is off: no server is set in Preferences)." = "স্থানীয় নেটওয়ার্কে শেয়ার করা হচ্ছে (অনলাইন শেয়ারিং বন্ধ আছে: প্রেফারেন্সেসে কোনো সার্ভার সেট করা নেই)।"
+"Sharing on your network · {people}" = "আপনার নেটওয়ার্কে শেয়ার করা হচ্ছে · {people}"
+"Sharing online · {people}" = "অনলাইনে শেয়ার করা হচ্ছে · {people}"
+"Sharing stopped: the file stays on the server, open only to you" = "শেয়ারিং বন্ধ করা হয়েছে: ফাইলটি সার্ভারেই আছে, শুধুমাত্র আপনার জন্য খোলা"
+"Show" = "দেখান"
+"Show all templates" = "সব টেমপ্লেট দেখান"
+"Show as grid" = "গ্রিড হিসেবে দেখান"
+"Show as list" = "তালিকা হিসেবে দেখান"
+"Show autosaves" = "স্বয়ংক্রিয় সেভ দেখান"
+"Show behind transparent areas" = "স্বচ্ছ এলাকার পেছনে দেখান"
+"Show comments (Shift+C)" = "মন্তব্য দেখান (Shift+C)"
+"Show device frame" = "ডিভাইস ফ্রেম দেখান"
+"Show dimensions on objects" = "অবজেক্টে মাত্রা (dimensions) দেখান"
+"Show hotspot hints" = "হটস্পট ইঙ্গিত দেখান"
+"Show in Explorer" = "এক্সপ্লোরারে দেখান"
+"Show in Finder" = "ফাইন্ডারে দেখান"
+"Show in folder" = "ফোল্ডারে দেখান"
+"Show only this on the canvas" = "ক্যানভাসে শুধুমাত্র এটি দেখান"
+"Show open" = "খোলা দেখান"
+"Show section contents" = "সেকশনের কন্টেন্ট দেখান"
+"Show this layer" = "এই লেয়ারটি দেখান"
+"Show usage" = "ব্যবহার দেখান"
+"Show/Hide" = "দেখান/লুকান"
+"Show/Hide UI" = "UI দেখান/লুকান"
+"Side by side" = "পাশাপাশি"
+"Sidebar" = "সাইডবার"
+"Simplify stroke" = "স্ট্রোক সরল করুন"
+"Size" = "আকার"
+"Size jitter" = "আকার জিটার"
+"Skip ink" = "কালি বাদ দিন"
+"Slashed zero" = "স্ল্যাশড জিরো"
+"Slice" = "স্লাইস"
+"Slices" = "স্লাইসসমূহ"
+"Slide in" = "স্লাইড ইন"
+"Slide out" = "স্লাইড আউট"
+"Slot" = "স্লট"
+"Slot content" = "স্লট কন্টেন্ট"
+"Small capitals" = "ছোট বড় হাতের অক্ষর"
+"Small caps" = "স্মল ক্যাপস"
+"Smart animate" = "স্মার্ট অ্যানিমেট"
+"Snap to pixel grid" = "পিক্সেল গ্রিডে স্ন্যাপ করুন"
+"Social and slides" = "সোশ্যাল ও স্লাইড"
+"Social media" = "সোশ্যাল মিডিয়া"
+"Social post sizes" = "সোশ্যাল পোস্টের আকার"
+"Soft light" = "সফট লাইট"
+"Solid" = "সলিড"
+"Some variants have the same property values: give each one a unique combination" = "কিছু ভ্যারিয়েন্টের প্রপার্টি মান একই: প্রতিটিকে একটি অনন্য কম্বিনেশন দিন"
+"Sort" = "সাজান"
+"Sort by" = "যেভাবে সাজাবেন"
+"Sort by date" = "তারিখ অনুযায়ী সাজান"
+"Sort by page" = "পেজ অনুযায়ী সাজান"
+"Sort by {column}" = "{column} অনুযায়ী সাজান"
+"Space around" = "চারপাশে স্পেস"
+"Space between" = "মাঝখানে স্পেস"
+"Space drag" = "স্পেস ড্র্যাগ"
+"Space evenly" = "সমানভাবে স্পেস"
+"Space+drag" = "Space+ড্র্যাগ"
+"Spacing" = "ব্যবধান"
+"Spam, stolen work, abuse…" = "স্প্যাম, চুরি করা কাজ, অপব্যবহার..."
+"Speech bubble" = "কথার বুদবুদ"
+"Splay" = "সপ্লে"
+"Spotlight me" = "আমাকে স্পটলাইট করুন"
+"Spread" = "স্প্রেড"
+"Square" = "বর্গক্ষেত্র"
+"Stamp" = "স্ট্যাম্প"
+"Stamps" = "স্ট্যাম্পগুলি"
+"Standard" = "স্ট্যান্ডার্ড"
+"Standard ligatures" = "স্ট্যান্ডার্ড লিগেচার"
+"Star" = "তারকা"
+"Stars" = "তারকাসমূহ"
+"Start" = "শুরু"
+"Start ascending from / stop descending at" = "এখান থেকে ওঠা শুরু করুন / এখানে নামা বন্ধ করুন"
+"Start from a blank canvas" = "খালি ক্যানভাস থেকে শুরু করুন"
+"Start from a template" = "টেমপ্লেট থেকে শুরু করুন"
+"Start on path" = "পাথ থেকে শুরু করুন"
+"Start point" = "শুরুর বিন্দু"
+"Start sharing" = "শেয়ার করা শুরু করুন"
+"Start sharing with the Share button, then pass on the code it gives" = "শেয়ার বোতাম দিয়ে শেয়ার করা শুরু করুন, তারপর এটি যে কোড দেয় তা দিন"
+"Starting to share…" = "শেয়ার করা শুরু হচ্ছে..."
+"Status" = "স্ট্যাটাস"
+"Sticky" = "স্টিকি"
+"Sticky note" = "স্টিকি নোট"
+"Sticky note colors" = "স্টিকি নোটের রং"
+"Sticky notes, shapes and connectors" = "স্টিকি নোট, আকৃতি ও সংযোগকারী"
+"Stop" = "থামুন"
+"Stop following {name}" = "{name}-কে অনুসরণ করা বন্ধ করুন"
+"Stop session" = "সেশন বন্ধ করুন"
+"Stop sharing" = "শেয়ার করা বন্ধ করুন"
+"Stop spotlighting" = "স্পটলাইটিং বন্ধ করুন"
+"Stop {n}  {hex}" = "স্টপ {n}  {hex}"
+"Straight" = "সোজা"
+"Stretch" = "টেনে বড় করা (Stretch)"
+"Strikethrough" = "স্ট্রাইকথ্রু"
+"String" = "স্ট্রিং"
+"Stroke" = "স্ট্রোক"
+"Stroke style" = "স্ট্রোক স্টাইল"
+"Stroke weight" = "স্ট্রোকের ওজন"
+"Strokes" = "স্ট্রোকসমূহ"
+"Style" = "স্টাইল"
+"Styles" = "স্টাইলসমূহ"
+"Stylistic set 1" = "স্টাইলিস্টিক সেট ১"
+"Stylistic set 2" = "স্টাইলিস্টিক সেট ২"
+"Stylistic set 3" = "স্টাইলিস্টিক সেট ৩"
+"Stylistic set 4" = "স্টাইলিস্টিক সেট ৪"
+"Stylistic set 5" = "স্টাইলিস্টিক সেট ৫"
+"Subtract" = "বিয়োগ করুন"
+"Subtracts" = "বিয়োগ করে"
+"Suffix" = "সাফিক্স"
+"Suspend snapping while dragging" = "ড্র্যাগ করার সময় স্ন্যাপিং স্থগিত রাখুন"
+"Swap instance" = "ইনস্ট্যান্স সোয়াপ করুন"
+"Swap library: use another library's assets of the same names" = "লাইব্রেরি সোয়াপ করুন: একই নামের অন্য লাইব্রেরির অ্যাসেট ব্যবহার করুন"
+"Swap orientation" = "ভিত্তিক বিন্যাস (orientation) সোয়াপ করুন"
+"Swap overlay" = "ওভারলে সোয়াপ করুন"
+"Swap to {name}" = "{name}-এ সোয়াপ করুন"
+"Swap width and height" = "প্রস্থ ও উচ্চতা সোয়াপ করুন"
+"Swapped instance" = "সোয়াপ করা ইনস্ট্যান্স"
+"Swapped {n} assets" = { one = "{n}টি অ্যাসেট সোয়াপ করা হয়েছে", other = "{n}টি অ্যাসেট সোয়াপ করা হয়েছে" }
+"Swapped {n} assets; {missed} had no match and still use the old library" = { one = "{n}টি অ্যাসেট সোয়াপ করা হয়েছে; {missed}-এর কোনো মিল পাওয়া যায়নি এবং এখনো পুরোনো লাইব্রেরি ব্যবহার করছে", other = "{n}টি অ্যাসেট সোয়াপ করা হয়েছে; {missed}-এর কোনো মিল পাওয়া যায়নি এবং এখনো পুরোনো লাইব্রেরি ব্যবহার করছে" }
+"Sweep" = "সুইপ"
+"System" = "সিস্টেম"
+"Tab / Shift+Tab" = "Tab / Shift+Tab"
+"Table" = "টেবিল"
+"Tablet" = "ট্যাবলেট"
+"Tabular numbers" = "টাবুলার সংখ্যা"
+"Take the values from the first selected layer" = "প্রথমে নির্বাচিত লেয়ার থেকে মানগুলো নিন"
+"Taper" = "ট্যাপার"
+"Taper both ends" = "উভয় প্রান্ত ট্যাপার করুন"
+"Tell the server's operator what is wrong with it" = "সার্ভারের অপারেটরকে জানান এতে কী সমস্যা রয়েছে"
+"Temperature" = "তাপমাত্রা"
+"Template" = "টেমপ্লেট"
+"Templates" = "টেমপ্লেটসমূহ"
+"Terms" = "শর্তাবলী"
+"Text" = "টেক্সট"
+"Text align" = "টেক্সট সারিবদ্ধকরণ"
+"Text content" = "টেক্সট কন্টেন্ট"
+"Text size" = "লেখার আকার"
+"Text style" = "টেক্সট স্টাইল"
+"Text styles" = "টেক্সট স্টাইলসমূহ"
+"Texts" = "টেক্সটসমূহ"
+"Texture" = "টেক্সচার"
+"The canvas previews colors in sRGB; exported PNG, JPG and WebP files are tagged Display P3." = "ক্যানভাস sRGB-তে রঙ প্রিভিউ করে; এক্সপোর্ট করা PNG, JPG এবং WebP ফাইলে Display P3 ট্যাগ করা থাকে।"
+"The destination document is unavailable. Nothing was imported." = "গন্তব্য ডকুমেন্ট অনুপলব্ধ। কিছু ইম্পোর্ট করা হয়নি।"
+"The destination document was closed. Nothing was imported." = "গন্তব্য ডকুমেন্ট বন্ধ করা হয়েছিল। কিছু ইম্পোর্ট করা হয়নি।"
+"The destination page was removed. Nothing was imported." = "গন্তব্য পেজ সরানো হয়েছে। কিছু ইম্পোর্ট করা হয়নি।"
+"The file is deleted from the server: nobody can open or join it from there again, and this can't be undone. Copies that are open stay with whoever has them." = "ফাইলটি সার্ভার থেকে ডিলিট করা হয়েছে: কেউ আর সেখান থেকে এটি খুলতে বা যুক্ত হতে পারবে না, এবং এটি আর ফেরানো যাবে না। যে কপিগুলো খোলা আছে তা যার যার কাছে আছে তার সাথেই থাকবে।"
+"The file now holds another library" = "ফাইলটিতে এখন অন্য একটি লাইব্রেরি রয়েছে"
+"The file now holds another library (\"{name}\")" = "ফাইলটিতে এখন অন্য একটি লাইব্রেরি রয়েছে (\"{name}\")"
+"The files you shared or published online from this computer. They stay on their server until you remove them." = "এই কম্পিউটার থেকে আপনি যে ফাইলগুলো অনলাইনে শেয়ার বা প্রকাশ করেছেন। আপনি না সরানো পর্যন্ত সেগুলো তাদের সার্ভারেই থাকে।"
+"The link carries the session's secret: share it only with people you invite." = "লিংকটি সেশনের গোপনীয়তা বহন করে: শুধুমাত্র আপনার আমন্ত্রিত লোকদের সাথেই এটি শেয়ার করুন।"
+"The name in your online files and on the server. The document inside keeps its own name." = "আপনার অনলাইন ফাইল এবং সার্ভারে থাকা নাম। ভেতরের ডকুমেন্টটি তার নিজস্ব নাম বজায় রাখে।"
+"The selection uses several text styles: click to apply one" = "নির্বাচনে একাধিক টেক্সট স্টাইল ব্যবহার করা হয়েছে: একটি প্রয়োগ করতে ক্লিক করুন"
+"The server deletes this file if nobody opens it before {date}." = "{date}-এর আগে কেউ না খুললে সার্ভার এই ফাইলটি ডিলিট করে দেবে।"
+"The whole file" = "সম্পূর্ণ ফাইল"
+"Theme" = "থিম"
+"There's no destination for that action" = "সেই অ্যাকশনের জন্য কোনো গন্তব্য নেই"
+"Thickness" = "পুরুত্ব"
+"This branch can't be reviewed: {e}" = "এই ব্রাঞ্চটি পর্যালোচনা করা যাচ্ছে না: {e}"
+"This branch was merged or archived." = "এই ব্রাঞ্চটি মার্জ বা আর্কাইভ করা হয়েছে।"
+"This computer only" = "শুধুমাত্র এই কম্পিউটার"
+"This computer remembers the owner token, so the file can be managed from the home screen's Online list. Copy it to manage the file from somewhere else: it is a password for this file and won't be shown again." = "এই কম্পিউটার ওনার টোকেন মনে রাখে, তাই হোম স্ক্রিনের অনলাইন তালিকা থেকে ফাইলটি পরিচালনা করা যেতে পারে। অন্য কোথাও থেকে ফাইলটি পরিচালনা করতে এটি কপি করুন: এটি এই ফাইলের জন্য একটি পাসওয়ার্ড এবং আর কখনো দেখানো হবে না।"
+"This condition is edited as an expression" = "এই শর্তটি এক্সপ্রেশন হিসেবে এডিট করা হয়েছে"
+"This file" = "এই ফাইল"
+"This file has unsaved changes" = "এই ফাইলে সেভ করা হয়নি এমন পরিবর্তন রয়েছে"
+"This file uses fonts that aren't installed on this computer. Their text is drawn in a fallback font until you install them." = "এই ফাইলে এমন ফন্ট ব্যবহার করা হয়েছে যা এই কম্পিউটারে ইনস্টল করা নেই। আপনি ইনস্টল না করা পর্যন্ত সেগুলোর টেক্সট একটি ফলব্যাক ফন্টে দেখানো হয়।"
+"This file is on {server}, open only to you. Share it to let others in with a new code." = "এই ফাইলটি {server}-এ আছে, শুধুমাত্র আপনার জন্য খোলা। নতুন কোড দিয়ে অন্যদের প্রবেশ করাতে এটি শেয়ার করুন।"
+"This frame is new on the branch." = "এই ফ্রেমটি ব্রাঞ্চে নতুন।"
+"This frame isn't on the branch." = "এই ফ্রেমটি ব্রাঞ্চে নেই।"
+"This server is open to the public: no key needed." = "এই সার্ভারটি সবার জন্য উন্মুক্ত: কোনো কী প্রয়োজন নেই।"
+"This server needs its key: add ?key=… to the address (`figcraft-server key` prints it on the server's machine)." = "এই সার্ভারের কী প্রয়োজন: ঠিকানায় ?key=… যোগ করুন (`figcraft-server key` এটি সার্ভারের মেশিনে প্রিন্ট করে)।"
+"This server takes files only with its key: see Advanced." = "এই সার্ভার শুধুমাত্র এর কী সহ ফাইল নেয়: উন্নত (Advanced) দেখুন।"
+"Thumbs up" = "বুড়ো আঙুল উঁচু"
+"Tidy up" = "পরিপাটি করুন"
+"Tile" = "টাইল"
+"Tile type" = "টাইল টাইপ"
+"Tint" = "টিন্ট"
+"Title" = "শিরোনাম"
+"Title case" = "টাইটেল কেস"
+"To share this library with your team, publish the file to a server (Share ▸ Publish to server…), then publish the library there." = "আপনার টিমের সাথে এই লাইব্রেরি শেয়ার করতে, ফাইলটি একটি সার্ভারে প্রকাশ করুন (Share ▸ Publish to server…), এরপর সেখানে লাইব্রেরি প্রকাশ করুন।"
+"Toggle" = "টগল"
+"Toggle light/dark theme" = "লাইট/ডার্ক থিম টগল করুন"
+"Toggle visibility" = "দৃশ্যমানতা টগল করুন"
+"Tools" = "টুলস"
+"Top" = "উপরে"
+"Top & bottom" = "উপরে ও নিচে"
+"Top left radius" = "ওপরের বাম ব্যাসার্ধ"
+"Top right radius" = "ওপরের ডান ব্যাসার্ধ"
+"Transform" = "ট্রান্সফর্ম"
+"Triangle" = "ত্রিভুজ"
+"Triangle arrow" = "ত্রিভুজ তীর"
+"Trigger" = "ট্রিগার"
+"True" = "সত্য (True)"
+"Truncate text" = "টেক্সট ট্রাঙ্কেট করুন"
+"Truncate with an ellipsis" = "উপবৃত্ত (ellipsis) দিয়ে ট্রাঙ্কেট করুন"
+"Try again" = "আবার চেষ্টা করুন"
+"Try another search or filter." = "অন্য অনুসন্ধান বা ফিল্টার ব্যবহার করে দেখুন।"
+"Try another search, or browse templates." = "অন্য অনুসন্ধান ব্যবহার করুন, অথবা টেমপ্লেট ব্রাউজ করুন।"
+"Try another word, or look at every kind." = "অন্য শব্দ ব্যবহার করুন, অথবা সব ধরণ দেখুন।"
+"Turn a layer into a component, reuse it, and change every copy at once" = "একটি লেয়ারকে কম্পোনেন্টে রূপান্তর করুন, এটি পুনরায় ব্যবহার করুন এবং এক সাথে সব কপি পরিবর্তন করুন"
+"Two digits" = "দুটি অঙ্ক"
+"Type" = "ধরন (Type)"
+"Type settings" = "টাইপ সেটিংস"
+"Type the join code you were given, or paste an invite link." = "আপনাকে দেওয়া যুক্ত হওয়ার কোডটি টাইপ করুন, অথবা একটি আমন্ত্রণ লিংক পেস্ট করুন।"
+"Typography" = "টাইপোগ্রাফি"
+"Underline" = "আন্ডারলাইন"
+"Undo takes back only your own changes; what others changed since stays." = "আনডু কেবল আপনার নিজস্ব পরিবর্তনগুলো ফিরিয়ে নেয়; এর মধ্যে অন্যরা যা পরিবর্তন করেছে তা থেকেই যায়।"
+"Ungroup" = "আনগ্রুপ"
+"Uniform" = "ইউনিফর্ম"
+"Union" = "ইউনিয়ন"
+"Unions" = "ইউনিয়নসমূহ"
+"Unknown — treated as sRGB" = "অজানা — sRGB হিসেবে গণ্য করা হয়েছে"
+"Unread" = "অপঠিত"
+"Unresolve" = "অমীমাংসিত করুন"
+"Unsaved changes" = "সংরক্ষিত হয়নি এমন পরিবর্তন"
+"Unsaved changes in {names}. Save them before closing?" = "{names}-এ সংরক্ষিত হয়নি এমন পরিবর্তন রয়েছে। বন্ধ করার আগে সেগুলো সংরক্ষণ করবেন?"
+"Unsaved changes: save first ({save}), or close the tab with {alt}-click to discard" = "সংরক্ষিত হয়নি এমন পরিবর্তন: প্রথমে সেভ করুন ({save}), অথবা বাতিল করতে {alt}-ক্লিক করে ট্যাব বন্ধ করুন"
+"Unsaved changes: save first, or close again with {key} to discard" = "সংরক্ষিত হয়নি এমন পরিবর্তন: প্রথমে সেভ করুন, অথবা বাতিল করতে {key} দিয়ে আবার বন্ধ করুন"
+"Up" = "উপরে"
+"Update plugin" = "প্লাগইন আপডেট করুন"
+"Update" = "আপডেট"
+"Update from main" = "প্রধান (main) থেকে আপডেট করুন"
+"Update from selection" = "নির্বাচন থেকে আপডেট করুন"
+"Updated {components} and {styles}" = "{components} এবং {styles} আপডেট করা হয়েছে"
+"Updated {name}" = "{name} আপডেট করা হয়েছে"
+"Updating the graphics driver often helps. To use OpenGL only, start FigCraft from a Command Prompt with:" = "গ্রাফিক্স ড্রাইভার আপডেট করা প্রায়ই সহায়ক হয়। শুধুমাত্র OpenGL ব্যবহার করতে, কমান্ড প্রম্পট থেকে FigCraft শুরু করুন:"
+"Updating the graphics driver often helps. WGPU_BACKEND (vulkan, gl, metal) names another graphics API to try." = "গ্রাফিক্স ড্রাইভার আপডেট করা প্রায়ই সহায়ক হয়। WGPU_BACKEND (vulkan, gl, metal) চেষ্টা করার জন্য অন্য একটি গ্রাফিক্স API এর নাম বলে।"
+"Uploads this file to a FigCraft server and keeps this tab in sync with it. You get a link to edit and a link to view." = "এই ফাইলটি একটি FigCraft সার্ভারে আপলোড করে এবং এই ট্যাবটিকে এর সাথে সিঙ্ক করে রাখে। আপনি এডিট করার জন্য একটি লিংক এবং দেখার জন্য একটি লিংক পান।"
+"Uppercase" = "বড় হাতের অক্ষর"
+"Use a fixed value" = "একটি নির্দিষ্ট মান ব্যবহার করুন"
+"Use an expression, e.g. count + 1" = "একটি এক্সপ্রেশন ব্যবহার করুন, যেমন count + 1"
+"Use as mask" = "মাস্ক হিসেবে ব্যবহার করুন"
+"Use auto layout" = "অটো লেআউট ব্যবহার করুন"
+"Use number keys for opacity" = "অস্বচ্ছতার জন্য নম্বর কি ব্যবহার করুন"
+"Use the .figcraft or .fig extension." = ".figcraft বা .fig এক্সটেনশন ব্যবহার করুন।"
+"Use the layer's fill" = "লেয়ারের ফিল ব্যবহার করুন"
+"Used in {files} · {instances}" = "{files} · {instances}-এ ব্যবহৃত"
+"Username" = "ব্যবহারকারী নাম"
+"Value" = "মান"
+"Uses variables: each layer shows them in its own mode" = "ভেরিয়েবল ব্যবহার করে: প্রতিটি লেয়ার তাদের নিজস্ব মোডে সেগুলো দেখায়"
+"Variable" = "ভেরিয়েবল"
+"Variable collections" = "ভেরিয়েবল সংগ্রহসমূহ"
+"Variable modes" = "ভেরিয়েবল মোড"
+"Variable width" = "পরিবর্তনশীল প্রস্থ (Variable width)"
+"Variables" = "ভেরিয়েবলসমূহ"
+"Variables JSON…" = "ভেরিয়েবল JSON..."
+"Variables store reusable values (colours, numbers, strings, booleans) with modes such as Light and Dark." = "ভেরিয়েবলগুলো লাইট এবং ডার্কের মতো মোডের সাথে পুনঃব্যবহারযোগ্য মান (রঙ, নম্বর, স্ট্রিং, বুলিয়ান) সংরক্ষণ করে।"
+"Variant" = "ভ্যারিয়েন্ট"
+"Vector" = "ভেক্টর"
+"Vectors" = "ভেক্টরসমূহ"
+"Version" = "সংস্করণ"
+"Version history" = "সংস্করণ ইতিহাস"
+"Version {version}" = "সংস্করণ {version}"
+"Version {v} · {components} · {styles} · {variables}" = "সংস্করণ {v} · {components} · {styles} · {variables}"
+"Vertical" = "উল্লম্ব"
+"Vertical align" = "উল্লম্ব সারিবদ্ধকরণ"
+"Vertical hex" = "উল্লম্ব হেক্স"
+"Vertical padding" = "উল্লম্ব প্যাডিং"
+"Vertical spacing" = "উল্লম্ব ব্যবধান"
+"Vertical trim" = "উল্লম্ব ট্রিম"
+"View" = "ভিউ"
+"View link" = "ভিউ লিংক"
+"View link copied" = "ভিউ লিংক কপি করা হয়েছে"
+"View only" = "শুধুমাত্র দেখার উপযোগী"
+"View only: you see every change as it happens but can't edit. Leave to keep a copy you can edit." = "শুধুমাত্র দেখার উপযোগী: আপনি প্রতিটি পরিবর্তন ঘটার সাথে সাথে দেখতে পান কিন্তু এডিট করতে পারেন না। আপনি এডিট করতে পারেন এমন একটি কপি রাখতে ত্যাগ করুন।"
+"Viewing “{name}”" = "“{name}” দেখা হচ্ছে"
+"Violet" = "বেগুনি"
+"Visibility" = "দৃশ্যমানতা"
+"Visible" = "দৃশ্যমান"
+"Vivid" = "ভিভিড"
+"WGPU_BACKEND is set and names the graphics API to use; unsetting it lets FigCraft choose." = "WGPU_BACKEND সেট করা আছে এবং ব্যবহারের জন্য গ্রাফিক্স API-এর নাম দেয়; এটি আনসেট করলে FigCraft কে বেছে নিতে দেয়।"
+"Warm" = "উষ্ণ"
+"Watch" = "ওয়াচ"
+"Wavy" = "ঢেউ খেলানো"
+"Web" = "ওয়েব"
+"Websites" = "ওয়েবসাইটসমূহ"
+"WebSocket URL" = "WebSocket URL"
+"WebSocket URL copied" = "WebSocket URL কপি করা হয়েছে"
+"Wedge" = "ওয়েজ"
+"Weight" = "ওজন"
+"What you try here changes this preview and the code below, not the file" = "আপনি এখানে যা চেষ্টা করেন তা ফাইলটিকে নয়, কেবল এই প্রিভিউ এবং নিচের কোডটিকে পরিবর্তন করে"
+"What changed since it was marked ready for dev" = "এটি ডেভের জন্য প্রস্তুত হিসেবে চিহ্নিত করার পর থেকে কী পরিবর্তিত হয়েছে"
+"What is wrong with this file? The server's operator gets your report." = "এই ফাইলে কী সমস্যা রয়েছে? সার্ভারের অপারেটর আপনার রিপোর্ট পান।"
+"What it's for" = "এটি কি জন্য"
+"What this changed from isn't known: it changed before FigCraft kept a copy of ready-for-dev frames. Resolve the change (or mark it ready again) to compare from now on." = "এটি কি থেকে পরিবর্তিত হয়েছে তা অজানা: FigCraft ডেভের জন্য প্রস্তুত ফ্রেমের একটি কপি রাখার আগেই এটি পরিবর্তিত হয়েছে। এখন থেকে তুলনা করতে পরিবর্তনটি সমাধান করুন (বা এটি আবার প্রস্তুত হিসেবে চিহ্নিত করুন)।"
+"While hovering" = "হোভার করার সময়"
+"While pressing" = "চেপে ধরে রাখার সময়"
+"White" = "সাদা"
+"Who runs it, its terms and how long it keeps files" = "এটি কে পরিচালনা করে, এর শর্তাবলী এবং এটি কতদিন ফাইল রাখে"
+"Why it changed" = "কেন এটি পরিবর্তিত হয়েছে"
+"Widget" = "উইজেট"
+"Widgets" = "উইজেটসমূহ"
+"Width" = "প্রস্থ"
+"Width point" = "প্রস্থ বিন্দু"
+"Width profile" = "প্রস্থ প্রোফাইল"
+"Wireframe kit" = "ওয়্যারফ্রেম কিট"
+"With the layers' export settings" = "লেয়ারের এক্সপোর্ট সেটিংস সহ"
+"Wrap" = "র‍্যাপ"
+"Wrap in new section" = "নতুন সেকশনে র‍্যাপ করুন"
+"Yellow" = "হলুদ"
+"Yesterday" = "গতকাল"
+"You" = "আপনি"
+"You'll get the shared file as a new tab and edit it together." = "আপনি একটি নতুন ট্যাব হিসেবে শেয়ার করা ফাইলটি পাবেন এবং একসাথে এডিট করবেন।"
+"You're spotlighting: everyone follows your view" = "আপনি স্পটলাইট করছেন: সবাই আপনার ভিউ অনুসরণ করছে"
+"Your copy of the file stays open" = "ফাইলের আপনার কপিটি খোলা থাকে"
+"Your copy stays open; the file stays on the server" = "আপনার কপি খোলা থাকে; ফাইলটি সার্ভারেই থাকে"
+"Your name" = "আপনার নাম"
+"Your name in comments" = "মন্তব্যে আপনার নাম"
+"Your system asks for reduced motion: animations stay off." = "আপনার সিস্টেম কম মোশনের অনুরোধ জানায়: অ্যানিমেশন বন্ধ থাকে।"
+"Z" = "Z"
+"Z to A" = "Z থেকে A"
+"Zoom" = "জুম"
+"Zoom around the pointer" = "পয়েন্টারের চারপাশে জুম করুন"
+"Zoom device to fill window" = "উইন্ডো পূর্ণ করতে ডিভাইস জুম করুন"
+"Zoom in" = "জুম ইন"
+"Zoom out" = "জুম আউট"
+"Zoom to 100%" = "১০০%-এ জুম করুন"
+"Zoom to 200%" = "২০০%-এ জুম করুন"
+"Zoom to 50%" = "৫০%-এ জুম করুন"
+"Zoom to fit" = "ফিট করতে জুম করুন"
+"Zoom to selection" = "নির্বাচনে জুম করুন"
+"Zoom tool: click to zoom in, drag an area" = "জুম টুল: জুম ইন করতে ক্লিক করুন, একটি এলাকা ড্র্যাগ করুন"
+"Zoom tool: zoom out" = "জুম টুল: জুম আউট"
+"and {n} more" = { one = "এবং আরও {n}টি", other = "এবং আরও {n}টি" }
+"bleed marks" = "ব্লিড মার্ক"
+"by {author}" = "{author} দ্বারা"
+"call any command its access allows" = "এর অ্যাক্সেস অনুমতি দেয় এমন যেকোনো কমান্ড কল করুন"
+"call only: {commands}" = "শুধুমাত্র কল করুন: {commands}"
+"can edit the document" = "ডকুমেন্ট এডিট করতে পারেন"
+"conditional prototype actions nested too deeply were skipped" = "শর্তসাপেক্ষ প্রোটোটাইপ অ্যাকশনগুলো খুব গভীরভাবে নেস্ট করার কারণে বাদ দেওয়া হয়েছে"
+"conditional prototype actions with conditions that can't be evaluated were skipped" = "মূল্যায়ন করা যায় না এমন শর্তযুক্ত প্রোটোটাইপ অ্যাকশনগুলো বাদ দেওয়া হয়েছে"
+"connector label background was skipped: style data is missing" = "কানেক্টর লেবেলের ব্যাকগ্রাউন্ড বাদ দেওয়া হয়েছে: স্টাইল ডেটা অনুপস্থিত"
+"connector label was skipped: background bounds are invalid" = "কানেক্টর লেবেল বাদ দেওয়া হয়েছে: ব্যাকগ্রাউন্ড বাউন্ড অবৈধ"
+"connector label was skipped: background transform is invalid" = "কানেক্টর লেবেল বাদ দেওয়া হয়েছে: ব্যাকগ্রাউন্ড ট্রান্সফর্ম অবৈধ"
+"connector label was skipped: composed text transform is invalid" = "কানেক্টর লেবেল বাদ দেওয়া হয়েছে: কম্পোজড টেক্সট ট্রান্সফর্ম অবৈধ"
+"connector label was skipped: derived background bounds are missing" = "কানেক্টর লেবেল বাদ দেওয়া হয়েছে: ডিরাইভড ব্যাকগ্রাউন্ড বাউন্ড অনুপস্থিত"
+"connector label was skipped: derived text bounds are missing" = "কানেক্টর লেবেল বাদ দেওয়া হয়েছে: ডিরাইভড টেক্সট বাউন্ড অনুপস্থিত"
+"connector label was skipped: text bounds are invalid" = "কানেক্টর লেবেল বাদ দেওয়া হয়েছে: টেক্সট বাউন্ড অবৈধ"
+"connector label was skipped: text style data is missing" = "কানেক্টর লেবেল বাদ দেওয়া হয়েছে: টেক্সট স্টাইল ডেটা অনুপস্থিত"
+"connector label was skipped: text transform is invalid" = "কানেক্টর লেবেল বাদ দেওয়া হয়েছে: টেক্সট ট্রান্সফর্ম অবৈধ"
+"connector labels were skipped" = "কানেক্টর লেবেলগুলো বাদ দেওয়া হয়েছে"
+"connector layers import as static frame/vector snapshots with labels when present; live endpoint bindings are not retained" = "কানেক্টর লেবেল উপস্থিত থাকলে স্ট্যাটিক ফ্রেম/ভেক্টর স্ন্যাপশট হিসেবে ইম্পোর্ট হয়; লাইভ এন্ডপয়েন্ট বাইন্ডিং রাখা হয় না"
+"connector snapshot vector data is missing; connector was left empty" = "কানেক্টর স্ন্যাপশট ভেক্টর ডেটা অনুপস্থিত; কানেক্টর খালি রাখা হয়েছে"
+"connectors whose ends can't be placed are empty" = "যে কানেক্টরের প্রান্তগুলো রাখা যায় না সেগুলো খালি"
+"crop marks" = "ক্রপ মার্ক"
+"damaged vector geometry was skipped" = "ক্ষতিগ্রস্ত ভেক্টর জিওমেট্রি বাদ দেওয়া হয়েছে"
+"damaged vector networks import as outlines" = "ক্ষতিগ্রস্ত ভেক্টর নেটওয়ার্ক আউটলাইন হিসেবে ইম্পোর্ট হয়"
+"development: {path}" = "ডেভেলপমেন্ট: {path}"
+"document children other than pages were skipped" = "পেজ ছাড়া ডকুমেন্টের অন্যান্য চিলড্রেন বাদ দেওয়া হয়েছে"
+"duplicate grid track sizing entries use equal tracks" = "ডুপ্লিকেট গ্রিড ট্র্যাক সাইজিং এন্ট্রিগুলো সমান ট্র্যাক ব্যবহার করে"
+"e.g. count + 1" = "যেমন count + 1"
+"e.g. count >= 3 and not done" = "যেমন count >= 3 and not done"
+"elbowed and curved connectors without a saved path import as straight lines" = "সংরক্ষিত পাথ ছাড়া এলবো এবং কার্ভড কানেক্টর সরল রেখা হিসেবে ইম্পোর্ট হয়"
+"entries without a node type were skipped" = "নোটের ধরন ছাড়া এন্ট্রিগুলো বাদ দেওয়া হয়েছে"
+"figcraft:// links from a browser, chat or email open this app and join the session." = "ব্রাউজার, চ্যাট বা ইমেল থেকে figcraft:// লিংকগুলো এই অ্যাপ খুলে সেশনে যুক্ত হয়।"
+"filled areas of a vector with their own fill use the layer's fill" = "ভেক্টরের নিজস্ব ফিলযুক্ত পূর্ণ এলাকাগুলো লেয়ারের ফিল ব্যবহার করে"
+"from {server}" = "{server} থেকে"
+"gamepad triggers without exactly one known controller button were skipped" = "সঠিকভাবে একটি পরিচিত কন্ট্রোলার বোতাম ছাড়া গেমপ্যাড ট্রিগার বাদ দেওয়া হয়েছে"
+"grid track list exceeds 1000 entries; the tracks use the default equal sizing" = "গ্রিড ট্র্যাক তালিকা ১০০০ এন্ট্রি অতিক্রম করেছে; ট্র্যাকগুলো ডিফল্ট সমান সাইজিং ব্যবহার করে"
+"grid track sizing is unsupported or malformed; affected tracks use equal sizing" = "গ্রিড ট্র্যাক সাইজিং অসমর্থিত বা ত্রুটিপূর্ণ; প্রভাবিত ট্র্যাকগুলো সমান সাইজিং ব্যবহার করে"
+"grid track sizing list exceeds 1000 entries; the tracks use the default equal sizing" = "গ্রিড ট্র্যাক সাইজিং তালিকা ১০০০ এন্ট্রি অতিক্রম করেছে; ট্র্যাকগুলো ডিফল্ট সমান সাইজিং ব্যবহার করে"
+"hidden" = "লুকানো"
+"iOS" = "iOS"
+"image filters are ambiguous because both filter containers are present; filter conversion was skipped" = "ছবির ফিল্টারগুলো দ্ব্যর্থক কারণ উভয় ফিল্টার কন্টেইনার উপস্থিত রয়েছে; ফিল্টার রূপান্তর বাদ দেওয়া হয়েছে"
+"image filters use FigCraft's approximate renderer" = "ছবির ফিল্টারগুলো FigCraft-এর অনুমানমূলক রেন্ডারার ব্যবহার করে"
+"instance swap properties whose default component isn't in the file were skipped" = "ইনস্ট্যান্স সোয়াপ প্রপার্টি যার ডিফল্ট কম্পোনেন্ট ফাইলে নেই তা বাদ দেওয়া হয়েছে"
+"instances inside their own main component were imported as frames" = "নিজের প্রধান কম্পোনেন্টের ভেতরের ইনস্ট্যান্সগুলো ফ্রেম হিসেবে ইম্পোর্ট করা হয়েছে"
+"instances of components that aren't in the file show no layers" = "ফাইলে নেই এমন কম্পোনেন্টের ইনস্ট্যান্স কোনো লেয়ার দেখায় না"
+"instances of components that aren't in the file were imported as frames" = "ফাইলে নেই এমন কম্পোনেন্টের ইনস্ট্যান্স ফ্রেম হিসেবে ইম্পোর্ট করা হয়েছে"
+"instances that would nest a component inside itself were imported as frames" = "যে ইনস্ট্যান্সগুলো কোনো কম্পোনেন্টকে নিজের ভেতরে নেস্ট করত সেগুলোকে ফ্রেম হিসেবে ইম্পোর্ট করা হয়েছে"
+"instances without a main component were imported as empty frames" = "প্রধান কম্পোনেন্ট ছাড়া ইনস্ট্যান্সগুলো খালি ফ্রেম হিসেবে ইম্পোর্ট করা হয়েছে"
+"invalid internal .fig text path data was ignored" = "অবৈধ অভ্যন্তরীণ .fig টেক্সট পাথ ডেটা উপেক্ষা করা হয়েছে"
+"invalid or oversized vector networks import as outlines" = "অবৈধ বা অতিরিক্ত বড় ভেক্টর নেটওয়ার্ক আউটলাইন হিসেবে ইম্পোর্ট হয়"
+"invalid or oversized vector path data was skipped" = "অবৈধ বা অতিরিক্ত বড় ভেক্টর পাথ ডেটা বাদ দেওয়া হয়েছে"
+"just now" = "এইমাত্র"
+"key triggers without a supported key were skipped" = "সমর্থিত কি ছাড়া কি ট্রিগার বাদ দেওয়া হয়েছে"
+"key up triggers import as key presses" = "কি আপ ট্রিগার কি প্রেস হিসেবে ইম্পোর্ট হয়"
+"layers without a position were placed at their parent's origin" = "অবস্থান ছাড়া লেয়ারগুলো তাদের প্যারেন্টের মূল অবস্থানে রাখা হয়েছে"
+"layers without a type were skipped" = "ধরন ছাড়া লেয়ারগুলো বাদ দেওয়া হয়েছে"
+"legacy image filter container is unsupported; filter conversion was skipped" = "লিগ্যাসি ইমেজ ফিল্টার কন্টেইনার অসমর্থিত; ফিল্টার রূপান্তর বাদ দেওয়া হয়েছে"
+"locked" = "লক করা"
+"malformed image filters container was skipped" = "ত্রুটিপূর্ণ ইমেজ ফিল্টার কন্টেইনার বাদ দেওয়া হয়েছে"
+"malformed image paintFilter container was skipped" = "ত্রুটিপূর্ণ ইমেজ paintFilter কন্টেইনার বাদ দেওয়া হয়েছে"
+"malformed slot content assignment was skipped" = "ত্রুটিপূর্ণ স্লট কন্টেন্ট অ্যাসাইনমেন্ট বাদ দেওয়া হয়েছে"
+"no bleed" = "কোনো ব্লিড নেই"
+"nobody else here yet" = "এখানে আর কেউ নেই"
+"non-default slot settings are not represented and were skipped" = "অ-ডিফল্ট স্লট সেটিংস উপস্থাপিত হয়নি এবং বাদ দেওয়া হয়েছে"
+"now" = "এখন"
+"only in a text style or variable" = "শুধুমাত্র টেক্সট স্টাইল বা ভেরিয়েবলে"
+"or" = "অথবা"
+"point stroke joins were preserved; dashed or variable-width strokes render with the layer join" = "পয়েন্ট স্ট্রোক জয়েন্ট সংরক্ষিত হয়েছে; ড্যাশড বা পরিবর্তনশীল প্রস্থের স্ট্রোক লেয়ার জয়েন্ট দিয়ে রেন্ডার হয়"
+"preferred slot component keys cannot be resolved to file nodes and were skipped" = "পছন্দসই স্লট কম্পোনেন্ট কি ফাইল নোডে সমাধান করা যায়নি এবং বাদ দেওয়া হয়েছে"
+"prototype actions of unknown types were skipped" = "অজানা ধরনের প্রোটোটাইপ অ্যাকশন বাদ দেওয়া হয়েছে"
+"prototype actions without a destination in the file were skipped" = "ফাইলে গন্তব্য নেই এমন প্রোটোটাইপ অ্যাকশন বাদ দেওয়া হয়েছে"
+"prototype expressions on variables that aren't in the variables JSON were skipped" = "ভেরিয়েবল JSON-এ নেই এমন ভেরিয়েবলের উপর প্রোটোটাইপ এক্সপ্রেশন বাদ দেওয়া হয়েছে"
+"prototype expressions with unsupported functions were skipped" = "অসমর্থিত ফাংশনযুক্ত প্রোটোটাইপ এক্সপ্রেশন বাদ দেওয়া হয়েছে"
+"prototype interactions without supported actions were skipped" = "সমর্থিত অ্যাকশন ছাড়া প্রোটোটাইপ ইন্টারঅ্যাকশন বাদ দেওয়া হয়েছে"
+"prototype navigations of unknown types were skipped" = "অজানা ধরনের প্রোটোটাইপ নেভিগেশন বাদ দেওয়া হয়েছে"
+"prototype transitions of unknown types play instantly" = "অজানা ধরনের প্রোটোটাইপ ট্রানজিশন তাৎক্ষণিকভাবে চলে"
+"prototype triggers of unknown types were skipped" = "অজানা ধরনের প্রোটোটাইপ ট্রিগার বাদ দেওয়া হয়েছে"
+"put a widget on the canvas" = "ক্যানভাসে একটি উইজেট রাখুন"
+"read and edit the document" = "ডকুমেন্ট পড়ুন এবং এডিট করুন"
+"read the document" = "ডকুমেন্ট পড়ুন"
+"reads the document" = "ডকুমেন্ট পড়ে"
+"set-variable actions on variables that aren't in the variables JSON were skipped" = "ভেরিয়েবল JSON-এ নেই এমন ভেরিয়েবলের উপর set-variable অ্যাকশন বাদ দেওয়া হয়েছে"
+"set-variable actions with values that can't be evaluated were skipped" = "মূল্যায়ন করা যায় না এমন মানযুক্ত set-variable অ্যাকশন বাদ দেওয়া হয়েছে"
+"set-variable actions with values that don't fit the variable were skipped" = "ভেরিয়েবলের সাথে মেলে না এমন মানযুক্ত set-variable অ্যাকশন বাদ দেওয়া হয়েছে"
+"set-variable actions without a value were skipped" = "মান ছাড়া set-variable অ্যাকশন বাদ দেওয়া হয়েছে"
+"set-variable-mode actions on collections or modes that aren't in the variables JSON were skipped" = "ভেরিয়েবল JSON-এ নেই এমন সংগ্রহ বা মোডের উপর set-variable-mode অ্যাকশন বাদ দেওয়া হয়েছে"
+"slot content assignment target is missing or is not slot content" = "স্লট কন্টেন্ট অ্যাসাইনমেন্ট লক্ষ্য অনুপস্থিত অথবা স্লট কন্টেন্ট নয়"
+"slot content assignment uses the empty GUID sentinel and was skipped" = "স্লট কন্টেন্ট অ্যাসাইনমেন্ট খালি GUID সেন্টিমেল ব্যবহার করে এবং বাদ দেওয়া হয়েছে"
+"slot layers without a matching slot property were imported as frames" = "মিল রয়েছে এমন স্লট প্রপার্টি ছাড়া স্লট লেয়ারগুলো ফ্রেম হিসেবে ইম্পোর্ট করা হয়েছে"
+"some vector points refer to point settings missing from the file; they use the layer's joins and plain corners" = "কিছু ভেক্টর পয়েন্ট ফাইল থেকে অনুপস্থিত পয়েন্ট সেটিংস উল্লেখ করে; সেগুলো লেয়ারের জয়েন্ট এবং সাধারণ কোণা ব্যবহার করে"
+"some vector segments refer to style settings missing from the file; they use the layer's stroke" = "কিছু ভেক্টর সেগমেন্ট ফাইল থেকে অনুপস্থিত স্টাইল সেটিংস উল্লেখ করে; সেগুলো লেয়ারের স্ট্রোক ব্যবহার করে"
+"stale or invalid grid track sizing entries were ignored" = "পুরোনো বা অবৈধ গ্রিড ট্র্যাক সাইজিং এন্ট্রি উপেক্ষা করা হয়েছে"
+"stars and polygons without point counts or geometry use the default point count" = "পয়েন্ট সংখ্যা বা জিওমেট্রি ছাড়া তারকা এবং বহুভুজ ডিফল্ট পয়েন্ট সংখ্যা ব্যবহার করে"
+"style settings of some vector segments aren't supported; those segments use the layer's stroke" = "কিছু ভেক্টর সেগমেন্টের স্টাইল সেটিংস সমর্থিত নয়; সেই সেগমেন্টগুলো লেয়ারের স্ট্রোক ব্যবহার করে"
+"text path underline or strikethrough decoration is not rendered" = "টেক্সট পাথ আন্ডারলাইন বা স্ট্রাইকথ্রু সজ্জা রেন্ডার হয় না"
+"text style overrides refer to missing table entries" = "টেক্সট স্টাইল ওভাররাইড অনুপস্থিত টেবিল এন্ট্রি নির্দেশ করে"
+"the file has no pages" = "ফাইলে কোনো পেজ নেই"
+"the plugin" = "প্লাগইনটি"
+"the variables JSON has no `variableCollections` (expected the local variables response) and was ignored" = "ভেরিয়েবল JSON-এ কোনো `variableCollections` নেই (স্থানীয় ভেরিয়েবল প্রতিক্রিয়া প্রত্যাশিত ছিল) এবং উপেক্ষা করা হয়েছে"
+"this session only" = "শুধুমাত্র এই সেশন"
+"unknown component property types were skipped" = "অজানা কম্পোনেন্ট প্রপার্টি ধরন বাদ দেওয়া হয়েছে"
+"variable aliases to variables that aren't in the variables JSON (or of another type) were skipped" = "ভেরিয়েবল JSON-এ নেই (বা অন্য ধরনের) এমন ভেরিয়েবলের ভেরিয়েবল অ্যালিয়াস বাদ দেওয়া হয়েছে"
+"variable bindings to properties the layer doesn't have were skipped" = "লেয়ারের নেই এমন প্রপার্টির ভেরিয়েবল বাইন্ডিং বাদ দেওয়া হয়েছে"
+"variable bindings to variables that aren't in the variables JSON (library variables) were skipped" = "ভেরিয়েবল JSON-এ নেই (লাইব্রেরি ভেরিয়েবল) এমন ভেরিয়েবলের ভেরিয়েবল বাইন্ডিং বাদ দেওয়া হয়েছে"
+"variable bindings were skipped: the file JSON has no variable definitions (pass the local variables JSON as `variables`, or embed its `meta` next to the file JSON)" = "ভেরিয়েবল বাইন্ডিং বাদ দেওয়া হয়েছে: ফাইল JSON-এ কোনো ভেরিয়েবল সংজ্ঞা নেই (স্থানীয় ভেরিয়েবল JSON কে `variables` হিসেবে পাস করুন, অথবা ফাইল JSON এর পাশে এর `meta` এমবেড করুন)"
+"variable bindings whose variable type doesn't fit the property were skipped" = "প্রপার্টির সাথে মানানসই নয় এমন ভেরিয়েবল ধরনের ভেরিয়েবল বাইন্ডিং বাদ দেওয়া হয়েছে"
+"variable collections without modes were skipped" = "মোড ছাড়া ভেরিয়েবল সংগ্রহ বাদ দেওয়া হয়েছে"
+"variable mode lookups in prototype expressions that aren't a variable and one of its modes were skipped" = "প্রোটোটাইপ এক্সপ্রেশনের ভেরিয়েবল মোড লুকআপ যা কোনো ভেরিয়েবল এবং এর একটি মোড নয় তা বাদ দেওয়া হয়েছে"
+"variable modes of collections that aren't in the file were skipped" = "ফাইলে নেই এমন সংগ্রহের ভেরিয়েবল মোড বাদ দেওয়া হয়েছে"
+"variable modes of collections that aren't in the variables JSON were skipped" = "ভেরিয়েবল JSON-এ নেই এমন সংগ্রহের ভেরিয়েবল মোড বাদ দেওয়া হয়েছে"
+"variable values that don't match their type (or composed colours) were skipped" = "তাদের ধরনের সাথে মেলে না এমন ভেরিয়েবল মান বাদ দেওয়া হয়েছে"
+"variables of unknown types were skipped" = "অজানা ধরনের ভেরিয়েবল বাদ দেওয়া হয়েছে"
+"variables whose collection isn't in the variables JSON were skipped" = "সংগ্রহ ভেরিয়েবল JSON-এ নেই এমন ভেরিয়েবল বাদ দেওয়া হয়েছে"
+"variables without readable values were skipped" = "পড়ার উপযোগী মান নেই এমন ভেরিয়েবল বাদ দেওয়া হয়েছে"
+"vector points with unknown stroke joins use the layer join" = "অজানা স্ট্রোক জয়েন্টযুক্ত ভেক্টর পয়েন্ট লেয়ার জয়েন্ট ব্যবহার করে"
+"vectors without geometry are empty" = "জিওমেট্রি ছাড়া ভেক্টর খালি"
+"vectors without geometry are empty (export the file JSON with geometry=paths)" = "জিওমেট্রি ছাড়া ভেক্টর খালি (geometry=paths সহ ফাইল JSON এক্সপোর্ট করুন)"
+"very long text was cut to 1,048,576 characters" = "খুব দীর্ঘ টেক্সট কেটে ১,০৪৮,৫৭৬ অক্ষরে ছোট করা হয়েছে"
+"very long vector paths were skipped" = "খুব দীর্ঘ ভেক্টর পাথ বাদ দেওয়া হয়েছে"
+"video actions are not supported and were skipped" = "ভিডিও অ্যাকশন সমর্থিত নয় এবং বাদ দেওয়া হয়েছে"
+"video triggers are not supported and were skipped" = "ভিডিও ট্রিগার সমর্থিত নয় এবং বাদ দেওয়া হয়েছে"
+"yesterday" = "গতকাল"
+"{instances} in {files}" = "{files}-এ {instances}টি ইনস্ট্যান্স"
+"{language}: draft translation, waiting for a native speaker's review." = "{language}: ড্রাফট অনুবাদ, স্থানীয় ভাষাভাষীর পর্যালোচনার অপেক্ষায়।"
+"{length} bleed" = "{length} ব্লিড"
+"{month} {day}, {year}" = "{day} {month}, {year}"
+"{name} cleared from the list" = "তালিকা থেকে {name} মুছে ফেলা হয়েছে"
+"{name} is forgotten on this computer; the file stays on {server}" = "এই কম্পিউটার থেকে {name} মুছে ফেলা হয়েছে; ফাইলটি {server}-এ রয়ে গেছে"
+"{name} is on the server." = "{name} সার্ভারে আছে।"
+"{name} is spotlighting" = "{name} স্পটলাইট করছে"
+"{name}\nClick to apply to the selection" = "{name}\nনির্বাচনে প্রয়োগ করতে ক্লিক করুন"
+"{name}\nDrag onto the canvas, or click to place in the middle of the view.\nHold Alt (Option) while dropping onto an instance to swap it." = "{name}\nক্যানভাসে ড্র্যাগ করুন, অথবা ভিউর মাঝখানে রাখতে ক্লিক করুন।\nকোনো ইনস্ট্যান্সে ড্রপ করার সময় সোয়াপ করতে Alt (Option) চেপে ধরে রাখুন।"
+"{name} (from {library})" = "{name} ({library} থেকে)"
+"{name} (you)" = "{name} (আপনি)"
+"{name} ({layers} layers)" = "{name} ({layers}টি লেয়ার)"
+"{name} ({tag}): {min} – {max}, default {default}. Double-click the slider to go back to the style's value; Escape while dragging cancels." = "{name} ({tag}): {min} – {max}, ডিফল্ট {default}. স্টাইলের মানে ফিরে যেতে স্লাইডারে ডাবল-ক্লিক করুন; ড্র্যাগ করার সময় Escape টিপলে বাতিল হবে।"
+"{name} from {path}" = "{path} থেকে {name}"
+"{name} was removed from the server" = "সার্ভার থেকে {name} সরানো হয়েছে"
+"{name} · deleted on main" = "{name} · প্রধান (main)-এ ডিলিট করা হয়েছে"
+"{name} · deleted on the branch" = "{name} · ব্রাঞ্চে ডিলিট করা হয়েছে"
+"{name} · not published" = "{name} · প্রকাশিত নয়"
+"{name} · on a server" = "{name} · একটি সার্ভারে"
+"{name} · published version {v}" = "{name} · প্রকাশিত সংস্করণ {v}"
+"{name} · version {v} on the server" = "{name} · সার্ভারে সংস্করণ {v}"
+"{name}, in a live session" = "{name}, লাইভ সেশনে"
+"{name}, online, open only to you" = "{name}, অনলাইনে, শুধুমাত্র আপনার জন্য খোলা"
+"{name}, {kind}, {w} by {h}, selected" = "{name}, {kind}, {w} × {h}, নির্বাচিত"
+"{n} added" = { one = "{n}টি যোগ করা হয়েছে", other = "{n}টি যোগ করা হয়েছে" }
+"{n} autosave versions" = { one = "{n}টি স্বয়ংক্রিয় সেভ সংস্করণ", other = "{n}টি স্বয়ংক্রিয় সেভ সংস্করণ" }
+"{n} changed" = { one = "{n}টি পরিবর্তিত হয়েছে", other = "{n}টি পরিবর্তিত হয়েছে" }
+"{n} columns" = { one = "{n}টি কলাম", other = "{n}টি কলাম" }
+"{n} components" = { one = "{n}টি কম্পোনেন্ট", other = "{n}টি কম্পোনেন্ট" }
+"{n} components and styles have newer versions" = { one = "{n}টি কম্পোনেন্ট বা স্টাইলের নতুন সংস্করণ রয়েছে", other = "{n}টি কম্পোনেন্ট এবং স্টাইলের নতুন সংস্করণ রয়েছে" }
+"{n} conflicts to resolve" = { one = "{n}টি দ্বন্দ্ব সমাধান করতে হবে", other = "{n}টি দ্বন্দ্ব সমাধান করতে হবে" }
+"{n} days ago" = { one = "{n} দিন আগে", other = "{n} দিন আগে" }
+"{n} files" = { one = "{n}টি ফাইল", other = "{n}টি ফাইল" }
+"{n} hours ago" = { one = "{n} ঘণ্টা আগে", other = "{n} ঘণ্টা আগে" }
+"{n} instances" = { one = "{n}টি ইনস্ট্যান্স", other = "{n}টি ইনস্ট্যান্স" }
+"{n} layers" = { one = "{n}টি লেয়ার", other = "{n}টি লেয়ার" }
+"{n} layers as one file" = { one = "{n}টি লেয়ার একটি ফাইল হিসেবে", other = "{n}টি লেয়ার একটি ফাইল হিসেবে" }
+"{n} layers selected" = { one = "{n}টি লেয়ার নির্বাচিত", other = "{n}টি লেয়ার নির্বাচিত" }
+"{n} layers · {parts}" = { one = "{n}টি লেয়ার · {parts}", other = "{n}টি লেয়ার · {parts}" }
+"{n} matches" = { one = "{n}টি মিল", other = "{n}টি মিল" }
+"{n} minutes ago" = { one = "{n} মিনিট আগে", other = "{n} মিনিট আগে" }
+"{n} months ago" = { one = "{n} মাস আগে", other = "{n} মাস আগে" }
+"{n} more notes omitted from this report" = { one = "এই রিপোর্ট থেকে আরও {n}টি নোট বাদ দেওয়া হয়েছে", other = "এই রিপোর্ট থেকে আরও {n}টি নোট বাদ দেওয়া হয়েছে" }
+"{n} of {total}" = "{total}-এর মধ্যে {n}"
+"{n} people joined" = { one = "{n} জন যুক্ত হয়েছেন", other = "{n} জন যুক্ত হয়েছেন" }
+"{n} preferred components" = { one = "{n}টি পছন্দের কম্পোনেন্ট", other = "{n}টি পছন্দের কম্পোনেন্ট" }
+"{n} ready" = { one = "{n}টি প্রস্তুত", other = "{n}টি প্রস্তুত" }
+"{n} removed" = { one = "{n}টি সরানো হয়েছে", other = "{n}টি সরানো হয়েছে" }
+"{n} replies" = { one = "{n}টি উত্তর", other = "{n}টি উত্তর" }
+"{n} rows" = { one = "{n}টি সারি", other = "{n}টি সারি" }
+"{n} styles" = { one = "{n}টি স্টাইল", other = "{n}টি স্টাইল" }
+"{n} text layers" = { one = "{n}টি টেক্সট লেয়ার", other = "{n}টি টেক্সট লেয়ার" }
+"{n} variables" = { one = "{n}টি ভেরিয়েবল", other = "{n}টি ভেরিয়েবল" }
+"{n} weeks ago" = { one = "{n} সপ্তাহ আগে", other = "{n} সপ্তাহ আগে" }
+"{n} years ago" = { one = "{n} বছর আগে", other = "{n} বছর আগে" }
+"{n}d" = "{n}d"
+"{n}h" = "{n}h"
+"{n}m" = "{n}m"
+"{n}w" = "{n}w"
+"{page}, nothing selected" = "{page}, কিছু নির্বাচিত নেই"
+"{profile} (current)" = "{profile} (বর্তমান)"
+"{property} is its value; {property ? \"a\" : \"b\"} picks a string. Other {…} stays as written." = "{property} হলো এর মান; {property ? \"a\" : \"b\"} একটি স্ট্রিং বাছে। অন্যান্য {…} যেমন লেখা আছে তেমনই থাকে।"
+"{server} can't say what became of your files (it is older than this app)." = "{server} বলতে পারছে না আপনার ফাইলের কী হয়েছে (এটি এই অ্যাপের চেয়ে পুরনো)।"
+"{server} · No longer on the server" = "{server} · আর সার্ভারে নেই"
+"{server} · {shared} · Opened {date}" = "{server} · {shared} · খোলা হয়েছে {date}"
+"{tool}  hold {key}" = "{tool}  চেপে ধরে রাখুন {key}"
+"{value} isn't a colour" = "{value} কোনো রঙ নয়"
+"{when} · edited" = "{when} · এডিট করা হয়েছে"
+"← ↑ → ↓" = "← ↑ → ↓"
+"← → ↑ ↓" = "← → ↑ ↓"
+"←" = "←"
+"→, Space or N" = "→, স্পেস বা N"
+"↵" = "↵"
+"⇥ / ⇧⇥" = "⇥ / ⇧⇥"
+"⌘ arrows" = "⌘ অ্যারো"
+"⌘ click" = "⌘ ক্লিক"
+"⌘ scroll" = "⌘ স্ক্রল"
+"⌥ drag" = "⌥ ড্র্যাগ"
+
+
+[commands]
+"board.connector" = "সংযোগকারী"
+"board.ink" = "মার্কারের টান"
+"board.label" = "সংযোগকারীর লেবেল"
+"board.nextSticky" = "পরের স্টিকি নোট"
+"board.setColor" = "বোর্ডের রং"
+"board.setStyle" = "বোর্ডের শৈলী"
+"board.shape" = "লেখাসহ আকৃতি"
+"board.stamp" = "স্ট্যাম্প"
+"board.sticky" = "স্টিকি নোট"
+"file.newBoard" = "নতুন বোর্ড"
+"tool.connector" = "সংযোগকারী"
+"tool.eraser" = "ইরেজার"
+"tool.highlighter" = "হাইলাইটার"
+"tool.marker" = "মার্কার"
+"tool.shape" = "আকৃতি"
+"tool.stamp" = "স্ট্যাম্প"
+"tool.sticky" = "স্টিকি নোট"
diff --git a/crates/ui-egui/locales/cs.toml b/crates/ui-egui/locales/cs.toml
index 268ff5275..e7a2dec12 100644
--- a/crates/ui-egui/locales/cs.toml
+++ b/crates/ui-egui/locales/cs.toml
@@ -13,6 +13,7 @@ status = "draft — needs native review"
 "1…9, 0" = "1…9, 0"
 "@{login}: {prs} PRs, {commits} commits, +{added} / −{deleted} lines (Δ {delta}), +{bin_added} / −{bin_deleted} binary assets, {first} – {last}" = "@{login}: PR: {prs}, commity: {commits}, +{added} / −{deleted} řádků (Δ {delta}), +{bin_added} / −{bin_deleted} binárních souborů, {first} – {last}"
 "A collection of this file with these modes and variables: override their values per mode and add variables of its own" = "Kolekce tohoto souboru s těmito režimy a proměnnými: přepište jejich hodnoty pro jednotlivé režimy a přidejte vlastní proměnné"
+"A .figcraft file with this name already exists. Choose its full name to confirm replacement." = "Soubor .figcraft s tímto názvem už existuje. Nahrazení potvrdíte výběrem jeho úplného názvu."
 "A layer on its own aligns to its frame: select more layers, or one in a frame" = "Samostatná vrstva se zarovná ke svému rámci: vyberte více vrstev nebo jednu v rámci"
 "A responsive product page: hero, features, figures, a quote and a footer" = "Responzivní produktová stránka: úvodní blok, funkce, čísla, citace a zápatí"
 "A spring plays until it settles: its mass, stiffness and damping set how long" = "Pružina se pohybuje až do ustálení: délku určuje její hmotnost, tuhost a tlumení"
@@ -119,6 +120,7 @@ status = "draft — needs native review"
 "Archived" = "Archivováno"
 "Arrange" = "Uspořádat"
 "Arrow" = "Šipka"
+"Arrow at the end" = "Šipka na konci"
 "As typed" = "Podle zadání"
 "Asking the server…" = "Dotazování serveru…"
 "Assets" = "Zdroje"
@@ -192,7 +194,9 @@ status = "draft — needs native review"
 "C or ⇧C" = "C nebo ⇧C"
 "CMYK colour" = "Barva CMYK"
 "Can view" = "Může prohlížet"
+"Check" = "Fajfka"
 "Checking the server…" = "Kontrola serveru…"
+"Chevron" = "Lomená šipka"
 "Clear from this list" = "Vymazat z tohoto seznamu"
 "Code or invite link" = "Kód nebo odkaz s pozvánkou"
 "Color profile: {name}" = "Barevný profil: {name}"
@@ -239,7 +243,6 @@ status = "draft — needs native review"
 "Close tab" = "Zavřít kartu"
 "Close version history" = "Zavřít historii verzí"
 "Close when clicking outside" = "Zavřít při kliknutí mimo"
-"Close without saving" = "Zavřít bez uložení"
 "Code" = "Kód"
 "Code syntax" = "Syntaxe kódu"
 "Collapse" = "Sbalit"
@@ -266,6 +269,7 @@ status = "draft — needs native review"
 "Commits" = "Commity"
 "Company" = "Společnost"
 "Compare changes" = "Porovnat změny"
+"Compatibility notes" = "Poznámky ke kompatibilitě"
 "Completed" = "Dokončeno"
 "Component" = "Komponenta"
 "Component name" = "Název komponenty"
@@ -280,6 +284,7 @@ status = "draft — needs native review"
 "Connected" = "Připojeno"
 "Connected to code: {from}" = "Propojeno s kódem: {from}"
 "Connection lost, reconnecting (attempt {attempt})…" = "Spojení ztraceno, opětovné připojování (pokus {attempt})…"
+"Connector" = "Spojnice"
 "Constrain proportions" = "Zachovat poměr stran"
 "Constraints" = "Omezení"
 "Content" = "Obsah"
@@ -308,6 +313,7 @@ status = "draft — needs native review"
 "Corner radius" = "Poloměr rohu"
 "Corner smoothing" = "Vyhlazení rohů"
 "Couldn't reach {server}: showing what this computer remembers." = "Server {server} není dostupný: zobrazuje se stav uložený v tomto počítači."
+"Couldn't read {name}." = "Soubor {name} se nepodařilo přečíst."
 "Count" = "Počet"
 "Create" = "Vytvořit"
 "Create a variable collection first" = "Nejprve vytvořte kolekci proměnných"
@@ -331,6 +337,7 @@ status = "draft — needs native review"
 "Current version" = "Aktuální verze"
 "Cursor chat" = "Chat u kurzoru"
 "Custom" = "Vlastní"
+"Custom size" = "Vlastní velikost"
 "Cut" = "Vyjmout"
 "Dark" = "Tmavý"
 "Darken" = "Ztmavit"
@@ -364,6 +371,7 @@ status = "draft — needs native review"
 "Description" = "Popis"
 "Description (optional)" = "Popis (nepovinný)"
 "Design" = "Návrh"
+"Design panel" = "Panel návrhu"
 "Design system starter" = "Základ design systému"
 "Desktop" = "Počítač"
 "Destination" = "Cíl"
@@ -391,6 +399,7 @@ status = "draft — needs native review"
 "Distribute horizontal spacing" = "Rozmístit vodorovné rozestupy"
 "Distribute vertical spacing" = "Rozmístit svislé rozestupy"
 "Divider" = "Oddělovač"
+"Don't Save" = "Neukládat"
 "Don't truncate" = "Nezkracovat"
 "Done" = "Hotovo"
 "Done editing" = "Dokončit úpravy"
@@ -423,6 +432,7 @@ status = "draft — needs native review"
 "Effect settings" = "Nastavení efektu"
 "Effect styles" = "Styly efektů"
 "Effects" = "Efekty"
+"Elbow" = "Lomená"
 "Ellipse" = "Elipsa"
 "Ellipses" = "Elipsy"
 "Else" = "Jinak"
@@ -472,6 +482,7 @@ status = "draft — needs native review"
 "False" = "Nepravda"
 "Feb" = "února"
 "Fetching from the server…" = "Stahování ze serveru…"
+"FigCraft doesn't support every feature of these files yet. The notes list what was left out or changed in the imported copy; the original file is unchanged." = "FigCraft zatím nepodporuje všechny funkce těchto souborů. Poznámky uvádějí, co bylo v importované kopii vynecháno nebo změněno; původní soubor zůstává beze změny."
 "File" = "Soubor"
 "File name" = "Název souboru"
 "File not found" = "Soubor nenalezen"
@@ -557,6 +568,7 @@ status = "draft — needs native review"
 "Hanging list" = "Předsazený seznam"
 "Hanging punctuation" = "Předsazená interpunkce"
 "Hard light" = "Tvrdé světlo"
+"Heart" = "Srdce"
 "Height" = "Výška"
 "Help" = "Nápověda"
 "Help and resources" = "Nápověda a zdroje"
@@ -569,6 +581,7 @@ status = "draft — needs native review"
 "Hide these tips (Getting started in the Help menu shows them again)" = "Skrýt tyto tipy (znovu je zobrazíte volbou Začínáme v nabídce Nápověda)"
 "Hide when publishing" = "Skrýt při publikování"
 "Highlight layers on hover" = "Zvýraznit vrstvy pod ukazatelem"
+"Highlighter" = "Zvýrazňovač"
 "Highlights" = "Světla"
 "Hold Alt" = "Podržte Alt"
 "Hold Alt+Z" = "Podržte Alt+Z"
@@ -595,11 +608,14 @@ status = "draft — needs native review"
 "If {condition}" = "Pokud {condition}"
 "Ignore auto layout (absolute position)" = "Ignorovat automatické rozvržení (absolutní poloha)"
 "Image" = "Obrázek"
+"Images" = "Obrázky"
 "Import" = "Import"
 "Import path" = "Cesta importu"
 "Import plugin from manifest" = "Importovat plugin z manifestu"
 "Import plugin from manifest…" = "Importovat plugin z manifestu…"
+"Import report" = "Zpráva o importu"
 "Import variables" = "Importovat proměnné"
+"Imported document" = "Importovaný dokument"
 "Imported {name}" = "Importováno: {name}"
 "Imported {n} new variables, updated {updated}" = { one = "Importována {n} nová proměnná, aktualizováno: {updated}", few = "Importovány {n} nové proměnné, aktualizováno: {updated}", other = "Importováno {n} nových proměnných, aktualizováno: {updated}" }
 "Import…" = "Importovat…"
@@ -627,11 +643,13 @@ status = "draft — needs native review"
 "Instance swap (no other component)" = "Výměna instance (žádná jiná komponenta)"
 "Instances" = "Instance"
 "Instant" = "Okamžitě"
+"Intensity" = "Intenzita"
 "Interaction" = "Interakce"
 "Interactions" = "Interakce"
 "Interface design and prototyping. A free, open-source, clean-room design tool written from scratch in Rust, part of the ArtCraft Crafting Apps." = "Návrh rozhraní a prototypování. Svobodný nástroj s otevřeným zdrojovým kódem, napsaný od základu v jazyce Rust nezávisle na kódu jiných produktů. Součást sady ArtCraft Crafting Apps."
 "Intersect" = "Průnik"
 "Intersects" = "Průniky"
+"Invalid color" = "Neplatná barva"
 "Invite link" = "Odkaz s pozvánkou"
 "Invite link copied" = "Odkaz s pozvánkou zkopírován"
 "It asks permission to:" = "Žádá o oprávnění:"
@@ -729,6 +747,7 @@ status = "draft — needs native review"
 "Mark as resolved" = "Označit jako vyřešené"
 "Mark as unread" = "Označit jako nepřečtené"
 "Mark as unresolved" = "Označit jako nevyřešené"
+"Marker" = "Fix"
 "Mask" = "Maska"
 "Mass · Stiffness · Damping" = "Hmotnost · Tuhost · Tlumení"
 "Match (empty: the whole name)" = "Hledaný text (prázdné: celý název)"
@@ -787,8 +806,10 @@ status = "draft — needs native review"
 "Named instance" = "Pojmenovaná instance"
 "Navigate to" = "Přejít na"
 "Nested instance" = "Vnořená instance"
+"New board" = "Nová tabule"
 "New design file" = "Nový soubor návrhu"
 "Newest first" = "Od nejnovějších"
+"Next frame" = "Další rámec"
 "Next or previous control in the focused region" = "Další nebo předchozí ovládací prvek v zaměřené oblasti"
 "Next ready for dev" = "Další připravené pro vývoj"
 "Next size option" = "Další možnost velikosti"
@@ -798,12 +819,15 @@ status = "draft — needs native review"
 "No branches. A branch is a copy of the file to try changes in, then review and merge." = "Žádné větve. Větev je kopie souboru pro vyzkoušení změn, které pak zkontrolujete a sloučíte."
 "No category" = "Bez kategorie"
 "No changes" = "Žádné změny"
+"No color styles" = "Žádné barevné styly"
 "No colour variables fit here." = "Žádné vhodné barevné proměnné."
 "No colour variables yet. Create them in Local variables." = "Zatím žádné barevné proměnné. Vytvořte je v Místních proměnných."
 "No comments yet" = "Zatím žádné komentáře"
+"No compatibility warnings reported" = "Nebyla hlášena žádná upozornění na kompatibilitu"
 "No components yet. Select layers and press {keys}." = "Zatím žádné komponenty. Vyberte vrstvy a stiskněte {keys}."
 "No conflicts." = "Žádné konflikty."
 "No contributor data was built into this copy." = "Toto sestavení neobsahuje údaje o přispěvatelích."
+"No device" = "Bez zařízení"
 "No fonts match" = "Žádná odpovídající písma"
 "No join code here (the server is older than join codes, or this address can't be put in one): share the link instead." = "Kód pro připojení není dostupný (server kódy nepodporuje nebo tuto adresu nelze do kódu vložit): sdílejte odkaz."
 "No layer changes to show." = "Žádné změny vrstev k zobrazení."
@@ -884,6 +908,7 @@ status = "draft — needs native review"
 "Open branch" = "Otevřít větev"
 "Open file" = "Otevřít soubor"
 "Open files" = "Otevřít soubory"
+"Open presentations" = "Otevřené prezentace"
 "Open in focus view" = "Otevřít v zaměřeném pohledu"
 "Open in new window" = "Otevřít v novém okně"
 "Open invite links in FigCraft" = "Otevírat odkazy s pozvánkou v aplikaci FigCraft"
@@ -892,6 +917,7 @@ status = "draft — needs native review"
 "Open overlay" = "Otevřít překryv"
 "Open prototype preview" = "Otevřít náhled prototypu"
 "Open variables ({count})" = "Otevřít proměnné ({count})"
+"Opened as a new document" = "Otevřeno jako nový dokument"
 "Opened “{name}” in a new tab" = "Soubor „{name}“ otevřen v nové kartě"
 "Open|comments" = "Otevřené"
 "Options" = "Možnosti"
@@ -915,7 +941,11 @@ status = "draft — needs native review"
 "PDF print settings" = "Nastavení tisku PDF"
 "Padding" = "Vnitřní odsazení"
 "Page" = "Stránka"
+"Page deleted" = "Stránka smazána"
 "Pages" = "Stránky"
+"Pages added to the document" = "Stránky přidány do dokumentu"
+"Pink" = "Růžová"
+"Placed on the current page" = "Umístěno na aktuální stránku"
 "Pages: {pages}" = "Stránky: {pages}"
 "Paint bucket" = "Plechovka barvy"
 "Pan the canvas" = "Posunout plátno"
@@ -930,6 +960,7 @@ status = "draft — needs native review"
 "Paste a team library link (a view link)" = "Vložte odkaz na týmovou knihovnu (odkaz pro prohlížení)"
 "Paste here" = "Vložit sem"
 "Paste to replace" = "Vložit a nahradit"
+"Pasted design layers; {n} kinds of content were left out" = { one = "Vloženy vrstvy návrhu; vynechán {n} druh obsahu", few = "Vloženy vrstvy návrhu; vynechány {n} druhy obsahu", other = "Vloženy vrstvy návrhu; vynecháno {n} druhů obsahu" }
 "Pattern" = "Vzor"
 "Pattern alignment" = "Zarovnání vzoru"
 "Pattern scale" = "Měřítko vzoru"
@@ -956,6 +987,7 @@ status = "draft — needs native review"
 "Plugins" = "Pluginy"
 "Plus darker" = "Sčítání se ztmavením"
 "Plus lighter" = "Sčítání se zesvětlením"
+"Plus one" = "Plus jedna"
 "Point" = "Bod"
 "Points" = "Body"
 "Polygon" = "Mnohoúhelník"
@@ -983,6 +1015,7 @@ status = "draft — needs native review"
 "Preview" = "Náhled"
 "Preview this flow" = "Náhled tohoto toku"
 "Preview this frame" = "Náhled tohoto rámce"
+"Previous frame" = "Předchozí rámec"
 "Previous ready for dev" = "Předchozí připravené pro vývoj"
 "Progressive" = "Postupné"
 "Properties" = "Vlastnosti"
@@ -1003,6 +1036,7 @@ status = "draft — needs native review"
 "Push" = "Vytlačení"
 "Push changes to main component" = "Přenést změny do hlavní komponenty"
 "Put text on path" = "Umístit text na cestu"
+"Question" = "Otázka"
 "R" = "R"
 "Radial" = "Kruhový"
 "Radius" = "Poloměr"
@@ -1076,6 +1110,7 @@ status = "draft — needs native review"
 "Resize by the nudge amount" = "Změnit velikost o velikost posunu"
 "Resize frames to the device's screen (or the window without a device): their constraints and auto layout respond" = "Přizpůsobit velikost rámců obrazovce zařízení (nebo oknu bez zařízení): omezení a automatické rozvržení se přizpůsobí"
 "Resize to fit" = "Přizpůsobit velikost obsahu"
+"Resizing" = "Změna velikosti"
 "Resolve" = "Vyřešit"
 "Resolve change" = "Vyřešit změnu"
 "Resolved" = "Vyřešené"
@@ -1101,6 +1136,7 @@ status = "draft — needs native review"
 "Rotation jitter" = "Náhodná odchylka natočení"
 "Round" = "Kulatý"
 "Rounded" = "Zaoblený"
+"Rounded rectangle" = "Zaoblený obdélník"
 "Row" = "Řádek"
 "Row gap" = "Mezera mezi řádky"
 "Row sizes" = "Velikosti řádků"
@@ -1149,12 +1185,14 @@ status = "draft — needs native review"
 "Select all with same" = "Vybrat vše se stejným"
 "Select layer" = "Vybrat vrstvu"
 "Select layers to apply the style to" = "Vyberte vrstvy, na které chcete použít styl"
+"Select layers with this color" = "Vybrat vrstvy s touto barvou"
 "Select overlapping shapes" = "Vyberte překrývající se tvary"
 "Select points to edit their position, radius and mirroring" = "Vyberte body a upravte jejich polohu, poloměr a zrcadlení"
 "Select slot" = "Vybrat slot"
 "Selection" = "Výběr"
 "Selection box, {w} by {h} at {x}, {y}: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "Rámeček výběru, {w} × {h} na pozici {x}, {y}: šipky posouvají, Shift+šipky nebo {cmd}+šipky mění velikost, Enter vybere, Escape zruší"
 "Selection box: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "Rámeček výběru: šipky posouvají, Shift+šipky nebo {cmd}+šipky mění velikost, Enter vybere, Escape zruší"
+"Selection colors" = "Barvy výběru"
 "Send backward" = "Přesunout o úroveň níž"
 "Send report" = "Odeslat hlášení"
 "Send to back" = "Přesunout do pozadí"
@@ -1171,6 +1209,7 @@ status = "draft — needs native review"
 "Shape" = "Tvar"
 "Shape builder" = "Tvorba tvarů"
 "Shape tools" = "Nástroje tvarů"
+"Shapes" = "Tvary"
 "Share" = "Sdílet"
 "Share this file" = "Sdílet tento soubor"
 "Share with a code" = "Sdílet pomocí kódu"
@@ -1237,10 +1276,13 @@ status = "draft — needs native review"
 "Space+drag" = "Mezerník+tažení"
 "Spacing" = "Rozestupy"
 "Spam, stolen work, abuse…" = "Spam, odcizená práce, zneužití…"
+"Speech bubble" = "Bublina"
 "Splay" = "Rozevření"
 "Spotlight me" = "Sdílet můj pohled"
 "Spread" = "Rozšíření"
 "Square" = "Čtverec"
+"Stamp" = "Razítko"
+"Stamps" = "Razítka"
 "Standard" = "Standardní"
 "Standard ligatures" = "Standardní ligatury"
 "Star" = "Hvězda"
@@ -1256,12 +1298,16 @@ status = "draft — needs native review"
 "Starting to share…" = "Zahajování sdílení…"
 "Status" = "Stav"
 "Sticky" = "Přichycené"
+"Sticky note" = "Lepicí poznámka"
+"Sticky note colors" = "Barvy lepicích poznámek"
+"Sticky notes, shapes and connectors" = "Lepicí poznámky, tvary a spojnice"
 "Stop" = "Zastavit"
 "Stop following {name}" = "Přestat sledovat: {name}"
 "Stop session" = "Ukončit relaci"
 "Stop sharing" = "Zastavit sdílení"
 "Stop spotlighting" = "Ukončit sdílení pohledu"
 "Stop {n}  {hex}" = "Zarážka {n}  {hex}"
+"Straight" = "Rovná"
 "Stretch" = "Roztáhnout"
 "Strikethrough" = "Přeškrtnutí"
 "String" = "Textový řetězec"
@@ -1306,6 +1352,7 @@ status = "draft — needs native review"
 "Text" = "Text"
 "Text align" = "Zarovnání textu"
 "Text content" = "Textový obsah"
+"Text size" = "Velikost textu"
 "Text style" = "Textový styl"
 "Text styles" = "Textové styly"
 "Texts" = "Texty"
@@ -1336,6 +1383,7 @@ status = "draft — needs native review"
 "This server is open to the public: no key needed." = "Tento server je veřejný: klíč není potřeba."
 "This server needs its key: add ?key=… to the address (`figcraft-server key` prints it on the server's machine)." = "Tento server vyžaduje klíč: přidejte do adresy ?key=… (příkaz `figcraft-server key` ho vypíše na počítači serveru)."
 "This server takes files only with its key: see Advanced." = "Tento server přijímá soubory pouze s klíčem: viz Pokročilé."
+"Thumbs up" = "Palec nahoru"
 "Tidy up" = "Uspořádat"
 "Tile" = "Dlaždice"
 "Tile type" = "Typ dlaždic"
@@ -1352,6 +1400,7 @@ status = "draft — needs native review"
 "Top left radius" = "Poloměr levého horního rohu"
 "Top right radius" = "Poloměr pravého horního rohu"
 "Transform" = "Transformace"
+"Triangle" = "Trojúhelník"
 "Triangle arrow" = "Trojúhelníková šipka"
 "Trigger" = "Spouštěč"
 "True" = "Pravda"
@@ -1376,7 +1425,7 @@ status = "draft — needs native review"
 "Unread" = "Nepřečtené"
 "Unresolve" = "Znovu otevřít"
 "Unsaved changes" = "Neuložené změny"
-"Unsaved changes in {names}. Close the window and lose them?" = "Neuložené změny v {names}. Zavřít okno a zahodit je?"
+"Unsaved changes in {names}. Save them before closing?" = "Neuložené změny v {names}. Uložit je před zavřením?"
 "Unsaved changes: save first ({save}), or close the tab with {alt}-click to discard" = "Neuložené změny: nejprve uložte ({save}) nebo zavřete kartu kliknutím s {alt} a zahoďte je"
 "Unsaved changes: save first, or close again with {key} to discard" = "Neuložené změny: nejprve uložte nebo zavřete znovu s {key} a zahoďte je"
 "Up" = "Nahoru"
@@ -1393,6 +1442,7 @@ status = "draft — needs native review"
 "Use as mask" = "Použít jako masku"
 "Use auto layout" = "Použít automatické rozvržení"
 "Use number keys for opacity" = "Nastavovat krytí číselnými klávesami"
+"Use the .figcraft or .fig extension." = "Použijte příponu .figcraft nebo .fig."
 "Use the layer's fill" = "Použít výplň vrstvy"
 "Used in {files} · {instances}" = "Použití – {files} · {instances}"
 "Username" = "Uživatelské jméno"
@@ -1485,26 +1535,119 @@ status = "draft — needs native review"
 "call any command its access allows" = "volat libovolný příkaz povolený jeho oprávněními"
 "call only: {commands}" = "volat pouze: {commands}"
 "can edit the document" = "může upravovat dokument"
+"conditional prototype actions nested too deeply were skipped" = "podmíněné akce prototypu vnořené příliš hluboko byly přeskočeny"
+"conditional prototype actions with conditions that can't be evaluated were skipped" = "podmíněné akce prototypu s podmínkami, které nelze vyhodnotit, byly přeskočeny"
+"connector label background was skipped: style data is missing" = "pozadí popisku spojnice bylo přeskočeno: chybí data stylu"
+"connector label was skipped: background bounds are invalid" = "popisek spojnice byl přeskočen: hranice pozadí jsou neplatné"
+"connector label was skipped: background transform is invalid" = "popisek spojnice byl přeskočen: transformace pozadí je neplatná"
+"connector label was skipped: composed text transform is invalid" = "popisek spojnice byl přeskočen: složená transformace textu je neplatná"
+"connector label was skipped: derived background bounds are missing" = "popisek spojnice byl přeskočen: chybí odvozené hranice pozadí"
+"connector label was skipped: derived text bounds are missing" = "popisek spojnice byl přeskočen: chybí odvozené hranice textu"
+"connector label was skipped: text bounds are invalid" = "popisek spojnice byl přeskočen: hranice textu jsou neplatné"
+"connector label was skipped: text style data is missing" = "popisek spojnice byl přeskočen: chybí data stylu textu"
+"connector label was skipped: text transform is invalid" = "popisek spojnice byl přeskočen: transformace textu je neplatná"
+"connector labels were skipped" = "popisky spojnic byly přeskočeny"
+"connector layers import as static frame/vector snapshots with labels when present; live endpoint bindings are not retained" = "vrstvy spojnic se importují jako statické snímky rámců nebo vektorů, s popisky, pokud existují; živé vazby koncových bodů se nezachovávají"
+"connector snapshot vector data is missing; connector was left empty" = "chybí vektorová data snímku spojnice; spojnice zůstala prázdná"
+"connectors whose ends can't be placed are empty" = "spojnice, jejichž konce nelze umístit, jsou prázdné"
 "crop marks" = "ořezové značky"
+"damaged vector geometry was skipped" = "poškozená vektorová geometrie byla přeskočena"
+"damaged vector networks import as outlines" = "poškozené vektorové sítě se importují jako obrysy"
 "development: {path}" = "vývoj: {path}"
+"document children other than pages were skipped" = "potomci dokumentu, kteří nejsou stránkami, byli přeskočeni"
+"duplicate grid track sizing entries use equal tracks" = "duplicitní položky velikosti stop mřížky používají stejně velké stopy"
 "e.g. count + 1" = "např. count + 1"
 "e.g. count >= 3 and not done" = "např. count >= 3 and not done"
+"elbowed and curved connectors without a saved path import as straight lines" = "lomené a zakřivené spojnice bez uložené cesty se importují jako přímky"
+"entries without a node type were skipped" = "položky bez typu uzlu byly přeskočeny"
 "figcraft:// links from a browser, chat or email open this app and join the session." = "Odkazy figcraft:// z prohlížeče, chatu nebo e-mailu otevřou tuto aplikaci a připojí k relaci."
+"filled areas of a vector with their own fill use the layer's fill" = "vyplněné oblasti vektoru s vlastní výplní používají výplň vrstvy"
 "from {server}" = "ze serveru {server}"
+"gamepad triggers without exactly one known controller button were skipped" = "spouštěče herního ovladače bez právě jednoho známého tlačítka ovladače byly přeskočeny"
+"grid track list exceeds 1000 entries; the tracks use the default equal sizing" = "seznam stop mřížky přesahuje 1000 položek; stopy používají výchozí stejnou velikost"
+"grid track sizing is unsupported or malformed; affected tracks use equal sizing" = "velikost stop mřížky není podporována nebo je poškozená; dotčené stopy mají stejnou velikost"
+"grid track sizing list exceeds 1000 entries; the tracks use the default equal sizing" = "seznam velikostí stop mřížky přesahuje 1000 položek; stopy používají výchozí stejnou velikost"
 "hidden" = "skryté"
 "iOS" = "iOS"
+"image filters are ambiguous because both filter containers are present; filter conversion was skipped" = "filtry obrázku jsou nejednoznačné, protože jsou přítomny oba kontejnery filtrů; převod filtrů byl přeskočen"
+"image filters use FigCraft's approximate renderer" = "filtry obrázku používají přibližné vykreslování FigCraftu"
+"instance swap properties whose default component isn't in the file were skipped" = "vlastnosti výměny instance, jejichž výchozí komponenta není v souboru, byly přeskočeny"
+"instances inside their own main component were imported as frames" = "instance uvnitř vlastní hlavní komponenty byly importovány jako rámce"
+"instances of components that aren't in the file show no layers" = "instance komponent, které nejsou v souboru, nezobrazují žádné vrstvy"
+"instances of components that aren't in the file were imported as frames" = "instance komponent, které nejsou v souboru, byly importovány jako rámce"
+"instances that would nest a component inside itself were imported as frames" = "instance, které by vnořily komponentu samu do sebe, byly importovány jako rámce"
+"instances without a main component were imported as empty frames" = "instance bez hlavní komponenty byly importovány jako prázdné rámce"
+"invalid internal .fig text path data was ignored" = "neplatná interní data textu na cestě ze souboru .fig byla ignorována"
+"invalid or oversized vector networks import as outlines" = "neplatné nebo příliš velké vektorové sítě se importují jako obrysy"
+"invalid or oversized vector path data was skipped" = "neplatná nebo příliš velká data vektorových cest byla přeskočena"
 "just now" = "právě teď"
+"key triggers without a supported key were skipped" = "spouštěče kláves bez podporované klávesy byly přeskočeny"
+"key up triggers import as key presses" = "spouštěče uvolnění klávesy se importují jako stisky klávesy"
+"layers without a position were placed at their parent's origin" = "vrstvy bez pozice byly umístěny do počátku nadřazeného prvku"
+"layers without a type were skipped" = "vrstvy bez typu byly přeskočeny"
+"legacy image filter container is unsupported; filter conversion was skipped" = "starší kontejner filtrů obrázku není podporován; převod filtrů byl přeskočen"
 "locked" = "zamknuté"
+"malformed image filters container was skipped" = "poškozený kontejner filtrů obrázku byl přeskočen"
+"malformed image paintFilter container was skipped" = "poškozený kontejner paintFilter obrázku byl přeskočen"
+"malformed slot content assignment was skipped" = "poškozené přiřazení obsahu slotu bylo přeskočeno"
 "no bleed" = "bez spadávky"
 "nobody else here yet" = "zatím tu není nikdo další"
+"non-default slot settings are not represented and were skipped" = "jiná než výchozí nastavení slotů nelze znázornit a byla přeskočena"
 "now" = "nyní"
 "or" = "nebo"
+"point stroke joins were preserved; dashed or variable-width strokes render with the layer join" = "spojení tahu v bodech byla zachována; přerušované tahy a tahy s proměnnou šířkou se kreslí se spojením vrstvy"
+"preferred slot component keys cannot be resolved to file nodes and were skipped" = "klíče preferovaných komponent slotů nelze přiřadit k vrstvám souboru, byly přeskočeny"
+"prototype actions of unknown types were skipped" = "akce prototypu neznámých typů byly přeskočeny"
+"prototype actions without a destination in the file were skipped" = "akce prototypu bez cíle v souboru byly přeskočeny"
+"prototype expressions on variables that aren't in the variables JSON were skipped" = "výrazy prototypu s proměnnými, které nejsou v JSON proměnných, byly přeskočeny"
+"prototype expressions with unsupported functions were skipped" = "výrazy prototypu s nepodporovanými funkcemi byly přeskočeny"
+"prototype interactions without supported actions were skipped" = "interakce prototypu bez podporovaných akcí byly přeskočeny"
+"prototype navigations of unknown types were skipped" = "navigace prototypu neznámých typů byly přeskočeny"
+"prototype transitions of unknown types play instantly" = "přechody prototypu neznámých typů proběhnou okamžitě"
+"prototype triggers of unknown types were skipped" = "spouštěče prototypu neznámých typů byly přeskočeny"
 "put a widget on the canvas" = "umístit widget na plátno"
 "read and edit the document" = "číst a upravovat dokument"
 "read the document" = "číst dokument"
 "reads the document" = "čte dokument"
+"set-variable actions on variables that aren't in the variables JSON were skipped" = "akce nastavení proměnné u proměnných, které nejsou v JSON proměnných, byly přeskočeny"
+"set-variable actions with values that can't be evaluated were skipped" = "akce nastavení proměnné s hodnotami, které nelze vyhodnotit, byly přeskočeny"
+"set-variable actions with values that don't fit the variable were skipped" = "akce nastavení proměnné s hodnotami, které neodpovídají proměnné, byly přeskočeny"
+"set-variable actions without a value were skipped" = "akce nastavení proměnné bez hodnoty byly přeskočeny"
+"set-variable-mode actions on collections or modes that aren't in the variables JSON were skipped" = "akce nastavení režimu proměnných u kolekcí nebo režimů, které nejsou v JSON proměnných, byly přeskočeny"
+"slot content assignment target is missing or is not slot content" = "cíl přiřazení obsahu slotu chybí nebo není obsahem slotu"
+"slot content assignment uses the empty GUID sentinel and was skipped" = "přiřazení obsahu slotu používá prázdné GUID jako zarážku a bylo přeskočeno"
+"some vector points refer to point settings missing from the file; they use the layer's joins and plain corners" = "některé vektorové body odkazují na nastavení bodů, která v souboru chybí; používají spojení vrstvy a nezaoblené rohy"
+"some vector segments refer to style settings missing from the file; they use the layer's stroke" = "některé vektorové segmenty odkazují na nastavení stylu, která v souboru chybí; používají tah vrstvy"
+"stale or invalid grid track sizing entries were ignored" = "zastaralé nebo neplatné položky velikosti stop mřížky byly ignorovány"
+"stars and polygons without point counts or geometry use the default point count" = "hvězdy a mnohoúhelníky bez počtu bodů nebo geometrie používají výchozí počet bodů"
+"style settings of some vector segments aren't supported; those segments use the layer's stroke" = "nastavení stylu některých vektorových segmentů nejsou podporována; tyto segmenty používají tah vrstvy"
+"text path underline or strikethrough decoration is not rendered" = "podtržení ani přeškrtnutí textu na cestě se nevykresluje"
+"text style overrides refer to missing table entries" = "přepsání textových stylů odkazují na chybějící položky tabulky"
+"the file has no pages" = "soubor nemá žádné stránky"
 "the plugin" = "plugin"
+"the variables JSON has no `variableCollections` (expected the local variables response) and was ignored" = "JSON proměnných nemá `variableCollections` (očekávala se odpověď s místními proměnnými) a byl ignorován"
 "this session only" = "pouze v této relaci"
+"unknown component property types were skipped" = "neznámé typy vlastností komponent byly přeskočeny"
+"variable aliases to variables that aren't in the variables JSON (or of another type) were skipped" = "aliasy na proměnné, které nejsou v JSON proměnných (nebo jsou jiného typu), byly přeskočeny"
+"variable bindings to properties the layer doesn't have were skipped" = "vazby proměnných na vlastnosti, které vrstva nemá, byly přeskočeny"
+"variable bindings to variables that aren't in the variables JSON (library variables) were skipped" = "vazby na proměnné, které nejsou v JSON proměnných (proměnné knihovny), byly přeskočeny"
+"variable bindings were skipped: the file JSON has no variable definitions (pass the local variables JSON as `variables`, or embed its `meta` next to the file JSON)" = "vazby proměnných byly přeskočeny: JSON souboru nemá definice proměnných (předejte JSON místních proměnných jako `variables` nebo vložte jeho `meta` vedle JSON souboru)"
+"variable bindings whose variable type doesn't fit the property were skipped" = "vazby proměnných, jejichž typ neodpovídá vlastnosti, byly přeskočeny"
+"variable collections without modes were skipped" = "kolekce proměnných bez režimů byly přeskočeny"
+"variable mode lookups in prototype expressions that aren't a variable and one of its modes were skipped" = "vyhledání režimu proměnné ve výrazech prototypu, které nejsou proměnnou a jedním z jejích režimů, byla přeskočena"
+"variable modes of collections that aren't in the file were skipped" = "režimy proměnných kolekcí, které nejsou v souboru, byly přeskočeny"
+"variable modes of collections that aren't in the variables JSON were skipped" = "režimy proměnných kolekcí, které nejsou v JSON proměnných, byly přeskočeny"
+"variable values that don't match their type (or composed colours) were skipped" = "hodnoty proměnných, které neodpovídají svému typu (nebo složené barvy), byly přeskočeny"
+"variables of unknown types were skipped" = "proměnné neznámých typů byly přeskočeny"
+"variables whose collection isn't in the variables JSON were skipped" = "proměnné, jejichž kolekce není v JSON proměnných, byly přeskočeny"
+"variables without readable values were skipped" = "proměnné bez čitelných hodnot byly přeskočeny"
+"vector points with unknown stroke joins use the layer join" = "vektorové body s neznámým spojením tahu používají spojení vrstvy"
+"vectors without geometry are empty" = "vektory bez geometrie jsou prázdné"
+"vectors without geometry are empty (export the file JSON with geometry=paths)" = "vektory bez geometrie jsou prázdné (exportujte JSON souboru s geometry=paths)"
+"very long text was cut to 1,048,576 characters" = "velmi dlouhý text byl zkrácen na 1 048 576 znaků"
+"very long vector paths were skipped" = "velmi dlouhé vektorové cesty byly přeskočeny"
+"video actions are not supported and were skipped" = "akce videa nejsou podporovány a byly přeskočeny"
+"video triggers are not supported and were skipped" = "spouštěče videa nejsou podporovány a byly přeskočeny"
 "yesterday" = "včera"
 "{instances} in {files}" = "{instances} · {files}"
 "{language}: draft translation, waiting for a native speaker's review." = "{language}: návrh překladu, čeká na kontrolu rodilým mluvčím."
@@ -1514,6 +1657,7 @@ status = "draft — needs native review"
 "{name} is forgotten on this computer; the file stays on {server}" = "Zapomenuto v tomto počítači: {name}; soubor zůstává na serveru {server}"
 "{name} is on the server." = "{name} je na serveru."
 "{name} is spotlighting" = "{name} sdílí pohled"
+"{name} is too large to open in the browser (over 512 MB)." = "Soubor {name} je příliš velký na otevření v prohlížeči (více než 512 MB)."
 "{name}\nClick to apply to the selection" = "{name}\nKliknutím použijete na výběr"
 "{name}\nDrag onto the canvas, or click to place in the middle of the view.\nHold Alt (Option) while dropping onto an instance to swap it." = "{name}\nPřetáhněte na plátno nebo kliknutím umístěte doprostřed zobrazení.\nPři puštění na instanci podržte Alt (Option) a vyměňte ji."
 "{name} (from {library})" = "{name} (z {library})"
@@ -1549,6 +1693,7 @@ status = "draft — needs native review"
 "{n} matches" = { one = "{n} shoda", few = "{n} shody", other = "{n} shod" }
 "{n} minutes ago" = { one = "Před {n} minutou", few = "Před {n} minutami", other = "Před {n} minutami" }
 "{n} months ago" = { one = "Před {n} měsícem", few = "Před {n} měsíci", other = "Před {n} měsíci" }
+"{n} more notes omitted from this report" = { one = "{n} další poznámka v této zprávě vynechána", few = "{n} další poznámky v této zprávě vynechány", other = "{n} dalších poznámek v této zprávě vynecháno" }
 "{n} of {total}" = "{n} z {total}"
 "{n} people joined" = { one = "Připojila se {n} osoba", few = "Připojily se {n} osoby", other = "Připojilo se {n} osob" }
 "{n} preferred components" = { one = "{n} preferovaná komponenta", few = "{n} preferované komponenty", other = "{n} preferovaných komponent" }
@@ -1608,7 +1753,17 @@ status = "draft — needs native review"
 "arrange.packH" = "Rozmístit těsně vodorovně"
 "arrange.packV" = "Rozmístit těsně svisle"
 "arrange.roundToPixels" = "Zaokrouhlit na pixely"
+"arrange.spacing" = "Rozestupy"
 "arrange.tidy" = "Uspořádat"
+"board.connector" = "Spojnice"
+"board.ink" = "Tah fixem"
+"board.label" = "Popisek spojnice"
+"board.nextSticky" = "Další lepicí poznámka"
+"board.setColor" = "Barva na tabuli"
+"board.setStyle" = "Styl na tabuli"
+"board.shape" = "Tvar s textem"
+"board.stamp" = "Razítko"
+"board.sticky" = "Lepicí poznámka"
 "bool.exclude" = "Vyloučit výběr"
 "bool.flatten" = "Sloučit booleovskou skupinu do vektoru"
 "bool.intersect" = "Průnik výběru"
@@ -1708,6 +1863,7 @@ status = "draft — needs native review"
 "edit.duplicate" = "Duplikovat"
 "edit.findReplace" = "Najít a nahradit"
 "edit.paste" = "Vložit"
+"edit.pasteDesignLayers" = "Vložit vrstvy návrhu"
 "edit.pasteOver" = "Vložit přes výběr"
 "edit.pasteProperties" = "Vložit vlastnosti"
 "edit.pasteReplace" = "Vložit a nahradit"
@@ -1731,7 +1887,9 @@ status = "draft — needs native review"
 "file.exportLayers" = "Exportovat vrstvy"
 "file.exportSvg" = "Exportovat výběr jako SVG"
 "file.import" = "Importovat"
+"file.moveTab" = "Přesunout kartu"
 "file.new" = "Nový soubor návrhu"
+"file.newBoard" = "Nová tabule"
 "file.newFromTemplate" = "Nový ze šablony"
 "file.open" = "Otevřít"
 "file.openRecent" = "Otevřít nedávné"
@@ -1914,6 +2072,10 @@ status = "draft — needs native review"
 "select.sameStroke" = "Vybrat stejný tah"
 "select.sameText" = "Vybrat stejné vlastnosti textu"
 "select.set" = "Vybrat"
+"selection.applyColorStyle" = "Použít barevný styl na výběr"
+"selection.colors" = "Barvy výběru"
+"selection.selectColor" = "Vybrat vrstvy s touto barvou"
+"selection.setPaint" = "Změnit barvu výběru"
 "shape.arrow" = "Šipka"
 "shape.ellipse" = "Elipsa"
 "shape.line" = "Čára"
@@ -1994,10 +2156,14 @@ status = "draft — needs native review"
 "text.weightUp" = "Zvětšit tloušťku písma"
 "tool.arrow" = "Šipka"
 "tool.comment" = "Komentář"
+"tool.connector" = "Spojnice"
 "tool.ellipse" = "Elipsa"
+"tool.eraser" = "Guma"
 "tool.frame" = "Rámec"
 "tool.hand" = "Ruka"
+"tool.highlighter" = "Zvýrazňovač"
 "tool.line" = "Čára"
+"tool.marker" = "Fix"
 "tool.move" = "Přesunout"
 "tool.pen" = "Pero"
 "tool.pencil" = "Tužka"
@@ -2009,9 +2175,12 @@ status = "draft — needs native review"
 "tool.scaleAnchor" = "Kotva měřítka"
 "tool.section" = "Sekce"
 "tool.set" = "Vybrat nástroj"
+"tool.shape" = "Tvary"
 "tool.shapeBuilder" = "Tvorba tvarů"
 "tool.slice" = "Výřez"
+"tool.stamp" = "Razítko"
 "tool.star" = "Hvězda"
+"tool.sticky" = "Lepicí poznámka"
 "tool.text" = "Text"
 "transform.move" = "Přesunout"
 "transform.moveTo" = "Přesunout na"
@@ -2073,11 +2242,13 @@ status = "draft — needs native review"
 "vector.edit.tool" = "Nástroj úprav vektoru"
 "vector.edit.transform" = "Transformovat body"
 "vector.edit.widthPoint" = "Bod šířky"
+"vector.fillRule" = "Nastavit pravidlo výplně"
 "vector.flatten" = "Sloučit do vektoru"
 "vector.join" = "Spojit výběr"
 "vector.offset" = "Odsadit cestu"
 "vector.outlineStroke" = "Převést tah na obrysy"
 "vector.reverse" = "Obrátit směr cesty"
+"vector.reverseLoop" = "Obrátit smyčku"
 "vector.simplify" = "Zjednodušit vektor"
 "vector.smoothJoin" = "Hladce spojit výběr"
 "version.autosave" = "Automaticky uložit verzi"
diff --git a/crates/ui-egui/locales/de.toml b/crates/ui-egui/locales/de.toml
index cd1e34827..816fecf13 100644
--- a/crates/ui-egui/locales/de.toml
+++ b/crates/ui-egui/locales/de.toml
@@ -17,6 +17,7 @@ status = "draft — needs native review"
 "1…9, 0" = "1…9, 0"
 "@{login}: {prs} PRs, {commits} commits, +{added} / −{deleted} lines (Δ {delta}), +{bin_added} / −{bin_deleted} binary assets, {first} – {last}" = "@{login}: {prs} PRs, {commits} Commits, +{added} / −{deleted} Zeilen (Δ {delta}), +{bin_added} / −{bin_deleted} Binärdateien, {first} – {last}"
 "A collection of this file with these modes and variables: override their values per mode and add variables of its own" = "Eine Sammlung dieser Datei mit diesen Modi und Variablen: Überschreiben Sie ihre Werte je Modus und fügen Sie eigene Variablen hinzu"
+"A .figcraft file with this name already exists. Choose its full name to confirm replacement." = "Eine .figcraft-Datei mit diesem Namen existiert bereits. Wählen Sie ihren vollständigen Namen, um das Ersetzen zu bestätigen."
 "A layer on its own aligns to its frame: select more layers, or one in a frame" = "Eine einzelne Ebene richtet sich an ihrem Rahmen aus: Wählen Sie weitere Ebenen oder eine Ebene in einem Rahmen"
 "A spring plays until it settles: its mass, stiffness and damping set how long" = "Eine Feder läuft, bis sie zur Ruhe kommt: Masse, Steifigkeit und Dämpfung bestimmen die Dauer"
 "About" = "Über"
@@ -117,6 +118,7 @@ status = "draft — needs native review"
 "Archived" = "Archiviert"
 "Arrange" = "Anordnen"
 "Arrow" = "Pfeil"
+"Arrow at the end" = "Pfeil am Ende"
 "As typed" = "Wie eingegeben"
 "Asking the server…" = "Server wird gefragt…"
 "Assets" = "Assets"
@@ -188,7 +190,9 @@ status = "draft — needs native review"
 "C or ⇧C" = "C oder ⇧C"
 "CMYK colour" = "CMYK-Farbe"
 "Can view" = "Kann ansehen"
+"Check" = "Häkchen"
 "Checking the server…" = "Server wird geprüft…"
+"Chevron" = "Chevron"
 "Clear from this list" = "Aus dieser Liste entfernen"
 "Code or invite link" = "Code oder Einladungslink"
 "Color profile: {name}" = "Farbprofil: {name}"
@@ -234,7 +238,6 @@ status = "draft — needs native review"
 "Close tab" = "Tab schließen"
 "Close version history" = "Versionsverlauf schließen"
 "Close when clicking outside" = "Bei Klick außerhalb schließen"
-"Close without saving" = "Ohne Speichern schließen"
 "Code" = "Code"
 "Code syntax" = "Code-Syntax"
 "Collapse" = "Einklappen"
@@ -261,6 +264,8 @@ status = "draft — needs native review"
 "Commits" = "Commits"
 "Company" = "Unternehmen"
 "Compare changes" = "Änderungen vergleichen"
+"Compare with" = "Vergleichen mit"
+"Compatibility notes" = "Hinweise zur Kompatibilität"
 "Completed" = "Abgeschlossen"
 "Component" = "Komponente"
 "Component name" = "Komponentenname"
@@ -275,6 +280,7 @@ status = "draft — needs native review"
 "Connected" = "Verbunden"
 "Connected to code: {from}" = "Mit Code verbunden: {from}"
 "Connection lost, reconnecting (attempt {attempt})…" = "Verbindung verloren, neuer Versuch ({attempt})…"
+"Connector" = "Verbinder"
 "Constrain proportions" = "Proportionen beibehalten"
 "Constraints" = "Constraints"
 "Content" = "Inhalt"
@@ -304,6 +310,7 @@ status = "draft — needs native review"
 "Corner smoothing" = "Eckenglättung"
 "Couldn't download the variables" = "Die Variablen konnten nicht heruntergeladen werden"
 "Couldn't reach {server}: showing what this computer remembers." = "{server} war nicht erreichbar: Es wird angezeigt, was dieser Computer gespeichert hat."
+"Couldn't read {name}." = "{name} konnte nicht gelesen werden."
 "Couldn't save automatically: {error}" = "Automatisches Speichern fehlgeschlagen: {error}"
 "Count" = "Anzahl"
 "Create" = "Erstellen"
@@ -327,6 +334,7 @@ status = "draft — needs native review"
 "Current version" = "Aktuelle Version"
 "Cursor chat" = "Cursor-Chat"
 "Custom" = "Benutzerdefiniert"
+"Custom size" = "Benutzerdefinierte Größe"
 "Cut" = "Ausschneiden"
 "Dark" = "Dunkel"
 "Darken" = "Abdunkeln"
@@ -357,6 +365,7 @@ status = "draft — needs native review"
 "Description" = "Beschreibung"
 "Description (optional)" = "Beschreibung (optional)"
 "Design" = "Design"
+"Design panel" = "Design-Bereich"
 "Desktop" = "Desktop"
 "Destination" = "Ziel"
 "Detach alias" = "Alias lösen"
@@ -367,6 +376,7 @@ status = "draft — needs native review"
 "Detach variable" = "Variable lösen"
 "Details" = "Details"
 "Dev Mode" = "Entwicklermodus"
+"Dev Mode only inspects: switch to Design (Shift+D) to edit" = "Der Entwicklermodus prüft nur: Wechseln Sie zu Design (Shift+D), um zu bearbeiten"
 "Dev resources" = "Entwicklerressourcen"
 "Development" = "Entwicklung"
 "Device" = "Gerät"
@@ -383,6 +393,7 @@ status = "draft — needs native review"
 "Distribute horizontal spacing" = "Horizontale Abstände verteilen"
 "Distribute vertical spacing" = "Vertikale Abstände verteilen"
 "Divider" = "Trennlinie"
+"Don't Save" = "Nicht speichern"
 "Don't truncate" = "Nicht kürzen"
 "Done" = "Fertig"
 "Done editing" = "Bearbeitung beenden"
@@ -416,6 +427,7 @@ status = "draft — needs native review"
 "Effect settings" = "Effekteinstellungen"
 "Effect styles" = "Effektstile"
 "Effects" = "Effekte"
+"Elbow" = "Gewinkelt"
 "Ellipse" = "Ellipse"
 "Ellipses" = "Ellipsen"
 "Else" = "Sonst"
@@ -464,6 +476,7 @@ status = "draft — needs native review"
 "False" = "Falsch"
 "Fetching from the server…" = "Wird vom Server abgerufen…"
 "FigCraft couldn't open its window: {error}" = "FigCraft konnte sein Fenster nicht öffnen: {error}"
+"FigCraft doesn't support every feature of these files yet. The notes list what was left out or changed in the imported copy; the original file is unchanged." = "FigCraft unterstützt noch nicht alle Funktionen dieser Dateien. Die Hinweise nennen, was in der importierten Kopie weggelassen oder geändert wurde; die Originaldatei bleibt unverändert."
 "File" = "Datei"
 "File name" = "Dateiname"
 "File published" = "Datei veröffentlicht"
@@ -545,6 +558,7 @@ status = "draft — needs native review"
 "Hanging list" = "Hängende Liste"
 "Hanging punctuation" = "Hängende Interpunktion"
 "Hard light" = "Hartes Licht"
+"Heart" = "Herz"
 "Height" = "Höhe"
 "Help" = "Hilfe"
 "Help and resources" = "Hilfe und Ressourcen"
@@ -555,6 +569,7 @@ status = "draft — needs native review"
 "Hide from publishing" = "Nicht veröffentlichen"
 "Hide section contents" = "Abschnittsinhalt ausblenden"
 "Highlight layers on hover" = "Ebenen beim Überfahren hervorheben"
+"Highlighter" = "Textmarker"
 "Highlights" = "Lichter"
 "Hold Alt" = "Alt gedrückt halten"
 "Hold Alt+Z" = "Alt+Z gedrückt halten"
@@ -580,11 +595,14 @@ status = "draft — needs native review"
 "If {condition}" = "Wenn {condition}"
 "Ignore auto layout (absolute position)" = "Auto-Layout ignorieren (absolute Position)"
 "Image" = "Bild"
+"Images" = "Bilder"
 "Import" = "Importieren"
 "Import path" = "Importpfad"
 "Import plugin from manifest" = "Plugin aus Manifest importieren"
 "Import plugin from manifest…" = "Plugin aus Manifest importieren…"
+"Import report" = "Importbericht"
 "Import variables" = "Variablen importieren"
+"Imported document" = "Importiertes Dokument"
 "Imported {name}" = "{name} importiert"
 "Imported {n} new variables, updated {updated}" = { one = "{n} neue Variable importiert, {updated} aktualisiert", other = "{n} neue Variablen importiert, {updated} aktualisiert" }
 "Import…" = "Importieren…"
@@ -612,11 +630,13 @@ status = "draft — needs native review"
 "Instance swap (no other component)" = "Instanztausch (keine andere Komponente)"
 "Instances" = "Instanzen"
 "Instant" = "Sofort"
+"Intensity" = "Intensität"
 "Interaction" = "Interaktion"
 "Interactions" = "Interaktionen"
 "Interface design and prototyping. A free, open-source, clean-room design tool written from scratch in Rust, part of the ArtCraft Crafting Apps." = "Interface-Design und Prototyping. Ein kostenloses Open-Source-Designwerkzeug, als Clean-Room-Entwicklung von Grund auf in Rust geschrieben, Teil der ArtCraft Crafting Apps."
 "Intersect" = "Schnittmenge"
 "Intersects" = "Schnittmengen"
+"Invalid color" = "Ungültige Farbe"
 "Invite link" = "Einladungslink"
 "Invite link copied" = "Einladungslink kopiert"
 "It asks permission to:" = "Es möchte:"
@@ -705,6 +725,7 @@ status = "draft — needs native review"
 "Mark as resolved" = "Als erledigt markieren"
 "Mark as unread" = "Als ungelesen markieren"
 "Mark as unresolved" = "Als nicht erledigt markieren"
+"Marker" = "Marker"
 "Mask" = "Maske"
 "Mass · Stiffness · Damping" = "Masse · Steifigkeit · Dämpfung"
 "Match (empty: the whole name)" = "Übereinstimmung (leer: der ganze Name)"
@@ -761,7 +782,9 @@ status = "draft — needs native review"
 "Named instance" = "Benannte Instanz"
 "Navigate to" = "Navigieren zu"
 "Nested instance" = "Verschachtelte Instanz"
+"New board" = "Neues Whiteboard"
 "New design file" = "Neue Designdatei"
+"Next frame" = "Nächster Rahmen"
 "Next or previous control in the focused region" = "Nächstes oder vorheriges Steuerelement im fokussierten Bereich"
 "Next ready for dev" = "Nächstes bereit für Entwicklung"
 "Next size option" = "Nächste Größenoption"
@@ -771,12 +794,15 @@ status = "draft — needs native review"
 "No branches. A branch is a copy of the file to try changes in, then review and merge." = "Keine Branches. Ein Branch ist eine Kopie der Datei, in der Sie Änderungen ausprobieren, prüfen und dann zusammenführen."
 "No category" = "Keine Kategorie"
 "No changes" = "Keine Änderungen"
+"No color styles" = "Keine Farbstile"
 "No colour variables fit here." = "Hier passen keine Farbvariablen."
 "No colour variables yet. Create them in Local variables." = "Noch keine Farbvariablen. Erstellen Sie sie unter Lokale Variablen."
 "No comments yet" = "Noch keine Kommentare"
+"No compatibility warnings reported" = "Keine Kompatibilitätswarnungen gemeldet"
 "No components yet. Select layers and press {keys}." = "Noch keine Komponenten. Wählen Sie Ebenen aus und drücken Sie {keys}."
 "No conflicts." = "Keine Konflikte."
 "No contributor data was built into this copy." = "Diese Kopie enthält keine Daten zu Mitwirkenden."
+"No device" = "Kein Gerät"
 "No fonts match" = "Keine passenden Schriften"
 "No join code here (the server is older than join codes, or this address can't be put in one): share the link instead." = "Hier gibt es keinen Beitrittscode (der Server ist älter als Beitrittscodes, oder diese Adresse passt in keinen): Teilen Sie stattdessen den Link."
 "No layer changes to show." = "Keine Ebenenänderungen vorhanden."
@@ -819,6 +845,7 @@ status = "draft — needs native review"
 "Not read yet" = "Noch nicht gelesen"
 "Not shared" = "Nicht geteilt"
 "Note {n}" = "Notiz {n}"
+"Nothing changed since this version." = "Seit dieser Version hat sich nichts geändert."
 "Nothing changed since this was marked ready for dev." = "Seit der Markierung als bereit für die Entwicklung hat sich nichts geändert."
 "Nothing here yet. Set a frame's status to list it." = "Noch nichts hier. Legen Sie den Status eines Rahmens fest, um ihn aufzulisten."
 "Nothing online yet. Use Share on a file to put it online and it is listed here." = "Noch nichts online. Stellen Sie eine Datei über „Teilen“ online, dann erscheint sie hier."
@@ -852,6 +879,7 @@ status = "draft — needs native review"
 "Open branch" = "Branch öffnen"
 "Open file" = "Datei öffnen"
 "Open files" = "Geöffnete Dateien"
+"Open presentations" = "Geöffnete Präsentationen"
 "Open in focus view" = "In Fokusansicht öffnen"
 "Open in new window" = "In neuem Fenster öffnen"
 "Open invite links in FigCraft" = "Einladungslinks in FigCraft öffnen"
@@ -860,6 +888,7 @@ status = "draft — needs native review"
 "Open overlay" = "Overlay öffnen"
 "Open prototype preview" = "Prototyp-Vorschau öffnen"
 "Open variables ({count})" = "Variablen öffnen ({count})"
+"Opened as a new document" = "Als neues Dokument geöffnet"
 "Opened “{name}” in a new tab" = "„{name}“ in neuem Tab geöffnet"
 "Opening the file…" = "Datei wird geöffnet…"
 "Opening {n} files as new files" = { one = "Wird als neue Datei geöffnet", other = "{n} Dateien werden als neue Dateien geöffnet" }
@@ -884,7 +913,11 @@ status = "draft — needs native review"
 "PDF print settings" = "PDF-Druckeinstellungen"
 "Padding" = "Innenabstand"
 "Page" = "Seite"
+"Page deleted" = "Seite gelöscht"
 "Pages" = "Seiten"
+"Pages added to the document" = "Seiten zum Dokument hinzugefügt"
+"Pink" = "Rosa"
+"Placed on the current page" = "Auf der aktuellen Seite platziert"
 "Pages: {pages}" = "Seiten: {pages}"
 "Paint bucket" = "Farbeimer"
 "Pan the canvas" = "Arbeitsfläche verschieben"
@@ -899,6 +932,7 @@ status = "draft — needs native review"
 "Paste a team library link (a view link)" = "Link einer Teambibliothek einfügen (ein Ansichtslink)"
 "Paste here" = "Hier einfügen"
 "Paste to replace" = "Zum Ersetzen einfügen"
+"Pasted design layers; {n} kinds of content were left out" = { one = "Designebenen eingefügt; {n} Art von Inhalt wurde ausgelassen", other = "Designebenen eingefügt; {n} Arten von Inhalt wurden ausgelassen" }
 "Pattern" = "Muster"
 "Pattern alignment" = "Musterausrichtung"
 "Pattern scale" = "Musterskalierung"
@@ -924,6 +958,7 @@ status = "draft — needs native review"
 "Plugins run in FigCraft's sandbox, without files, network or clock. Install only plugins you trust." = "Plugins laufen in der Sandbox von FigCraft, ohne Dateien, Netzwerk oder Uhr. Installieren Sie nur Plugins, denen Sie vertrauen."
 "Plus darker" = "Plus dunkler"
 "Plus lighter" = "Plus heller"
+"Plus one" = "Plus eins"
 "Point" = "Punkt"
 "Points" = "Punkte"
 "Polygon" = "Polygon"
@@ -949,6 +984,7 @@ status = "draft — needs native review"
 "Preview" = "Vorschau"
 "Preview this flow" = "Vorschau dieses Ablaufs"
 "Preview this frame" = "Vorschau dieses Rahmens"
+"Previous frame" = "Vorheriger Rahmen"
 "Previous ready for dev" = "Vorheriges bereit für Entwicklung"
 "Progressive" = "Progressiv"
 "Properties" = "Eigenschaften"
@@ -969,6 +1005,7 @@ status = "draft — needs native review"
 "Push" = "Schieben"
 "Push changes to main component" = "Änderungen an Hauptkomponente übertragen"
 "Put text on path" = "Text auf Pfad setzen"
+"Question" = "Frage"
 "R" = "R"
 "Radial" = "Radial"
 "Radius" = "Radius"
@@ -1013,6 +1050,7 @@ status = "draft — needs native review"
 "Removed" = "Entfernt"
 "Removed from the server" = "Vom Server entfernt"
 "Removed since it was marked" = "Seit der Markierung entfernt"
+"Removed since this version" = "Seit dieser Version entfernt"
 "Rename" = "Umbenennen"
 "Rename duplicated layers" = "Duplizierte Ebenen umbenennen"
 "Rename folder" = "Ordner umbenennen"
@@ -1042,6 +1080,7 @@ status = "draft — needs native review"
 "Resize by the nudge amount" = "Um die Schrittweite skalieren"
 "Resize frames to the device's screen (or the window without a device): their constraints and auto layout respond" = "Passt Rahmen an den Bildschirm des Geräts an (ohne Gerät an das Fenster): ihre Constraints und ihr Auto-Layout reagieren"
 "Resize to fit" = "Größe an Inhalt anpassen"
+"Resizing" = "Größenanpassung"
 "Resolve" = "Erledigen"
 "Resolve change" = "Änderung erledigen"
 "Resolved" = "Erledigt"
@@ -1067,6 +1106,7 @@ status = "draft — needs native review"
 "Rotation jitter" = "Drehungsschwankung"
 "Round" = "Rund"
 "Rounded" = "Abgerundet"
+"Rounded rectangle" = "Abgerundetes Rechteck"
 "Row" = "Zeile"
 "Row gap" = "Zeilenabstand"
 "Row sizes" = "Zeilengrößen"
@@ -1113,12 +1153,14 @@ status = "draft — needs native review"
 "Select all with same" = "Alle auswählen mit gleicher"
 "Select layer" = "Ebene auswählen"
 "Select layers to apply the style to" = "Wählen Sie die Ebenen aus, auf die der Stil angewendet werden soll"
+"Select layers with this color" = "Ebenen mit dieser Farbe auswählen"
 "Select overlapping shapes" = "Wählen Sie überlappende Formen aus"
 "Select points to edit their position, radius and mirroring" = "Wählen Sie Punkte aus, um Position, Radius und Spiegelung zu bearbeiten"
 "Select slot" = "Slot auswählen"
 "Selection" = "Auswahl"
 "Selection box, {w} by {h} at {x}, {y}: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "Auswahlrahmen, {w} × {h} bei {x}, {y}: Pfeiltasten verschieben ihn, Umschalt+Pfeiltasten oder {cmd}+Pfeiltasten ändern die Größe, Eingabe wählt aus, Esc bricht ab"
 "Selection box: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "Auswahlrahmen: Pfeiltasten verschieben ihn, Umschalt+Pfeiltasten oder {cmd}+Pfeiltasten ändern die Größe, Eingabe wählt aus, Esc bricht ab"
+"Selection colors" = "Auswahlfarben"
 "Send backward" = "Eine Ebene nach hinten"
 "Send report" = "Meldung senden"
 "Send to back" = "In den Hintergrund"
@@ -1134,6 +1176,7 @@ status = "draft — needs native review"
 "Shape" = "Form"
 "Shape builder" = "Formerstellung"
 "Shape tools" = "Formwerkzeuge"
+"Shapes" = "Formen"
 "Share" = "Teilen"
 "Share this file" = "Diese Datei teilen"
 "Share: live session, export" = "Teilen: Live-Sitzung, Export"
@@ -1191,10 +1234,13 @@ status = "draft — needs native review"
 "Space+drag" = "Leertaste+Ziehen"
 "Spacing" = "Abstand"
 "Spam, stolen work, abuse…" = "Spam, gestohlene Arbeit, Missbrauch…"
+"Speech bubble" = "Sprechblase"
 "Splay" = "Spreizung"
 "Spotlight me" = "Spotlight auf mich"
 "Spread" = "Ausbreitung"
 "Square" = "Quadrat"
+"Stamp" = "Stempel"
+"Stamps" = "Stempel"
 "Standard" = "Standard"
 "Standard ligatures" = "Standardligaturen"
 "Star" = "Stern"
@@ -1203,17 +1249,22 @@ status = "draft — needs native review"
 "Start ascending from / stop descending at" = "Aufwärts zählen ab / abwärts zählen bis"
 "Start from a blank canvas" = "Mit einer leeren Arbeitsfläche beginnen"
 "Start on path" = "Anfang auf dem Pfad"
+"Start on the Home screen" = "Mit Start beginnen"
 "Start point" = "Startpunkt"
 "Start sharing" = "Teilen starten"
 "Starting to share…" = "Teilen wird gestartet…"
 "Status" = "Status"
 "Sticky" = "Fixiert"
+"Sticky note" = "Haftnotiz"
+"Sticky note colors" = "Haftnotizfarben"
+"Sticky notes, shapes and connectors" = "Haftnotizen, Formen und Verbinder"
 "Stop" = "Beenden"
 "Stop following {name}" = "{name} nicht mehr folgen"
 "Stop session" = "Sitzung beenden"
 "Stop sharing" = "Teilen beenden"
 "Stop spotlighting" = "Spotlight beenden"
 "Stop {n}  {hex}" = "Farbunterbrechung {n}  {hex}"
+"Straight" = "Gerade"
 "Stretch" = "Strecken"
 "Strikethrough" = "Durchgestrichen"
 "String" = "Zeichenfolge"
@@ -1257,6 +1308,7 @@ status = "draft — needs native review"
 "Text" = "Text"
 "Text align" = "Textausrichtung"
 "Text content" = "Textinhalt"
+"Text size" = "Textgröße"
 "Text style" = "Textstil"
 "Text styles" = "Textstile"
 "Texts" = "Texte"
@@ -1290,6 +1342,9 @@ status = "draft — needs native review"
 "This server is open to the public: no key needed." = "Dieser Server ist öffentlich zugänglich: kein Schlüssel nötig."
 "This server needs its key: add ?key=… to the address (`figcraft-server key` prints it on the server's machine)." = "Dieser Server braucht seinen Schlüssel: Fügen Sie der Adresse ?key=… hinzu (`figcraft-server key` gibt ihn auf dem Rechner des Servers aus)."
 "This server takes files only with its key: see Advanced." = "Dieser Server nimmt Dateien nur mit seinem Schlüssel an: siehe Erweitert."
+"Thumbs up" = "Daumen hoch"
+"This version can't be read." = "Diese Version kann nicht gelesen werden."
+"This version doesn't have it: all of it is new." = "Diese Version enthält es nicht: alles daran ist neu."
 "Tidy up" = "Aufräumen"
 "Tile" = "Kachel"
 "Tile type" = "Kacheltyp"
@@ -1306,6 +1361,7 @@ status = "draft — needs native review"
 "Top left radius" = "Radius oben links"
 "Top right radius" = "Radius oben rechts"
 "Transform" = "Transformieren"
+"Triangle" = "Dreieck"
 "Triangle arrow" = "Dreieckspfeil"
 "Trigger" = "Auslöser"
 "True" = "Wahr"
@@ -1328,7 +1384,7 @@ status = "draft — needs native review"
 "Unread" = "Ungelesen"
 "Unresolve" = "Wieder öffnen"
 "Unsaved changes" = "Nicht gespeicherte Änderungen"
-"Unsaved changes in {names}. Close the window and lose them?" = "Nicht gespeicherte Änderungen in {names}. Fenster schließen und Änderungen verwerfen?"
+"Unsaved changes in {names}. Save them before closing?" = "Nicht gespeicherte Änderungen in {names}. Vor dem Schließen speichern?"
 "Unsaved changes: save first ({save}), or close the tab with {alt}-click to discard" = "Nicht gespeicherte Änderungen: Speichern Sie zuerst ({save}) oder schließen Sie den Tab mit {alt}+Klick, um sie zu verwerfen"
 "Unsaved changes: save first, or close again with {key} to discard" = "Nicht gespeicherte Änderungen: Speichern Sie zuerst oder schließen Sie erneut mit {key}, um sie zu verwerfen"
 "Up" = "Nach oben"
@@ -1347,6 +1403,7 @@ status = "draft — needs native review"
 "Use as mask" = "Als Maske verwenden"
 "Use auto layout" = "Auto-Layout verwenden"
 "Use number keys for opacity" = "Zifferntasten für Deckkraft verwenden"
+"Use the .figcraft or .fig extension." = "Verwenden Sie die Dateiendung .figcraft oder .fig."
 "Use the layer's fill" = "Füllung der Ebene verwenden"
 "Used in {files} · {instances}" = "Verwendet in {files} · {instances}"
 "Username" = "Benutzername"
@@ -1390,10 +1447,12 @@ status = "draft — needs native review"
 "WebSocket URL copied" = "WebSocket-URL kopiert"
 "Wedge" = "Keil"
 "Weight" = "Stärke"
+"What changed since a saved version" = "Was sich seit einer gespeicherten Version geändert hat"
 "What changed since it was marked ready for dev" = "Was sich seit der Markierung als bereit für die Entwicklung geändert hat"
 "What is wrong with this file? The server's operator gets your report." = "Was stimmt mit dieser Datei nicht? Der Betreiber des Servers erhält Ihre Meldung."
 "What it's for" = "Wofür sie gedacht ist"
 "What this changed from isn't known: it changed before FigCraft kept a copy of ready-for-dev frames. Resolve the change (or mark it ready again) to compare from now on." = "Der Ausgangsstand dieser Änderung ist unbekannt: Sie erfolgte, bevor FigCraft Kopien von Rahmen mit dem Status „Bereit für Entwicklung“ aufbewahrte. Erledigen Sie die Änderung (oder markieren Sie den Rahmen erneut als bereit), um ab jetzt zu vergleichen."
+"When marked ready" = "Beim Markieren als bereit"
 "While hovering" = "Beim Überfahren"
 "While pressing" = "Beim Drücken"
 "White" = "Weiß"
@@ -1435,25 +1494,118 @@ status = "draft — needs native review"
 "call any command its access allows" = "jeden Befehl aufrufen, den sein Zugriff erlaubt"
 "call only: {commands}" = "nur aufrufen: {commands}"
 "can edit the document" = "kann das Dokument bearbeiten"
+"conditional prototype actions nested too deeply were skipped" = "zu tief verschachtelte bedingte Prototyp-Aktionen wurden übersprungen"
+"conditional prototype actions with conditions that can't be evaluated were skipped" = "bedingte Prototyp-Aktionen mit nicht auswertbaren Bedingungen wurden übersprungen"
+"connector label background was skipped: style data is missing" = "Hintergrund der Verbinderbeschriftung wurde übersprungen: Stildaten fehlen"
+"connector label was skipped: background bounds are invalid" = "Verbinderbeschriftung wurde übersprungen: Grenzen des Hintergrunds sind ungültig"
+"connector label was skipped: background transform is invalid" = "Verbinderbeschriftung wurde übersprungen: Transformation des Hintergrunds ist ungültig"
+"connector label was skipped: composed text transform is invalid" = "Verbinderbeschriftung wurde übersprungen: zusammengesetzte Texttransformation ist ungültig"
+"connector label was skipped: derived background bounds are missing" = "Verbinderbeschriftung wurde übersprungen: abgeleitete Grenzen des Hintergrunds fehlen"
+"connector label was skipped: derived text bounds are missing" = "Verbinderbeschriftung wurde übersprungen: abgeleitete Textgrenzen fehlen"
+"connector label was skipped: text bounds are invalid" = "Verbinderbeschriftung wurde übersprungen: Textgrenzen sind ungültig"
+"connector label was skipped: text style data is missing" = "Verbinderbeschriftung wurde übersprungen: Textstildaten fehlen"
+"connector label was skipped: text transform is invalid" = "Verbinderbeschriftung wurde übersprungen: Texttransformation ist ungültig"
+"connector labels were skipped" = "Verbinderbeschriftungen wurden übersprungen"
+"connector layers import as static frame/vector snapshots with labels when present; live endpoint bindings are not retained" = "Verbinderebenen werden als statische Rahmen- oder Vektor-Momentaufnahmen importiert, mit Beschriftungen, sofern vorhanden; dynamische Bindungen der Endpunkte bleiben nicht erhalten"
+"connector snapshot vector data is missing; connector was left empty" = "Vektordaten der Verbinder-Momentaufnahme fehlen; der Verbinder bleibt leer"
+"connectors whose ends can't be placed are empty" = "Verbinder, deren Enden sich nicht platzieren lassen, sind leer"
 "crop marks" = "Schnittmarken"
+"damaged vector geometry was skipped" = "beschädigte Vektorgeometrie wurde übersprungen"
+"damaged vector networks import as outlines" = "beschädigte Vektornetze werden als Umrisse importiert"
 "development: {path}" = "Entwicklung: {path}"
+"document children other than pages were skipped" = "Dokumentinhalte, die keine Seiten sind, wurden übersprungen"
+"duplicate grid track sizing entries use equal tracks" = "doppelte Größeneinträge für Rasterspuren verwenden gleich große Spuren"
 "e.g. count + 1" = "z. B. count + 1"
 "e.g. count >= 3 and not done" = "z. B. count >= 3 and not done"
+"elbowed and curved connectors without a saved path import as straight lines" = "gewinkelte und gebogene Verbinder ohne gespeicherten Pfad werden als gerade Linien importiert"
+"entries without a node type were skipped" = "Einträge ohne Knotentyp wurden übersprungen"
 "figcraft:// links from a browser, chat or email open this app and join the session." = "figcraft://-Links aus Browser, Chat oder E-Mail öffnen diese App und treten der Sitzung bei."
+"filled areas of a vector with their own fill use the layer's fill" = "gefüllte Bereiche eines Vektors mit eigener Füllung verwenden die Füllung der Ebene"
 "from {server}" = "von {server}"
+"gamepad triggers without exactly one known controller button were skipped" = "Gamepad-Auslöser ohne genau eine bekannte Controllertaste wurden übersprungen"
+"grid track list exceeds 1000 entries; the tracks use the default equal sizing" = "die Liste der Rasterspuren hat mehr als 1000 Einträge; die Spuren verwenden die standardmäßige gleiche Größe"
+"grid track sizing is unsupported or malformed; affected tracks use equal sizing" = "die Größe der Rasterspuren wird nicht unterstützt oder ist fehlerhaft; betroffene Spuren sind gleich groß"
+"grid track sizing list exceeds 1000 entries; the tracks use the default equal sizing" = "die Liste der Rasterspurgrößen hat mehr als 1000 Einträge; die Spuren verwenden die standardmäßige gleiche Größe"
 "hidden" = "ausgeblendet"
 "iOS" = "iOS"
+"image filters are ambiguous because both filter containers are present; filter conversion was skipped" = "Bildfilter sind mehrdeutig, weil beide Filtercontainer vorhanden sind; die Filterumwandlung wurde übersprungen"
+"image filters use FigCraft's approximate renderer" = "Bildfilter verwenden die näherungsweise Darstellung von FigCraft"
+"instance swap properties whose default component isn't in the file were skipped" = "Instanztausch-Eigenschaften, deren Standardkomponente nicht in der Datei ist, wurden übersprungen"
+"instances inside their own main component were imported as frames" = "Instanzen innerhalb ihrer eigenen Hauptkomponente wurden als Rahmen importiert"
+"instances of components that aren't in the file show no layers" = "Instanzen von Komponenten, die nicht in der Datei sind, zeigen keine Ebenen"
+"instances of components that aren't in the file were imported as frames" = "Instanzen von Komponenten, die nicht in der Datei sind, wurden als Rahmen importiert"
+"instances that would nest a component inside itself were imported as frames" = "Instanzen, die eine Komponente in sich selbst verschachteln würden, wurden als Rahmen importiert"
+"instances without a main component were imported as empty frames" = "Instanzen ohne Hauptkomponente wurden als leere Rahmen importiert"
+"invalid internal .fig text path data was ignored" = "ungültige interne .fig-Daten für Text auf Pfad wurden ignoriert"
+"invalid or oversized vector networks import as outlines" = "ungültige oder zu große Vektornetze werden als Umrisse importiert"
+"invalid or oversized vector path data was skipped" = "ungültige oder zu große Vektorpfaddaten wurden übersprungen"
+"key triggers without a supported key were skipped" = "Tastenauslöser ohne unterstützte Taste wurden übersprungen"
+"key up triggers import as key presses" = "Auslöser beim Loslassen einer Taste werden als Tastendruck importiert"
+"layers without a position were placed at their parent's origin" = "Ebenen ohne Position wurden am Ursprung ihres übergeordneten Elements platziert"
+"layers without a type were skipped" = "Ebenen ohne Typ wurden übersprungen"
+"legacy image filter container is unsupported; filter conversion was skipped" = "der veraltete Bildfiltercontainer wird nicht unterstützt; die Filterumwandlung wurde übersprungen"
 "locked" = "gesperrt"
+"malformed image filters container was skipped" = "fehlerhafter Bildfiltercontainer wurde übersprungen"
+"malformed image paintFilter container was skipped" = "fehlerhafter paintFilter-Container des Bildes wurde übersprungen"
+"malformed slot content assignment was skipped" = "fehlerhafte Zuweisung von Slot-Inhalt wurde übersprungen"
 "no bleed" = "kein Anschnitt"
 "nobody else here yet" = "noch niemand sonst hier"
+"non-default slot settings are not represented and were skipped" = "vom Standard abweichende Slot-Einstellungen werden nicht abgebildet und wurden übersprungen"
 "now" = "jetzt"
 "or" = "oder"
+"point stroke joins were preserved; dashed or variable-width strokes render with the layer join" = "die Konturecken der Punkte wurden übernommen; gestrichelte Konturen und Konturen mit variabler Breite werden mit der Ecke der Ebene gezeichnet"
+"preferred slot component keys cannot be resolved to file nodes and were skipped" = "bevorzugte Komponentenschlüssel von Slots lassen sich keinen Ebenen der Datei zuordnen und wurden übersprungen"
+"prototype actions of unknown types were skipped" = "Prototyp-Aktionen unbekannter Art wurden übersprungen"
+"prototype actions without a destination in the file were skipped" = "Prototyp-Aktionen ohne Ziel in der Datei wurden übersprungen"
+"prototype expressions on variables that aren't in the variables JSON were skipped" = "Prototyp-Ausdrücke mit Variablen, die nicht im Variablen-JSON sind, wurden übersprungen"
+"prototype expressions with unsupported functions were skipped" = "Prototyp-Ausdrücke mit nicht unterstützten Funktionen wurden übersprungen"
+"prototype interactions without supported actions were skipped" = "Prototyp-Interaktionen ohne unterstützte Aktionen wurden übersprungen"
+"prototype navigations of unknown types were skipped" = "Prototyp-Navigationen unbekannter Art wurden übersprungen"
+"prototype transitions of unknown types play instantly" = "Prototyp-Übergänge unbekannter Art werden sofort ausgeführt"
+"prototype triggers of unknown types were skipped" = "Prototyp-Auslöser unbekannter Art wurden übersprungen"
 "put a widget on the canvas" = "ein Widget auf die Arbeitsfläche setzen"
 "read and edit the document" = "das Dokument lesen und bearbeiten"
 "read the document" = "das Dokument lesen"
 "reads the document" = "liest das Dokument"
+"set-variable actions on variables that aren't in the variables JSON were skipped" = "Aktionen „Variable festlegen“ für Variablen, die nicht im Variablen-JSON sind, wurden übersprungen"
+"set-variable actions with values that can't be evaluated were skipped" = "Aktionen „Variable festlegen“ mit nicht auswertbaren Werten wurden übersprungen"
+"set-variable actions with values that don't fit the variable were skipped" = "Aktionen „Variable festlegen“ mit Werten, die nicht zur Variable passen, wurden übersprungen"
+"set-variable actions without a value were skipped" = "Aktionen „Variable festlegen“ ohne Wert wurden übersprungen"
+"set-variable-mode actions on collections or modes that aren't in the variables JSON were skipped" = "Aktionen „Variablenmodus festlegen“ für Sammlungen oder Modi, die nicht im Variablen-JSON sind, wurden übersprungen"
+"slot content assignment target is missing or is not slot content" = "das Ziel der Slot-Inhaltszuweisung fehlt oder ist kein Slot-Inhalt"
+"slot content assignment uses the empty GUID sentinel and was skipped" = "die Slot-Inhaltszuweisung verwendet die leere GUID als Platzhalterwert und wurde übersprungen"
+"some vector points refer to point settings missing from the file; they use the layer's joins and plain corners" = "einige Vektorpunkte verweisen auf Punkteinstellungen, die in der Datei fehlen; sie übernehmen die Ecken der Ebenenkontur und bleiben ungerundet"
+"some vector segments refer to style settings missing from the file; they use the layer's stroke" = "einige Vektorsegmente verweisen auf Stileinstellungen, die in der Datei fehlen; sie verwenden die Kontur der Ebene"
+"stale or invalid grid track sizing entries were ignored" = "veraltete oder ungültige Größeneinträge für Rasterspuren wurden ignoriert"
+"stars and polygons without point counts or geometry use the default point count" = "Sterne und Polygone ohne Punktanzahl oder Geometrie verwenden die Standard-Punktanzahl"
+"style settings of some vector segments aren't supported; those segments use the layer's stroke" = "Stileinstellungen einiger Vektorsegmente werden nicht unterstützt; diese Segmente verwenden die Kontur der Ebene"
+"text path underline or strikethrough decoration is not rendered" = "Unter- oder Durchstreichung von Text auf Pfad wird nicht dargestellt"
+"text style overrides refer to missing table entries" = "Textstil-Überschreibungen verweisen auf fehlende Tabelleneinträge"
+"the file has no pages" = "die Datei hat keine Seiten"
 "the plugin" = "das Plugin"
+"the variables JSON has no `variableCollections` (expected the local variables response) and was ignored" = "das Variablen-JSON enthält keine `variableCollections` (erwartet wurde die Antwort mit den lokalen Variablen) und wurde ignoriert"
 "this session only" = "nur diese Sitzung"
+"unknown component property types were skipped" = "unbekannte Komponenteneigenschaftstypen wurden übersprungen"
+"variable aliases to variables that aren't in the variables JSON (or of another type) were skipped" = "Variablen-Aliase auf Variablen, die nicht im Variablen-JSON sind (oder einen anderen Typ haben), wurden übersprungen"
+"variable bindings to properties the layer doesn't have were skipped" = "Variablenbindungen an Eigenschaften, die die Ebene nicht hat, wurden übersprungen"
+"variable bindings to variables that aren't in the variables JSON (library variables) were skipped" = "Variablenbindungen an Variablen, die nicht im Variablen-JSON sind (Bibliotheksvariablen), wurden übersprungen"
+"variable bindings were skipped: the file JSON has no variable definitions (pass the local variables JSON as `variables`, or embed its `meta` next to the file JSON)" = "Variablenbindungen wurden übersprungen: Das Datei-JSON enthält keine Variablendefinitionen (übergeben Sie das lokale Variablen-JSON als `variables` oder betten Sie dessen `meta` neben dem Datei-JSON ein)"
+"variable bindings whose variable type doesn't fit the property were skipped" = "Variablenbindungen, deren Variablentyp nicht zur Eigenschaft passt, wurden übersprungen"
+"variable collections without modes were skipped" = "Variablensammlungen ohne Modi wurden übersprungen"
+"variable mode lookups in prototype expressions that aren't a variable and one of its modes were skipped" = "Variablenmodus-Abfragen in Prototyp-Ausdrücken, die nicht aus einer Variable und einem ihrer Modi bestehen, wurden übersprungen"
+"variable modes of collections that aren't in the file were skipped" = "Variablenmodi von Sammlungen, die nicht in der Datei sind, wurden übersprungen"
+"variable modes of collections that aren't in the variables JSON were skipped" = "Variablenmodi von Sammlungen, die nicht im Variablen-JSON sind, wurden übersprungen"
+"variable values that don't match their type (or composed colours) were skipped" = "Variablenwerte, die nicht zu ihrem Typ passen (oder zusammengesetzte Farben), wurden übersprungen"
+"variables of unknown types were skipped" = "Variablen unbekannter Typen wurden übersprungen"
+"variables whose collection isn't in the variables JSON were skipped" = "Variablen, deren Sammlung nicht im Variablen-JSON ist, wurden übersprungen"
+"variables without readable values were skipped" = "Variablen ohne lesbare Werte wurden übersprungen"
+"vector points with unknown stroke joins use the layer join" = "Vektorpunkte mit unbekannten Konturecken verwenden die Ecke der Ebene"
+"vectors without geometry are empty" = "Vektoren ohne Geometrie sind leer"
+"vectors without geometry are empty (export the file JSON with geometry=paths)" = "Vektoren ohne Geometrie sind leer (exportieren Sie das Datei-JSON mit geometry=paths)"
+"very long text was cut to 1,048,576 characters" = "sehr langer Text wurde auf 1.048.576 Zeichen gekürzt"
+"very long vector paths were skipped" = "sehr lange Vektorpfade wurden übersprungen"
+"video actions are not supported and were skipped" = "Videoaktionen werden nicht unterstützt und wurden übersprungen"
+"video triggers are not supported and were skipped" = "Videoauslöser werden nicht unterstützt und wurden übersprungen"
 "{instances} in {files}" = "{instances} in {files}"
 "{language}: draft translation, waiting for a native speaker's review." = "{language}: Übersetzungsentwurf, wartet auf die Prüfung durch Muttersprachler."
 "{length} bleed" = "{length} Anschnitt"
@@ -1468,6 +1620,7 @@ status = "draft — needs native review"
 "{name} is forgotten on this computer; the file stays on {server}" = "{name} wurde auf diesem Computer vergessen; die Datei bleibt auf {server}"
 "{name} is on the server." = "{name} liegt auf dem Server."
 "{name} is spotlighting" = "{name} hat das Spotlight"
+"{name} is too large to open in the browser (over 512 MB)." = "{name} ist zu groß, um im Browser geöffnet zu werden (über 512 MB)."
 "{name} was removed from the server" = "{name} wurde vom Server entfernt"
 "{name} · deleted on main" = "{name} · in der Hauptdatei gelöscht"
 "{name} · deleted on the branch" = "{name} · im Branch gelöscht"
@@ -1496,6 +1649,7 @@ status = "draft — needs native review"
 "{n} matches" = { one = "{n} Treffer", other = "{n} Treffer" }
 "{n} minutes ago" = { one = "vor {n} Minute", other = "vor {n} Minuten" }
 "{n} months ago" = { one = "vor {n} Monat", other = "vor {n} Monaten" }
+"{n} more notes omitted from this report" = { one = "{n} weitere Notiz in diesem Bericht nicht aufgeführt", other = "{n} weitere Notizen in diesem Bericht nicht aufgeführt" }
 "{n} of {total}" = "{n} von {total}"
 "{n} people joined" = { one = "{n} Person ist beigetreten", other = "{n} Personen sind beigetreten" }
 "{n} preferred components" = { one = "{n} bevorzugte Komponente", other = "{n} bevorzugte Komponenten" }
@@ -1555,7 +1709,17 @@ status = "draft — needs native review"
 "arrange.packH" = "Horizontal zusammenschieben"
 "arrange.packV" = "Vertikal zusammenschieben"
 "arrange.roundToPixels" = "Auf Pixel runden"
+"arrange.spacing" = "Abstand"
 "arrange.tidy" = "Aufräumen"
+"board.connector" = "Verbinder"
+"board.ink" = "Markerstrich"
+"board.label" = "Verbinderbeschriftung"
+"board.nextSticky" = "Nächste Haftnotiz"
+"board.setColor" = "Whiteboard-Farbe"
+"board.setStyle" = "Whiteboard-Stil"
+"board.shape" = "Form mit Text"
+"board.stamp" = "Stempel"
+"board.sticky" = "Haftnotiz"
 "bool.exclude" = "Auswahl ausschließen"
 "bool.flatten" = "Boolesche Gruppe zusammenfügen"
 "bool.intersect" = "Schnittmenge der Auswahl"
@@ -1654,6 +1818,7 @@ status = "draft — needs native review"
 "edit.duplicate" = "Duplizieren"
 "edit.findReplace" = "Suchen und ersetzen"
 "edit.paste" = "Einfügen"
+"edit.pasteDesignLayers" = "Designebenen einfügen"
 "edit.pasteOver" = "Über Auswahl einfügen"
 "edit.pasteProperties" = "Eigenschaften einfügen"
 "edit.pasteReplace" = "Zum Ersetzen einfügen"
@@ -1677,7 +1842,9 @@ status = "draft — needs native review"
 "file.exportLayers" = "Ebenen exportieren"
 "file.exportSvg" = "Auswahl als SVG exportieren"
 "file.import" = "Importieren"
+"file.moveTab" = "Tab verschieben"
 "file.new" = "Neue Designdatei"
+"file.newBoard" = "Neues Whiteboard"
 "file.open" = "Öffnen"
 "file.openRecent" = "Zuletzt verwendete öffnen"
 "file.placeImage" = "Bild platzieren"
@@ -1814,6 +1981,7 @@ status = "draft — needs native review"
 "pref.reduceMotion" = "Bewegung reduzieren"
 "pref.renameDuplicates" = "Duplizierte Ebenen umbenennen"
 "pref.showDimensions" = "Abmessungen an Objekten anzeigen"
+"pref.startOnHome" = "Mit Start beginnen"
 "pref.userName" = "Ihr Name in Kommentaren"
 "proto.action.add" = "Prototyp-Aktion hinzufügen"
 "proto.action.move" = "Prototyp-Aktion neu anordnen"
@@ -1857,6 +2025,10 @@ status = "draft — needs native review"
 "select.sameStroke" = "Gleiche Kontur auswählen"
 "select.sameText" = "Gleiche Texteigenschaften auswählen"
 "select.set" = "Auswählen"
+"selection.applyColorStyle" = "Farbstil auf Auswahl anwenden"
+"selection.colors" = "Auswahlfarben"
+"selection.selectColor" = "Ebenen mit dieser Farbe auswählen"
+"selection.setPaint" = "Farbe der Auswahl ändern"
 "shape.arrow" = "Pfeil"
 "shape.ellipse" = "Ellipse"
 "shape.line" = "Linie"
@@ -1936,10 +2108,14 @@ status = "draft — needs native review"
 "text.weightUp" = "Schriftstärke erhöhen"
 "tool.arrow" = "Pfeil"
 "tool.comment" = "Kommentar"
+"tool.connector" = "Verbinder"
 "tool.ellipse" = "Ellipse"
+"tool.eraser" = "Radiergummi"
 "tool.frame" = "Rahmen"
 "tool.hand" = "Hand"
+"tool.highlighter" = "Textmarker"
 "tool.line" = "Linie"
+"tool.marker" = "Marker"
 "tool.move" = "Verschieben"
 "tool.pen" = "Zeichenstift"
 "tool.pencil" = "Bleistift"
@@ -1951,9 +2127,12 @@ status = "draft — needs native review"
 "tool.scaleAnchor" = "Skalierungsanker"
 "tool.section" = "Abschnitt"
 "tool.set" = "Werkzeug wählen"
+"tool.shape" = "Formen"
 "tool.shapeBuilder" = "Formerstellung"
 "tool.slice" = "Slice"
+"tool.stamp" = "Stempel"
 "tool.star" = "Stern"
+"tool.sticky" = "Haftnotiz"
 "tool.text" = "Text"
 "transform.move" = "Verschieben"
 "transform.moveTo" = "Verschieben nach"
@@ -2015,11 +2194,13 @@ status = "draft — needs native review"
 "vector.edit.tool" = "Vektorbearbeitungswerkzeug"
 "vector.edit.transform" = "Punkte transformieren"
 "vector.edit.widthPoint" = "Breitenpunkt"
+"vector.fillRule" = "Füllregel festlegen"
 "vector.flatten" = "Zusammenfügen"
 "vector.join" = "Auswahl verbinden"
 "vector.offset" = "Pfad versetzen"
 "vector.outlineStroke" = "Kontur in Pfad umwandeln"
 "vector.reverse" = "Pfadrichtung umkehren"
+"vector.reverseLoop" = "Schleife umdrehen"
 "vector.simplify" = "Vektor vereinfachen"
 "vector.smoothJoin" = "Auswahl glatt verbinden"
 "version.autosave" = "Version automatisch speichern"
diff --git a/crates/ui-egui/locales/en.toml b/crates/ui-egui/locales/en.toml
index 3c127fc65..83cfcbe19 100644
--- a/crates/ui-egui/locales/en.toml
+++ b/crates/ui-egui/locales/en.toml
@@ -16,6 +16,7 @@ name = "English"
 "1…9, 0" = "1…9, 0"
 "@{login}: {prs} PRs, {commits} commits, +{added} / −{deleted} lines (Δ {delta}), +{bin_added} / −{bin_deleted} binary assets, {first} – {last}" = "@{login}: {prs} PRs, {commits} commits, +{added} / −{deleted} lines (Δ {delta}), +{bin_added} / −{bin_deleted} binary assets, {first} – {last}"
 "A collection of this file with these modes and variables: override their values per mode and add variables of its own" = "A collection of this file with these modes and variables: override their values per mode and add variables of its own"
+"A .figcraft file with this name already exists. Choose its full name to confirm replacement." = "A .figcraft file with this name already exists. Choose its full name to confirm replacement."
 "A layer on its own aligns to its frame: select more layers, or one in a frame" = "A layer on its own aligns to its frame: select more layers, or one in a frame"
 "A responsive product page: hero, features, figures, a quote and a footer" = "A responsive product page: hero, features, figures, a quote and a footer"
 "A spring plays until it settles: its mass, stiffness and damping set how long" = "A spring plays until it settles: its mass, stiffness and damping set how long"
@@ -90,6 +91,7 @@ name = "English"
 "All components" = "All components"
 "All fonts" = "All fonts"
 "All supported properties" = "All supported properties"
+"All the fonts this file uses are installed" = "All the fonts this file uses are installed"
 "All variables" = "All variables"
 "Alpha" = "Alpha"
 "Alphabetical" = "Alphabetical"
@@ -123,6 +125,7 @@ name = "English"
 "Archived" = "Archived"
 "Arrange" = "Arrange"
 "Arrow" = "Arrow"
+"Arrow at the end" = "Arrow at the end"
 "As typed" = "As typed"
 "Asking the server…" = "Asking the server…"
 "Assets" = "Assets"
@@ -170,6 +173,7 @@ name = "English"
 "Both directions" = "Both directions"
 "Bottom" = "Bottom"
 "Bottom left radius" = "Bottom left radius"
+"Bottom padding" = "Bottom padding"
 "Bottom right radius" = "Bottom right radius"
 "Branch" = "Branch"
 "Branch archived" = "Branch archived"
@@ -196,11 +200,17 @@ name = "English"
 "C or ⇧C" = "C or ⇧C"
 "CMYK colour" = "CMYK colour"
 "Can view" = "Can view"
+"Check" = "Check"
+"Checking the fonts installed on this computer…" = "Checking the fonts installed on this computer…"
 "Checking the server…" = "Checking the server…"
+"Chevron" = "Chevron"
 "Clear from this list" = "Clear from this list"
 "Code or invite link" = "Code or invite link"
 "Color profile: {name}" = "Color profile: {name}"
 "Colour and text styles, Light and Dark variables, buttons, inputs and cards" = "Colour and text styles, Light and Dark variables, buttons, inputs and cards"
+"Connector" = "Connector"
+"Convert to frame" = "Convert to frame"
+"Convert to section" = "Convert to section"
 "CSS custom properties…" = "CSS custom properties…"
 "Can edit" = "Can edit"
 "Can't read this library: {e}" = "Can't read this library: {e}"
@@ -243,7 +253,6 @@ name = "English"
 "Close tab" = "Close tab"
 "Close version history" = "Close version history"
 "Close when clicking outside" = "Close when clicking outside"
-"Close without saving" = "Close without saving"
 "Code" = "Code"
 "Code syntax" = "Code syntax"
 "Collapse" = "Collapse"
@@ -270,6 +279,8 @@ name = "English"
 "Commits" = "Commits"
 "Company" = "Company"
 "Compare changes" = "Compare changes"
+"Compare with" = "Compare with"
+"Compatibility notes" = "Compatibility notes"
 "Completed" = "Completed"
 "Component" = "Component"
 "Component name" = "Component name"
@@ -313,6 +324,7 @@ name = "English"
 "Corner smoothing" = "Corner smoothing"
 "Couldn't download the variables" = "Couldn't download the variables"
 "Couldn't reach {server}: showing what this computer remembers." = "Couldn't reach {server}: showing what this computer remembers."
+"Couldn't read {name}." = "Couldn't read {name}."
 "Couldn't save automatically: {error}" = "Couldn't save automatically: {error}"
 "Count" = "Count"
 "Create" = "Create"
@@ -337,6 +349,7 @@ name = "English"
 "Current version" = "Current version"
 "Cursor chat" = "Cursor chat"
 "Custom" = "Custom"
+"Custom size" = "Custom size"
 "Cut" = "Cut"
 "Dark" = "Dark"
 "Darken" = "Darken"
@@ -370,6 +383,7 @@ name = "English"
 "Description" = "Description"
 "Description (optional)" = "Description (optional)"
 "Design" = "Design"
+"Design panel" = "Design panel"
 "Design system starter" = "Design system starter"
 "Desktop" = "Desktop"
 "Destination" = "Destination"
@@ -381,6 +395,7 @@ name = "English"
 "Detach variable" = "Detach variable"
 "Details" = "Details"
 "Dev Mode" = "Dev Mode"
+"Dev Mode only inspects: switch to Design (Shift+D) to edit" = "Dev Mode only inspects: switch to Design (Shift+D) to edit"
 "Dev resources" = "Dev resources"
 "Development" = "Development"
 "Device" = "Device"
@@ -397,6 +412,7 @@ name = "English"
 "Distribute horizontal spacing" = "Distribute horizontal spacing"
 "Distribute vertical spacing" = "Distribute vertical spacing"
 "Divider" = "Divider"
+"Don't Save" = "Don't Save"
 "Don't truncate" = "Don't truncate"
 "Done" = "Done"
 "Done editing" = "Done editing"
@@ -432,6 +448,7 @@ name = "English"
 "Effect settings" = "Effect settings"
 "Effect styles" = "Effect styles"
 "Effects" = "Effects"
+"Elbow" = "Elbow"
 "Ellipse" = "Ellipse"
 "Ellipses" = "Ellipses"
 "Else" = "Else"
@@ -482,6 +499,7 @@ name = "English"
 "Feb" = "Feb"
 "Fetching from the server…" = "Fetching from the server…"
 "FigCraft couldn't open its window: {error}" = "FigCraft couldn't open its window: {error}"
+"FigCraft doesn't support every feature of these files yet. The notes list what was left out or changed in the imported copy; the original file is unchanged." = "FigCraft doesn't support every feature of these files yet. The notes list what was left out or changed in the imported copy; the original file is unchanged."
 "File" = "File"
 "File name" = "File name"
 "File not found" = "File not found"
@@ -567,6 +585,7 @@ name = "English"
 "Hanging list" = "Hanging list"
 "Hanging punctuation" = "Hanging punctuation"
 "Hard light" = "Hard light"
+"Heart" = "Heart"
 "Height" = "Height"
 "Help" = "Help"
 "Help and resources" = "Help and resources"
@@ -579,6 +598,7 @@ name = "English"
 "Hide these tips (Getting started in the Help menu shows them again)" = "Hide these tips (Getting started in the Help menu shows them again)"
 "Hide when publishing" = "Hide when publishing"
 "Highlight layers on hover" = "Highlight layers on hover"
+"Highlighter" = "Highlighter"
 "Highlights" = "Highlights"
 "Hold Alt" = "Hold Alt"
 "Hold Alt+Z" = "Hold Alt+Z"
@@ -606,11 +626,14 @@ name = "English"
 "If {condition}" = "If {condition}"
 "Ignore auto layout (absolute position)" = "Ignore auto layout (absolute position)"
 "Image" = "Image"
+"Images" = "Images"
 "Import" = "Import"
 "Import path" = "Import path"
 "Import plugin from manifest" = "Import plugin from manifest"
 "Import plugin from manifest…" = "Import plugin from manifest…"
+"Import report" = "Import report"
 "Import variables" = "Import variables"
+"Imported document" = "Imported document"
 "Imported {name}" = "Imported {name}"
 "Imported {n} new variables, updated {updated}" = { one = "Imported {n} new variable, updated {updated}", other = "Imported {n} new variables, updated {updated}" }
 "Import…" = "Import…"
@@ -621,6 +644,7 @@ name = "English"
 "Included" = "Included"
 "Included in layout" = "Included in layout"
 "Individual corners" = "Individual corners"
+"Individual padding" = "Individual padding"
 "Individual strokes" = "Individual strokes"
 "Ink" = "Ink"
 "Inner shadow" = "Inner shadow"
@@ -638,11 +662,14 @@ name = "English"
 "Instance swap (no other component)" = "Instance swap (no other component)"
 "Instances" = "Instances"
 "Instant" = "Instant"
+"Intensity" = "Intensity"
 "Interaction" = "Interaction"
 "Interactions" = "Interactions"
 "Interface design and prototyping. A free, open-source, clean-room design tool written from scratch in Rust, part of the ArtCraft Crafting Apps." = "Interface design and prototyping. A free, open-source, clean-room design tool written from scratch in Rust, part of the ArtCraft Crafting Apps."
+"Interface size" = "Interface size"
 "Intersect" = "Intersect"
 "Intersects" = "Intersects"
+"Invalid color" = "Invalid color"
 "Invite link" = "Invite link"
 "Invite link copied" = "Invite link copied"
 "It asks permission to:" = "It asks permission to:"
@@ -689,6 +716,7 @@ name = "English"
 "Leaves" = "Leaves"
 "Left" = "Left"
 "Left & right" = "Left & right"
+"Left padding" = "Left padding"
 "Left side" = "Left side"
 "Left side width" = "Left side width"
 "Letter case" = "Letter case"
@@ -740,6 +768,7 @@ name = "English"
 "Mark as resolved" = "Mark as resolved"
 "Mark as unread" = "Mark as unread"
 "Mark as unresolved" = "Mark as unresolved"
+"Marker" = "Marker"
 "Mask" = "Mask"
 "Mass · Stiffness · Damping" = "Mass · Stiffness · Damping"
 "Match (empty: the whole name)" = "Match (empty: the whole name)"
@@ -761,6 +790,7 @@ name = "English"
 "Mirror angle and length" = "Mirror angle and length"
 "Mirroring" = "Mirroring"
 "Missing" = "Missing"
+"Missing fonts" = "Missing fonts"
 "Missing layer" = "Missing layer"
 "Missing style" = "Missing style"
 "Missing variable" = "Missing variable"
@@ -798,9 +828,11 @@ name = "English"
 "Named instance" = "Named instance"
 "Navigate to" = "Navigate to"
 "Nested instance" = "Nested instance"
+"New board" = "New board"
 "New design file" = "New design file"
 "Newest first" = "Newest first"
 "Next or previous control in the focused region" = "Next or previous control in the focused region"
+"Next frame" = "Next frame"
 "Next ready for dev" = "Next ready for dev"
 "Next size option" = "Next size option"
 "No assets: no export settings, icons or images. Add export settings in the Design tab." = "No assets: no export settings, icons or images. Add export settings in the Design tab."
@@ -809,13 +841,17 @@ name = "English"
 "No branches. A branch is a copy of the file to try changes in, then review and merge." = "No branches. A branch is a copy of the file to try changes in, then review and merge."
 "No category" = "No category"
 "No changes" = "No changes"
+"No color styles" = "No color styles"
 "No colour variables fit here." = "No colour variables fit here."
 "No colour variables yet. Create them in Local variables." = "No colour variables yet. Create them in Local variables."
 "No comments yet" = "No comments yet"
+"No compatibility warnings reported" = "No compatibility warnings reported"
 "No components yet. Select layers and press {keys}." = "No components yet. Select layers and press {keys}."
 "No conflicts." = "No conflicts."
 "No contributor data was built into this copy." = "No contributor data was built into this copy."
+"No device" = "No device"
 "No fonts match" = "No fonts match"
+"No files or templates match your search" = "No files or templates match your search"
 "No join code here (the server is older than join codes, or this address can't be put in one): share the link instead." = "No join code here (the server is older than join codes, or this address can't be put in one): share the link instead."
 "No layer changes to show." = "No layer changes to show."
 "No libraries yet. Add a .figcraft file that was published as a library, or paste a team library's link." = "No libraries yet. Add a .figcraft file that was published as a library, or paste a team library's link."
@@ -829,6 +865,7 @@ name = "English"
 "No model credits were built into this copy." = "No model credits were built into this copy."
 "No number variables fit here." = "No number variables fit here."
 "No number variables yet. Create them in Local variables." = "No number variables yet. Create them in Local variables."
+"No other pages" = "No other pages"
 "No paints" = "No paints"
 "No plugins on {server}." = "No plugins on {server}."
 "No plugins yet. Import a development plugin from its figcraft-plugin.json." = "No plugins yet. Import a development plugin from its figcraft-plugin.json."
@@ -858,6 +895,7 @@ name = "English"
 "Not read yet" = "Not read yet"
 "Not shared" = "Not shared"
 "Note {n}" = "Note {n}"
+"Nothing changed since this version." = "Nothing changed since this version."
 "Nothing changed since this was marked ready for dev." = "Nothing changed since this was marked ready for dev."
 "Nothing here yet. Set a frame's status to list it." = "Nothing here yet. Set a frame's status to list it."
 "Nothing online yet. Use Share on a file to put it online and it is listed here." = "Nothing online yet. Use Share on a file to put it online and it is listed here."
@@ -895,6 +933,7 @@ name = "English"
 "Open branch" = "Open branch"
 "Open file" = "Open file"
 "Open files" = "Open files"
+"Open presentations" = "Open presentations"
 "Open in focus view" = "Open in focus view"
 "Open in new window" = "Open in new window"
 "Open invite links in FigCraft" = "Open invite links in FigCraft"
@@ -903,6 +942,7 @@ name = "English"
 "Open overlay" = "Open overlay"
 "Open prototype preview" = "Open prototype preview"
 "Open variables ({count})" = "Open variables ({count})"
+"Opened as a new document" = "Opened as a new document"
 "Opened “{name}” in a new tab" = "Opened “{name}” in a new tab"
 "Opening the file…" = "Opening the file…"
 "Opening {n} files as new files" = { one = "Opening as a new file", other = "Opening {n} files as new files" }
@@ -911,6 +951,7 @@ name = "English"
 "Orange" = "Orange"
 "Order" = "Order"
 "Other apps may not open every .fig file exported here." = "Other apps may not open every .fig file exported here."
+"Other" = "Other"
 "Others lose access and keep their copy; the file stays on the server for you" = "Others lose access and keep their copy; the file stays on the server for you"
 "Others type this under Share ▸ Join with a code" = "Others type this under Share ▸ Join with a code"
 "Outline stroke" = "Outline stroke"
@@ -928,7 +969,11 @@ name = "English"
 "PDF print settings" = "PDF print settings"
 "Padding" = "Padding"
 "Page" = "Page"
+"Page deleted" = "Page deleted"
 "Pages" = "Pages"
+"Pages added to the document" = "Pages added to the document"
+"Pink" = "Pink"
+"Placed on the current page" = "Placed on the current page"
 "Pages: {pages}" = "Pages: {pages}"
 "Paint bucket" = "Paint bucket"
 "Pan the canvas" = "Pan the canvas"
@@ -943,6 +988,7 @@ name = "English"
 "Paste a team library link (a view link)" = "Paste a team library link (a view link)"
 "Paste here" = "Paste here"
 "Paste to replace" = "Paste to replace"
+"Pasted design layers; {n} kinds of content were left out" = { one = "Pasted design layers; {n} kind of content was left out", other = "Pasted design layers; {n} kinds of content were left out" }
 "Pattern" = "Pattern"
 "Pattern alignment" = "Pattern alignment"
 "Pattern scale" = "Pattern scale"
@@ -965,10 +1011,13 @@ name = "English"
 "Place a shape or frame (its tool chosen)" = "Place a shape or frame (its tool chosen)"
 "Place automatically" = "Place automatically"
 "Place image" = "Place image"
+"Plugin" = "Plugin"
 "Plugins run in FigCraft's sandbox, without files, network or clock. Install only plugins you trust." = "Plugins run in FigCraft's sandbox, without files, network or clock. Install only plugins you trust."
 "Plugins" = "Plugins"
+"Plugins & widgets" = "Plugins & widgets"
 "Plus darker" = "Plus darker"
 "Plus lighter" = "Plus lighter"
+"Plus one" = "Plus one"
 "Point" = "Point"
 "Points" = "Points"
 "Polygon" = "Polygon"
@@ -996,6 +1045,7 @@ name = "English"
 "Preview" = "Preview"
 "Preview this flow" = "Preview this flow"
 "Preview this frame" = "Preview this frame"
+"Previous frame" = "Previous frame"
 "Previous ready for dev" = "Previous ready for dev"
 "Progressive" = "Progressive"
 "Properties" = "Properties"
@@ -1016,6 +1066,7 @@ name = "English"
 "Push" = "Push"
 "Push changes to main component" = "Push changes to main component"
 "Put text on path" = "Put text on path"
+"Question" = "Question"
 "R" = "R"
 "Radial" = "Radial"
 "Radius" = "Radius"
@@ -1033,6 +1084,7 @@ name = "English"
 "Reduce motion" = "Reduce motion"
 "Refraction" = "Refraction"
 "Regular expression" = "Regular expression"
+"Relative to your system's display scaling (100% is the system's own size). Document zoom is separate." = "Relative to your system's display scaling (100% is the system's own size). Document zoom is separate."
 "Remove" = "Remove"
 "Remove all" = "Remove all"
 "Remove annotation" = "Remove annotation"
@@ -1061,6 +1113,7 @@ name = "English"
 "Removed" = "Removed"
 "Removed from the server" = "Removed from the server"
 "Removed since it was marked" = "Removed since it was marked"
+"Removed since this version" = "Removed since this version"
 "Rename" = "Rename"
 "Rename duplicated layers" = "Rename duplicated layers"
 "Rename folder" = "Rename folder"
@@ -1071,6 +1124,7 @@ name = "English"
 "Rename on the server…" = "Rename on the server…"
 "Rename page" = "Rename page"
 "Rename to" = "Rename to"
+"Reorder selection" = "Reorder selection"
 "Replace all" = "Replace all"
 "Replace mixed export settings" = "Replace mixed export settings"
 "Replace with" = "Replace with"
@@ -1090,6 +1144,7 @@ name = "English"
 "Resize by the nudge amount" = "Resize by the nudge amount"
 "Resize frames to the device's screen (or the window without a device): their constraints and auto layout respond" = "Resize frames to the device's screen (or the window without a device): their constraints and auto layout respond"
 "Resize to fit" = "Resize to fit"
+"Resizing" = "Resizing"
 "Resolve" = "Resolve"
 "Resolve change" = "Resolve change"
 "Resolved" = "Resolved"
@@ -1105,6 +1160,7 @@ name = "English"
 "Review and merge" = "Review and merge"
 "Ribbon" = "Ribbon"
 "Right" = "Right"
+"Right padding" = "Right padding"
 "Right side" = "Right side"
 "Right side width" = "Right side width"
 "Rotate 90°" = "Rotate 90°"
@@ -1115,6 +1171,7 @@ name = "English"
 "Rotation jitter" = "Rotation jitter"
 "Round" = "Round"
 "Rounded" = "Rounded"
+"Rounded rectangle" = "Rounded rectangle"
 "Row" = "Row"
 "Row gap" = "Row gap"
 "Row sizes" = "Row sizes"
@@ -1151,8 +1208,11 @@ name = "English"
 "Search actions, layers and tools" = "Search actions, layers and tools"
 "Search assets" = "Search assets"
 "Search comments" = "Search comments"
+"Search files and templates" = "Search files and templates"
+"Search results" = "Search results"
 "Search fonts" = "Search fonts"
 "Search layers" = "Search layers"
+"Search pages" = "Search pages"
 "Search shortcuts" = "Search shortcuts"
 "Section" = "Section"
 "Section color" = "Section color"
@@ -1164,9 +1224,11 @@ name = "English"
 "Select all with same" = "Select all with same"
 "Select layer" = "Select layer"
 "Select layers to apply the style to" = "Select layers to apply the style to"
+"Select layers with this color" = "Select layers with this color"
 "Select overlapping shapes" = "Select overlapping shapes"
 "Select points to edit their position, radius and mirroring" = "Select points to edit their position, radius and mirroring"
 "Select slot" = "Select slot"
+"Selection colors" = "Selection colors"
 "Selection" = "Selection"
 "Selection box, {w} by {h} at {x}, {y}: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "Selection box, {w} by {h} at {x}, {y}: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels"
 "Selection box: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "Selection box: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels"
@@ -1186,6 +1248,7 @@ name = "English"
 "Shape" = "Shape"
 "Shape builder" = "Shape builder"
 "Shape tools" = "Shape tools"
+"Shapes" = "Shapes"
 "Share" = "Share"
 "Share this file" = "Share this file"
 "Share with a code" = "Share with a code"
@@ -1252,10 +1315,13 @@ name = "English"
 "Space+drag" = "Space+drag"
 "Spacing" = "Spacing"
 "Spam, stolen work, abuse…" = "Spam, stolen work, abuse…"
+"Speech bubble" = "Speech bubble"
 "Splay" = "Splay"
 "Spotlight me" = "Spotlight me"
 "Spread" = "Spread"
 "Square" = "Square"
+"Stamp" = "Stamp"
+"Stamps" = "Stamps"
 "Standard" = "Standard"
 "Standard ligatures" = "Standard ligatures"
 "Star" = "Star"
@@ -1265,18 +1331,23 @@ name = "English"
 "Start from a blank canvas" = "Start from a blank canvas"
 "Start from a template" = "Start from a template"
 "Start on path" = "Start on path"
+"Start on the Home screen" = "Start on the Home screen"
 "Start point" = "Start point"
 "Start sharing" = "Start sharing"
 "Start sharing with the Share button, then pass on the code it gives" = "Start sharing with the Share button, then pass on the code it gives"
 "Starting to share…" = "Starting to share…"
 "Status" = "Status"
 "Sticky" = "Sticky"
+"Sticky note" = "Sticky note"
+"Sticky note colors" = "Sticky note colors"
+"Sticky notes, shapes and connectors" = "Sticky notes, shapes and connectors"
 "Stop" = "Stop"
 "Stop following {name}" = "Stop following {name}"
 "Stop session" = "Stop session"
 "Stop sharing" = "Stop sharing"
 "Stop spotlighting" = "Stop spotlighting"
 "Stop {n}  {hex}" = "Stop {n}  {hex}"
+"Straight" = "Straight"
 "Stretch" = "Stretch"
 "Strikethrough" = "Strikethrough"
 "String" = "String"
@@ -1321,6 +1392,7 @@ name = "English"
 "Text" = "Text"
 "Text align" = "Text align"
 "Text content" = "Text content"
+"Text size" = "Text size"
 "Text style" = "Text style"
 "Text styles" = "Text styles"
 "Texts" = "Texts"
@@ -1338,6 +1410,7 @@ name = "English"
 "The selection uses several text styles: click to apply one" = "The selection uses several text styles: click to apply one"
 "The server deletes this file if nobody opens it before {date}." = "The server deletes this file if nobody opens it before {date}."
 "The whole file" = "The whole file"
+"The window is too small for {size}%, so the interface is drawn at {drawn}%. Make the window larger to use {size}%." = "The window is too small for {size}%, so the interface is drawn at {drawn}%. Make the window larger to use {size}%."
 "Theme" = "Theme"
 "There's no destination for that action" = "There's no destination for that action"
 "Thickness" = "Thickness"
@@ -1348,12 +1421,17 @@ name = "English"
 "This condition is edited as an expression" = "This condition is edited as an expression"
 "This file" = "This file"
 "This file has unsaved changes" = "This file has unsaved changes"
+"This file is too large to join here (up to {mb} MB)" = "This file is too large to join here (up to {mb} MB)"
+"This file uses fonts that aren't installed on this computer. Their text is drawn in a fallback font until you install them." = "This file uses fonts that aren't installed on this computer. Their text is drawn in a fallback font until you install them."
 "This file is on {server}, open only to you. Share it to let others in with a new code." = "This file is on {server}, open only to you. Share it to let others in with a new code."
 "This frame is new on the branch." = "This frame is new on the branch."
 "This frame isn't on the branch." = "This frame isn't on the branch."
 "This server is open to the public: no key needed." = "This server is open to the public: no key needed."
 "This server needs its key: add ?key=… to the address (`figcraft-server key` prints it on the server's machine)." = "This server needs its key: add ?key=… to the address (`figcraft-server key` prints it on the server's machine)."
 "This server takes files only with its key: see Advanced." = "This server takes files only with its key: see Advanced."
+"Thumbs up" = "Thumbs up"
+"This version can't be read." = "This version can't be read."
+"This version doesn't have it: all of it is new." = "This version doesn't have it: all of it is new."
 "Tidy up" = "Tidy up"
 "Tile" = "Tile"
 "Tile type" = "Tile type"
@@ -1368,8 +1446,10 @@ name = "English"
 "Top" = "Top"
 "Top & bottom" = "Top & bottom"
 "Top left radius" = "Top left radius"
+"Top padding" = "Top padding"
 "Top right radius" = "Top right radius"
 "Transform" = "Transform"
+"Triangle" = "Triangle"
 "Triangle arrow" = "Triangle arrow"
 "Trigger" = "Trigger"
 "True" = "True"
@@ -1377,6 +1457,7 @@ name = "English"
 "Truncate with an ellipsis" = "Truncate with an ellipsis"
 "Try again" = "Try again"
 "Try another search or filter." = "Try another search or filter."
+"Try another search, or browse templates." = "Try another search, or browse templates."
 "Try another word, or look at every kind." = "Try another word, or look at every kind."
 "Turn a layer into a component, reuse it, and change every copy at once" = "Turn a layer into a component, reuse it, and change every copy at once"
 "Two digits" = "Two digits"
@@ -1394,7 +1475,7 @@ name = "English"
 "Unread" = "Unread"
 "Unresolve" = "Unresolve"
 "Unsaved changes" = "Unsaved changes"
-"Unsaved changes in {names}. Close the window and lose them?" = "Unsaved changes in {names}. Close the window and lose them?"
+"Unsaved changes in {names}. Save them before closing?" = "Unsaved changes in {names}. Save them before closing?"
 "Unsaved changes: save first ({save}), or close the tab with {alt}-click to discard" = "Unsaved changes: save first ({save}), or close the tab with {alt}-click to discard"
 "Unsaved changes: save first, or close again with {key} to discard" = "Unsaved changes: save first, or close again with {key} to discard"
 "Up" = "Up"
@@ -1413,7 +1494,9 @@ name = "English"
 "Use as mask" = "Use as mask"
 "Use auto layout" = "Use auto layout"
 "Use number keys for opacity" = "Use number keys for opacity"
+"Use the .figcraft or .fig extension." = "Use the .figcraft or .fig extension."
 "Use the layer's fill" = "Use the layer's fill"
+"Use your browser's zoom to change the interface size." = "Use your browser's zoom to change the interface size."
 "Used in {files} · {instances}" = "Used in {files} · {instances}"
 "Username" = "Username"
 "Value" = "Value"
@@ -1458,16 +1541,19 @@ name = "English"
 "WebSocket URL copied" = "WebSocket URL copied"
 "Wedge" = "Wedge"
 "Weight" = "Weight"
+"What changed since a saved version" = "What changed since a saved version"
 "What you try here changes this preview and the code below, not the file" = "What you try here changes this preview and the code below, not the file"
 "What changed since it was marked ready for dev" = "What changed since it was marked ready for dev"
 "What is wrong with this file? The server's operator gets your report." = "What is wrong with this file? The server's operator gets your report."
 "What it's for" = "What it's for"
 "What this changed from isn't known: it changed before FigCraft kept a copy of ready-for-dev frames. Resolve the change (or mark it ready again) to compare from now on." = "What this changed from isn't known: it changed before FigCraft kept a copy of ready-for-dev frames. Resolve the change (or mark it ready again) to compare from now on."
+"When marked ready" = "When marked ready"
 "While hovering" = "While hovering"
 "While pressing" = "While pressing"
 "White" = "White"
 "Who runs it, its terms and how long it keeps files" = "Who runs it, its terms and how long it keeps files"
 "Why it changed" = "Why it changed"
+"Widget" = "Widget"
 "Widgets" = "Widgets"
 "Width" = "Width"
 "Width point" = "Width point"
@@ -1506,26 +1592,121 @@ name = "English"
 "call any command its access allows" = "call any command its access allows"
 "call only: {commands}" = "call only: {commands}"
 "can edit the document" = "can edit the document"
+"conditional prototype actions nested too deeply were skipped" = "conditional prototype actions nested too deeply were skipped"
+"conditional prototype actions with conditions that can't be evaluated were skipped" = "conditional prototype actions with conditions that can't be evaluated were skipped"
+"connector label background was skipped: style data is missing" = "connector label background was skipped: style data is missing"
+"connector label was skipped: background bounds are invalid" = "connector label was skipped: background bounds are invalid"
+"connector label was skipped: background transform is invalid" = "connector label was skipped: background transform is invalid"
+"connector label was skipped: composed text transform is invalid" = "connector label was skipped: composed text transform is invalid"
+"connector label was skipped: derived background bounds are missing" = "connector label was skipped: derived background bounds are missing"
+"connector label was skipped: derived text bounds are missing" = "connector label was skipped: derived text bounds are missing"
+"connector label was skipped: text bounds are invalid" = "connector label was skipped: text bounds are invalid"
+"connector label was skipped: text style data is missing" = "connector label was skipped: text style data is missing"
+"connector label was skipped: text transform is invalid" = "connector label was skipped: text transform is invalid"
+"connector labels were skipped" = "connector labels were skipped"
+"connector layers import as static frame/vector snapshots with labels when present; live endpoint bindings are not retained" = "connector layers import as static frame/vector snapshots with labels when present; live endpoint bindings are not retained"
+"connector snapshot vector data is missing; connector was left empty" = "connector snapshot vector data is missing; connector was left empty"
+"connectors whose ends can't be placed are empty" = "connectors whose ends can't be placed are empty"
 "crop marks" = "crop marks"
+"damaged vector geometry was skipped" = "damaged vector geometry was skipped"
+"damaged vector networks import as outlines" = "damaged vector networks import as outlines"
 "development: {path}" = "development: {path}"
+"document children other than pages were skipped" = "document children other than pages were skipped"
+"duplicate grid track sizing entries use equal tracks" = "duplicate grid track sizing entries use equal tracks"
 "e.g. count + 1" = "e.g. count + 1"
 "e.g. count >= 3 and not done" = "e.g. count >= 3 and not done"
+"elbowed and curved connectors without a saved path import as straight lines" = "elbowed and curved connectors without a saved path import as straight lines"
+"entries without a node type were skipped" = "entries without a node type were skipped"
 "figcraft:// links from a browser, chat or email open this app and join the session." = "figcraft:// links from a browser, chat or email open this app and join the session."
+"filled areas of a vector with their own fill use the layer's fill" = "filled areas of a vector with their own fill use the layer's fill"
 "from {server}" = "from {server}"
+"gamepad triggers without exactly one known controller button were skipped" = "gamepad triggers without exactly one known controller button were skipped"
+"grid track list exceeds 1000 entries; the tracks use the default equal sizing" = "grid track list exceeds 1000 entries; the tracks use the default equal sizing"
+"grid track sizing is unsupported or malformed; affected tracks use equal sizing" = "grid track sizing is unsupported or malformed; affected tracks use equal sizing"
+"grid track sizing list exceeds 1000 entries; the tracks use the default equal sizing" = "grid track sizing list exceeds 1000 entries; the tracks use the default equal sizing"
 "hidden" = "hidden"
 "iOS" = "iOS"
+"image filters are ambiguous because both filter containers are present; filter conversion was skipped" = "image filters are ambiguous because both filter containers are present; filter conversion was skipped"
+"image filters use FigCraft's approximate renderer" = "image filters use FigCraft's approximate renderer"
+"instance swap properties whose default component isn't in the file were skipped" = "instance swap properties whose default component isn't in the file were skipped"
+"instances inside their own main component were imported as frames" = "instances inside their own main component were imported as frames"
+"instances of components that aren't in the file show no layers" = "instances of components that aren't in the file show no layers"
+"instances of components that aren't in the file were imported as frames" = "instances of components that aren't in the file were imported as frames"
+"instances that would nest a component inside itself were imported as frames" = "instances that would nest a component inside itself were imported as frames"
+"instances without a main component were imported as empty frames" = "instances without a main component were imported as empty frames"
+"invalid internal .fig text path data was ignored" = "invalid internal .fig text path data was ignored"
+"invalid or oversized vector networks import as outlines" = "invalid or oversized vector networks import as outlines"
+"invalid or oversized vector path data was skipped" = "invalid or oversized vector path data was skipped"
 "just now" = "just now"
+"key triggers without a supported key were skipped" = "key triggers without a supported key were skipped"
+"key up triggers import as key presses" = "key up triggers import as key presses"
+"layers without a position were placed at their parent's origin" = "layers without a position were placed at their parent's origin"
+"layers without a type were skipped" = "layers without a type were skipped"
+"legacy image filter container is unsupported; filter conversion was skipped" = "legacy image filter container is unsupported; filter conversion was skipped"
 "locked" = "locked"
+"malformed image filters container was skipped" = "malformed image filters container was skipped"
+"malformed image paintFilter container was skipped" = "malformed image paintFilter container was skipped"
+"malformed slot content assignment was skipped" = "malformed slot content assignment was skipped"
 "no bleed" = "no bleed"
 "nobody else here yet" = "nobody else here yet"
+"non-default slot settings are not represented and were skipped" = "non-default slot settings are not represented and were skipped"
 "now" = "now"
+"only in a text style or variable" = "only in a text style or variable"
 "or" = "or"
+"point stroke joins were preserved; dashed or variable-width strokes render with the layer join" = "point stroke joins were preserved; dashed or variable-width strokes render with the layer join"
+"preferred slot component keys cannot be resolved to file nodes and were skipped" = "preferred slot component keys cannot be resolved to file nodes and were skipped"
+"prototype actions of unknown types were skipped" = "prototype actions of unknown types were skipped"
+"prototype actions without a destination in the file were skipped" = "prototype actions without a destination in the file were skipped"
+"prototype expressions on variables that aren't in the variables JSON were skipped" = "prototype expressions on variables that aren't in the variables JSON were skipped"
+"prototype expressions with unsupported functions were skipped" = "prototype expressions with unsupported functions were skipped"
+"prototype interactions without supported actions were skipped" = "prototype interactions without supported actions were skipped"
+"prototype navigations of unknown types were skipped" = "prototype navigations of unknown types were skipped"
+"prototype transitions of unknown types play instantly" = "prototype transitions of unknown types play instantly"
+"prototype triggers of unknown types were skipped" = "prototype triggers of unknown types were skipped"
 "put a widget on the canvas" = "put a widget on the canvas"
 "read and edit the document" = "read and edit the document"
 "read the document" = "read the document"
 "reads the document" = "reads the document"
+"set-variable actions on variables that aren't in the variables JSON were skipped" = "set-variable actions on variables that aren't in the variables JSON were skipped"
+"set-variable actions with values that can't be evaluated were skipped" = "set-variable actions with values that can't be evaluated were skipped"
+"set-variable actions with values that don't fit the variable were skipped" = "set-variable actions with values that don't fit the variable were skipped"
+"set-variable actions without a value were skipped" = "set-variable actions without a value were skipped"
+"set-variable-mode actions on collections or modes that aren't in the variables JSON were skipped" = "set-variable-mode actions on collections or modes that aren't in the variables JSON were skipped"
+"slot content assignment target is missing or is not slot content" = "slot content assignment target is missing or is not slot content"
+"slot content assignment uses the empty GUID sentinel and was skipped" = "slot content assignment uses the empty GUID sentinel and was skipped"
+"slot layers without a matching slot property were imported as frames" = "slot layers without a matching slot property were imported as frames"
+"some vector points refer to point settings missing from the file; they use the layer's joins and plain corners" = "some vector points refer to point settings missing from the file; they use the layer's joins and plain corners"
+"some vector segments refer to style settings missing from the file; they use the layer's stroke" = "some vector segments refer to style settings missing from the file; they use the layer's stroke"
+"stale or invalid grid track sizing entries were ignored" = "stale or invalid grid track sizing entries were ignored"
+"stars and polygons without point counts or geometry use the default point count" = "stars and polygons without point counts or geometry use the default point count"
+"style settings of some vector segments aren't supported; those segments use the layer's stroke" = "style settings of some vector segments aren't supported; those segments use the layer's stroke"
+"text path underline or strikethrough decoration is not rendered" = "text path underline or strikethrough decoration is not rendered"
+"text style overrides refer to missing table entries" = "text style overrides refer to missing table entries"
+"the file has no pages" = "the file has no pages"
 "the plugin" = "the plugin"
+"the variables JSON has no `variableCollections` (expected the local variables response) and was ignored" = "the variables JSON has no `variableCollections` (expected the local variables response) and was ignored"
 "this session only" = "this session only"
+"unknown component property types were skipped" = "unknown component property types were skipped"
+"variable aliases to variables that aren't in the variables JSON (or of another type) were skipped" = "variable aliases to variables that aren't in the variables JSON (or of another type) were skipped"
+"variable bindings to properties the layer doesn't have were skipped" = "variable bindings to properties the layer doesn't have were skipped"
+"variable bindings to variables that aren't in the variables JSON (library variables) were skipped" = "variable bindings to variables that aren't in the variables JSON (library variables) were skipped"
+"variable bindings were skipped: the file JSON has no variable definitions (pass the local variables JSON as `variables`, or embed its `meta` next to the file JSON)" = "variable bindings were skipped: the file JSON has no variable definitions (pass the local variables JSON as `variables`, or embed its `meta` next to the file JSON)"
+"variable bindings whose variable type doesn't fit the property were skipped" = "variable bindings whose variable type doesn't fit the property were skipped"
+"variable collections without modes were skipped" = "variable collections without modes were skipped"
+"variable mode lookups in prototype expressions that aren't a variable and one of its modes were skipped" = "variable mode lookups in prototype expressions that aren't a variable and one of its modes were skipped"
+"variable modes of collections that aren't in the file were skipped" = "variable modes of collections that aren't in the file were skipped"
+"variable modes of collections that aren't in the variables JSON were skipped" = "variable modes of collections that aren't in the variables JSON were skipped"
+"variable values that don't match their type (or composed colours) were skipped" = "variable values that don't match their type (or composed colours) were skipped"
+"variables of unknown types were skipped" = "variables of unknown types were skipped"
+"variables whose collection isn't in the variables JSON were skipped" = "variables whose collection isn't in the variables JSON were skipped"
+"variables without readable values were skipped" = "variables without readable values were skipped"
+"vector points with unknown stroke joins use the layer join" = "vector points with unknown stroke joins use the layer join"
+"vectors without geometry are empty" = "vectors without geometry are empty"
+"vectors without geometry are empty (export the file JSON with geometry=paths)" = "vectors without geometry are empty (export the file JSON with geometry=paths)"
+"very long text was cut to 1,048,576 characters" = "very long text was cut to 1,048,576 characters"
+"very long vector paths were skipped" = "very long vector paths were skipped"
+"video actions are not supported and were skipped" = "video actions are not supported and were skipped"
+"video triggers are not supported and were skipped" = "video triggers are not supported and were skipped"
 "yesterday" = "yesterday"
 "{instances} in {files}" = "{instances} in {files}"
 "{language}: draft translation, waiting for a native speaker's review." = "{language}: draft translation, waiting for a native speaker's review."
@@ -1535,6 +1716,7 @@ name = "English"
 "{name} is forgotten on this computer; the file stays on {server}" = "{name} is forgotten on this computer; the file stays on {server}"
 "{name} is on the server." = "{name} is on the server."
 "{name} is spotlighting" = "{name} is spotlighting"
+"{name} is too large to open in the browser (over 512 MB)." = "{name} is too large to open in the browser (over 512 MB)."
 "{name}\nClick to apply to the selection" = "{name}\nClick to apply to the selection"
 "{name}\nDrag onto the canvas, or click to place in the middle of the view.\nHold Alt (Option) while dropping onto an instance to swap it." = "{name}\nDrag onto the canvas, or click to place in the middle of the view.\nHold Alt (Option) while dropping onto an instance to swap it."
 "{name} (from {library})" = "{name} (from {library})"
@@ -1570,6 +1752,7 @@ name = "English"
 "{n} matches" = { one = "{n} match", other = "{n} matches" }
 "{n} minutes ago" = { one = "{n} minute ago", other = "{n} minutes ago" }
 "{n} months ago" = { one = "{n} month ago", other = "{n} months ago" }
+"{n} more notes omitted from this report" = { one = "{n} more note omitted from this report", other = "{n} more notes omitted from this report" }
 "{n} of {total}" = "{n} of {total}"
 "{n} people joined" = { one = "{n} person joined", other = "{n} people joined" }
 "{n} preferred components" = { one = "{n} preferred component", other = "{n} preferred components" }
@@ -1578,6 +1761,7 @@ name = "English"
 "{n} replies" = { one = "{n} reply", other = "{n} replies" }
 "{n} rows" = { one = "{n} row", other = "{n} rows" }
 "{n} styles" = { one = "{n} style", other = "{n} styles" }
+"{n} text layers" = { one = "{n} text layer", other = "{n} text layers" }
 "{n} variables" = { one = "{n} variable", other = "{n} variables" }
 "{n} weeks ago" = { one = "{n} week ago", other = "{n} weeks ago" }
 "{n} years ago" = { one = "{n} year ago", other = "{n} years ago" }
@@ -1586,6 +1770,7 @@ name = "English"
 "{n}m" = "{n}m"
 "{n}w" = "{n}w"
 "{page}, nothing selected" = "{page}, nothing selected"
+"{percent}%" = "{percent}%"
 "{profile} (current)" = "{profile} (current)"
 "{property} is its value; {property ? \"a\" : \"b\"} picks a string. Other {…} stays as written." = "{property} is its value; {property ? \"a\" : \"b\"} picks a string. Other {…} stays as written."
 "{server} can't say what became of your files (it is older than this app)." = "{server} can't say what became of your files (it is older than this app)."
@@ -1603,4 +1788,4 @@ name = "English"
 "⌘ arrows" = "⌘ arrows"
 "⌘ click" = "⌘ click"
 "⌘ scroll" = "⌘ scroll"
-"⌥ drag" = "⌥ drag"
\ No newline at end of file
+"⌥ drag" = "⌥ drag"
diff --git a/crates/ui-egui/locales/es-419.toml b/crates/ui-egui/locales/es-419.toml
index 6b42ac209..7756fba74 100644
--- a/crates/ui-egui/locales/es-419.toml
+++ b/crates/ui-egui/locales/es-419.toml
@@ -66,6 +66,7 @@ status = "draft — needs native review"
 "No components yet. Select layers and press {keys}." = "Aún no hay componentes. Selecciona capas y presiona {keys}."
 "No libraries yet. Add a .figcraft file that was published as a library, or paste a team library's link." = "Aún no hay bibliotecas. Agrega un archivo .figcraft publicado como biblioteca o pega el enlace de una biblioteca de equipo."
 "PDF print settings" = "Configuración de impresión PDF"
+"Pages added to the document" = "Páginas agregadas al documento"
 "Press a key…" = "Presiona una tecla…"
 "Prototype settings" = "Configuración del prototipo"
 "Remove export setting" = "Quitar configuración de exportación"
@@ -80,6 +81,11 @@ status = "draft — needs native review"
 "Type settings" = "Configuración de texto"
 "With the layers' export settings" = "Con la configuración de exportación de las capas"
 "You'll get the shared file as a new tab and edit it together." = "Recibirás el archivo compartido en una pestaña nueva y lo editarán en conjunto."
+"gamepad triggers without exactly one known controller button were skipped" = "se omitieron los desencadenantes de control sin exactamente un botón de control conocido"
+"key up triggers import as key presses" = "los desencadenantes al soltar una tecla se importan como presiones de tecla"
+"non-default slot settings are not represented and were skipped" = "la configuración de ranura no predeterminada no se representa y se omitió"
+"some vector segments refer to style settings missing from the file; they use the layer's stroke" = "algunos segmentos vectoriales hacen referencia a configuraciones de estilo que faltan en el archivo; usan el trazo de la capa"
+"style settings of some vector segments aren't supported; those segments use the layer's stroke" = "la configuración de estilo de algunos segmentos vectoriales no es compatible; esos segmentos usan el trazo de la capa"
 "{name} is forgotten on this computer; the file stays on {server}" = "{name} se olvidó en esta computadora; el archivo se queda en {server}"
 "{n} added" = { one = "{n} agregada", other = "{n} agregadas" }
 
diff --git a/crates/ui-egui/locales/es.toml b/crates/ui-egui/locales/es.toml
index 901283f11..e172584ce 100644
--- a/crates/ui-egui/locales/es.toml
+++ b/crates/ui-egui/locales/es.toml
@@ -8,6 +8,11 @@ name = "Español"
 status = "draft — needs native review"
 
 [ui]
+"Arrow at the end" = "Flecha al final"
+"Check" = "Visto"
+"Chevron" = "Cheurón"
+"Compatibility notes" = "Notas de compatibilidad"
+"Connector" = "Conector"
 "Couldn't download the variables" = "No se pudieron descargar las variables"
 
 "% of all commits" = "% del total de commits"
@@ -18,6 +23,7 @@ status = "draft — needs native review"
 "1…9, 0" = "1…9, 0"
 "@{login}: {prs} PRs, {commits} commits, +{added} / −{deleted} lines (Δ {delta}), +{bin_added} / −{bin_deleted} binary assets, {first} – {last}" = "@{login}: {prs} PR, {commits} commits, +{added} / −{deleted} líneas (Δ {delta}), +{bin_added} / −{bin_deleted} recursos binarios, {first} – {last}"
 "A collection of this file with these modes and variables: override their values per mode and add variables of its own" = "Una colección de este archivo con estos modos y variables: modifica sus valores por modo y añade variables propias"
+"A .figcraft file with this name already exists. Choose its full name to confirm replacement." = "Ya existe un archivo .figcraft con este nombre. Elige su nombre completo para confirmar que deseas reemplazarlo."
 "A layer on its own aligns to its frame: select more layers, or one in a frame" = "Una capa sola se alinea con su marco: selecciona más capas o una dentro de un marco"
 "A responsive product page: hero, features, figures, a quote and a footer" = "Una página de producto adaptable: cabecera, funciones, cifras, una cita y un pie"
 "A spring plays until it settles: its mass, stiffness and damping set how long" = "Un muelle se reproduce hasta que se asienta: su masa, rigidez y amortiguación fijan cuánto dura"
@@ -91,6 +97,7 @@ status = "draft — needs native review"
 "All comments" = "Todos los comentarios"
 "All components" = "Todos los componentes"
 "All fonts" = "Todas las fuentes"
+"All the fonts this file uses are installed" = "Todas las fuentes que usa este archivo están instaladas"
 "All supported properties" = "Todas las propiedades compatibles"
 "All variables" = "Todas las variables"
 "Alpha" = "Alfa"
@@ -172,6 +179,7 @@ status = "draft — needs native review"
 "Both directions" = "Ambas direcciones"
 "Bottom" = "Abajo"
 "Bottom left radius" = "Radio inferior izquierdo"
+"Bottom padding" = "Margen interno inferior"
 "Bottom right radius" = "Radio inferior derecho"
 "Branch" = "Rama"
 "Branch archived" = "Rama archivada"
@@ -198,6 +206,7 @@ status = "draft — needs native review"
 "C or ⇧C" = "C o ⇧C"
 "CMYK colour" = "Color CMYK"
 "Can view" = "Puede ver"
+"Checking the fonts installed on this computer…" = "Comprobando las fuentes instaladas en este equipo…"
 "Checking the server…" = "Comprobando el servidor…"
 "Clear from this list" = "Borrar de esta lista"
 "Code or invite link" = "Código o enlace de invitación"
@@ -245,7 +254,6 @@ status = "draft — needs native review"
 "Close tab" = "Cerrar pestaña"
 "Close version history" = "Cerrar historial de versiones"
 "Close when clicking outside" = "Cerrar al hacer clic fuera"
-"Close without saving" = "Cerrar sin guardar"
 "Code" = "Código"
 "Code syntax" = "Sintaxis de código"
 "Collapse" = "Contraer"
@@ -272,6 +280,7 @@ status = "draft — needs native review"
 "Commits" = "Commits"
 "Company" = "Empresa"
 "Compare changes" = "Comparar cambios"
+"Compare with" = "Comparar con"
 "Completed" = "Completado"
 "Component" = "Componente"
 "Component name" = "Nombre del componente"
@@ -302,6 +311,8 @@ status = "draft — needs native review"
 "Copied as SVG" = "Copiado como SVG"
 "Copied as text" = "Copiado como texto"
 "Copied {value}" = "Copiado: {value}"
+"Convert to frame" = "Convertir en marco"
+"Convert to section" = "Convertir en sección"
 "Copy" = "Copiar"
 "Copy as" = "Copiar como"
 "Copy as CSS" = "Copiar como CSS"
@@ -314,6 +325,7 @@ status = "draft — needs native review"
 "Corner radius" = "Radio de esquina"
 "Corner smoothing" = "Suavizado de esquinas"
 "Couldn't reach {server}: showing what this computer remembers." = "No se pudo contactar con {server}: se muestra lo que este ordenador recuerda."
+"Couldn't read {name}." = "No se pudo leer {name}."
 "Couldn't save automatically: {error}" = "No se pudo guardar automáticamente: {error}"
 "Count" = "Número"
 "Create" = "Crear"
@@ -338,6 +350,7 @@ status = "draft — needs native review"
 "Current version" = "Versión actual"
 "Cursor chat" = "Chat del cursor"
 "Custom" = "Personalizado"
+"Custom size" = "Tamaño personalizado"
 "Cut" = "Cortar"
 "Dark" = "Oscuro"
 "Darken" = "Oscurecer"
@@ -371,6 +384,7 @@ status = "draft — needs native review"
 "Description" = "Descripción"
 "Description (optional)" = "Descripción (opcional)"
 "Design" = "Diseño"
+"Design panel" = "Panel de diseño"
 "Design system starter" = "Base de sistema de diseño"
 "Desktop" = "Escritorio"
 "Destination" = "Destino"
@@ -382,6 +396,7 @@ status = "draft — needs native review"
 "Detach variable" = "Separar variable"
 "Details" = "Detalles"
 "Dev Mode" = "Modo desarrollo"
+"Dev Mode only inspects: switch to Design (Shift+D) to edit" = "El modo desarrollo solo inspecciona: cambia a Diseño (Shift+D) para editar"
 "Dev resources" = "Recursos de desarrollo"
 "Development" = "Desarrollo"
 "Device" = "Dispositivo"
@@ -398,6 +413,7 @@ status = "draft — needs native review"
 "Distribute horizontal spacing" = "Distribuir espacio horizontal"
 "Distribute vertical spacing" = "Distribuir espacio vertical"
 "Divider" = "Separador"
+"Don't Save" = "No guardar"
 "Don't truncate" = "No truncar"
 "Done" = "Listo"
 "Done editing" = "Terminar edición"
@@ -433,6 +449,7 @@ status = "draft — needs native review"
 "Effect settings" = "Ajustes del efecto"
 "Effect styles" = "Estilos de efecto"
 "Effects" = "Efectos"
+"Elbow" = "En ángulo"
 "Ellipse" = "Elipse"
 "Ellipses" = "Elipses"
 "Else" = "Si no"
@@ -483,6 +500,7 @@ status = "draft — needs native review"
 "Feb" = "feb"
 "Fetching from the server…" = "Obteniendo del servidor…"
 "FigCraft couldn't open its window: {error}" = "FigCraft no pudo abrir su ventana: {error}"
+"FigCraft doesn't support every feature of these files yet. The notes list what was left out or changed in the imported copy; the original file is unchanged." = "FigCraft aún no admite todas las funciones de estos archivos. Las notas indican qué se omitió o cambió en la copia importada; el archivo original no se modifica."
 "File" = "Archivo"
 "File name" = "Nombre del archivo"
 "File not found" = "No se encuentra el archivo"
@@ -568,6 +586,7 @@ status = "draft — needs native review"
 "Hanging list" = "Lista colgante"
 "Hanging punctuation" = "Puntuación colgante"
 "Hard light" = "Luz fuerte"
+"Heart" = "Corazón"
 "Height" = "Alto"
 "Help" = "Ayuda"
 "Help and resources" = "Ayuda y recursos"
@@ -580,6 +599,7 @@ status = "draft — needs native review"
 "Hide these tips (Getting started in the Help menu shows them again)" = "Ocultar estos consejos (Primeros pasos en el menú Ayuda los vuelve a mostrar)"
 "Hide when publishing" = "Ocultar al publicar"
 "Highlight layers on hover" = "Resaltar capas al pasar el cursor"
+"Highlighter" = "Resaltador"
 "Highlights" = "Luces"
 "Hold Alt" = "Mantén Alt"
 "Hold Alt+Z" = "Mantén Alt+Z"
@@ -607,11 +627,14 @@ status = "draft — needs native review"
 "If {condition}" = "Si {condition}"
 "Ignore auto layout (absolute position)" = "Ignorar diseño automático (posición absoluta)"
 "Image" = "Imagen"
+"Images" = "Imágenes"
 "Import" = "Importar"
 "Import path" = "Ruta de importación"
 "Import plugin from manifest" = "Importar plugin desde manifiesto"
 "Import plugin from manifest…" = "Importar plugin desde manifiesto…"
+"Import report" = "Informe de importación"
 "Import variables" = "Importar variables"
+"Imported document" = "Documento importado"
 "Imported {name}" = "{name} importado"
 "Imported {n} new variables, updated {updated}" = { one = "Variables importadas: {n} nueva; actualizadas: {updated}", other = "Variables importadas: {n} nuevas; actualizadas: {updated}" }
 "Import…" = "Importar…"
@@ -622,6 +645,7 @@ status = "draft — needs native review"
 "Included" = "Incluidos"
 "Included in layout" = "Incluidos en el diseño"
 "Individual corners" = "Esquinas individuales"
+"Individual padding" = "Margen interno individual"
 "Individual strokes" = "Trazos individuales"
 "Ink" = "Tinta"
 "Inner shadow" = "Sombra interior"
@@ -639,11 +663,14 @@ status = "draft — needs native review"
 "Instance swap (no other component)" = "Intercambio de instancia (no hay otro componente)"
 "Instances" = "Instancias"
 "Instant" = "Instantánea"
+"Intensity" = "Intensidad"
 "Interaction" = "Interacción"
 "Interactions" = "Interacciones"
 "Interface design and prototyping. A free, open-source, clean-room design tool written from scratch in Rust, part of the ArtCraft Crafting Apps." = "Diseño de interfaces y prototipos. Una herramienta de diseño gratuita y de código abierto, de implementación independiente (clean-room), escrita desde cero en Rust, parte de las Crafting Apps de ArtCraft."
+"Interface size" = "Tamaño de la interfaz"
 "Intersect" = "Intersecar"
 "Intersects" = "Intersecciones"
+"Invalid color" = "Color no válido"
 "Invite link" = "Enlace de invitación"
 "Invite link copied" = "Enlace de invitación copiado"
 "It asks permission to:" = "Pide permiso para:"
@@ -690,6 +717,7 @@ status = "draft — needs native review"
 "Leaves" = "Hojas"
 "Left" = "Izquierda"
 "Left & right" = "Izquierda y derecha"
+"Left padding" = "Margen interno izquierdo"
 "Left side" = "Lado izquierdo"
 "Left side width" = "Ancho del lado izquierdo"
 "Letter case" = "Mayúsculas y minúsculas"
@@ -741,6 +769,7 @@ status = "draft — needs native review"
 "Mark as resolved" = "Marcar como resuelto"
 "Mark as unread" = "Marcar como no leído"
 "Mark as unresolved" = "Marcar como no resuelto"
+"Marker" = "Rotulador"
 "Mask" = "Máscara"
 "Mass · Stiffness · Damping" = "Masa · Rigidez · Amortiguación"
 "Match (empty: the whole name)" = "Coincidencia (vacío: el nombre entero)"
@@ -764,6 +793,7 @@ status = "draft — needs native review"
 "Missing" = "No encontrado"
 "Missing layer" = "Capa no encontrada"
 "Missing style" = "Estilo no encontrado"
+"Missing fonts" = "Fuentes que faltan"
 "Missing variable" = "Variable no encontrada"
 "Miter" = "Inglete"
 "Miter angle" = "Ángulo de inglete"
@@ -799,9 +829,11 @@ status = "draft — needs native review"
 "Named instance" = "Instancia con nombre"
 "Navigate to" = "Navegar a"
 "Nested instance" = "Instancia anidada"
+"New board" = "Nueva pizarra"
 "New design file" = "Nuevo archivo de diseño"
 "Newest first" = "Más recientes primero"
 "Next or previous control in the focused region" = "Control siguiente o anterior de la región enfocada"
+"Next frame" = "Marco siguiente"
 "Next ready for dev" = "Siguiente listo para desarrollo"
 "Next size option" = "Siguiente opción de tamaño"
 "No assets: no export settings, icons or images. Add export settings in the Design tab." = "No hay recursos: ni ajustes de exportación, ni iconos, ni imágenes. Añade ajustes de exportación en la pestaña Diseño."
@@ -810,13 +842,17 @@ status = "draft — needs native review"
 "No branches. A branch is a copy of the file to try changes in, then review and merge." = "No hay ramas. Una rama es una copia del archivo para probar cambios y luego revisarlos y fusionarlos."
 "No category" = "Sin categoría"
 "No changes" = "Sin cambios"
+"No color styles" = "No hay estilos de color"
 "No colour variables fit here." = "Ninguna variable de color encaja aquí."
 "No colour variables yet. Create them in Local variables." = "Aún no hay variables de color. Créalas en Variables locales."
 "No comments yet" = "Aún no hay comentarios"
+"No compatibility warnings reported" = "No se han registrado advertencias de compatibilidad"
 "No components yet. Select layers and press {keys}." = "Aún no hay componentes. Selecciona capas y pulsa {keys}."
 "No conflicts." = "Sin conflictos."
 "No contributor data was built into this copy." = "Esta copia no incluye datos de colaboradores."
+"No device" = "Sin dispositivo"
 "No fonts match" = "Ninguna fuente coincide"
+"No files or templates match your search" = "Ningún archivo ni plantilla coincide con tu búsqueda"
 "No join code here (the server is older than join codes, or this address can't be put in one): share the link instead." = "Aquí no hay código para unirse (el servidor es anterior a los códigos, o esta dirección no cabe en uno): comparte el enlace."
 "No layer changes to show." = "No hay cambios de capas que mostrar."
 "No libraries yet. Add a .figcraft file that was published as a library, or paste a team library's link." = "Aún no hay bibliotecas. Añade un archivo .figcraft publicado como biblioteca o pega el enlace de una biblioteca de equipo."
@@ -830,6 +866,7 @@ status = "draft — needs native review"
 "No model credits were built into this copy." = "Esta copia no incluye créditos de modelos."
 "No number variables fit here." = "Ninguna variable numérica encaja aquí."
 "No number variables yet. Create them in Local variables." = "Aún no hay variables numéricas. Créalas en Variables locales."
+"No other pages" = "No hay otras páginas"
 "No paints" = "Sin pinturas"
 "No plugins on {server}." = "No hay plugins en {server}."
 "No plugins yet. Import a development plugin from its figcraft-plugin.json." = "Aún no hay plugins. Importa un plugin de desarrollo desde su figcraft-plugin.json."
@@ -859,6 +896,7 @@ status = "draft — needs native review"
 "Not read yet" = "Aún no leída"
 "Not shared" = "Sin compartir"
 "Note {n}" = "Nota {n}"
+"Nothing changed since this version." = "Nada cambió desde esta versión."
 "Nothing changed since this was marked ready for dev." = "Nada cambió desde que se marcó como listo para desarrollo."
 "Nothing here yet. Set a frame's status to list it." = "Aún no hay nada. Asigna un estado a un marco para verlo aquí."
 "Nothing online yet. Use Share on a file to put it online and it is listed here." = "Aún no hay nada en línea. Usa Compartir en un archivo para ponerlo en línea y aparecerá aquí."
@@ -896,6 +934,7 @@ status = "draft — needs native review"
 "Open branch" = "Abrir rama"
 "Open file" = "Abrir archivo"
 "Open files" = "Archivos abiertos"
+"Open presentations" = "Presentaciones abiertas"
 "Open in focus view" = "Abrir en vista de enfoque"
 "Open in new window" = "Abrir en una ventana nueva"
 "Open invite links in FigCraft" = "Abrir enlaces de invitación en FigCraft"
@@ -904,6 +943,7 @@ status = "draft — needs native review"
 "Open overlay" = "Abrir superposición"
 "Open prototype preview" = "Abrir vista previa del prototipo"
 "Open variables ({count})" = "Abrir variables ({count})"
+"Opened as a new document" = "Abierto como un documento nuevo"
 "Opened “{name}” in a new tab" = "“{name}” abierta en una pestaña nueva"
 "Opening the file…" = "Abriendo el archivo…"
 "Opening {n} files as new files" = { one = "Abriendo como archivo nuevo", other = "Abriendo {n} archivos como archivos nuevos" }
@@ -912,6 +952,7 @@ status = "draft — needs native review"
 "Orange" = "Naranja"
 "Order" = "Orden"
 "Other apps may not open every .fig file exported here." = "Puede que otras aplicaciones no abran todos los archivos .fig exportados aquí."
+"Other" = "Otros"
 "Others lose access and keep their copy; the file stays on the server for you" = "Los demás pierden el acceso y conservan su copia; el archivo se queda en el servidor para ti"
 "Others type this under Share ▸ Join with a code" = "Los demás lo escriben en Compartir ▸ Unirse con un código"
 "Outline stroke" = "Contornear trazo"
@@ -929,7 +970,11 @@ status = "draft — needs native review"
 "PDF print settings" = "Ajustes de impresión PDF"
 "Padding" = "Margen interno"
 "Page" = "Página"
+"Page deleted" = "Página eliminada"
 "Pages" = "Páginas"
+"Pages added to the document" = "Páginas añadidas al documento"
+"Pink" = "Rosa"
+"Placed on the current page" = "Colocado en la página actual"
 "Pages: {pages}" = "Páginas: {pages}"
 "Paint bucket" = "Bote de pintura"
 "Pan the canvas" = "Desplazar el lienzo"
@@ -944,6 +989,7 @@ status = "draft — needs native review"
 "Paste a team library link (a view link)" = "Pega el enlace de una biblioteca de equipo (de lectura)"
 "Paste here" = "Pegar aquí"
 "Paste to replace" = "Pegar para reemplazar"
+"Pasted design layers; {n} kinds of content were left out" = { one = "Capas de diseño pegadas; se omitió {n} tipo de contenido", other = "Capas de diseño pegadas; se omitieron {n} tipos de contenido" }
 "Pattern" = "Patrón"
 "Pattern alignment" = "Alineación del patrón"
 "Pattern scale" = "Escala del patrón"
@@ -966,10 +1012,13 @@ status = "draft — needs native review"
 "Place a shape or frame (its tool chosen)" = "Colocar forma o marco (herramienta elegida)"
 "Place automatically" = "Colocar automáticamente"
 "Place image" = "Colocar imagen"
+"Plugin" = "Plugin"
 "Plugins run in FigCraft's sandbox, without files, network or clock. Install only plugins you trust." = "Los plugins se ejecutan en el entorno aislado de FigCraft, sin archivos, red ni reloj. Instala solo plugins de confianza."
 "Plugins" = "Plugins"
+"Plugins & widgets" = "Plugins y widgets"
 "Plus darker" = "Más oscuro"
 "Plus lighter" = "Más claro"
+"Plus one" = "Más uno"
 "Point" = "Punto"
 "Points" = "Puntos"
 "Polygon" = "Polígono"
@@ -997,6 +1046,7 @@ status = "draft — needs native review"
 "Preview" = "Vista previa"
 "Preview this flow" = "Vista previa de este flujo"
 "Preview this frame" = "Vista previa de este marco"
+"Previous frame" = "Marco anterior"
 "Previous ready for dev" = "Anterior listo para desarrollo"
 "Progressive" = "Progresivo"
 "Properties" = "Propiedades"
@@ -1017,6 +1067,7 @@ status = "draft — needs native review"
 "Push" = "Empujar"
 "Push changes to main component" = "Enviar cambios al componente principal"
 "Put text on path" = "Poner texto en trazado"
+"Question" = "Pregunta"
 "R" = "R"
 "Radial" = "Radial"
 "Radius" = "Radio"
@@ -1034,6 +1085,7 @@ status = "draft — needs native review"
 "Reduce motion" = "Reducir movimiento"
 "Refraction" = "Refracción"
 "Regular expression" = "Expresión regular"
+"Relative to your system's display scaling (100% is the system's own size). Document zoom is separate." = "Relativo al escalado de pantalla del sistema (100% es el tamaño del propio sistema). El zoom del documento es independiente."
 "Remove" = "Quitar"
 "Remove all" = "Quitar todo"
 "Remove annotation" = "Quitar anotación"
@@ -1062,6 +1114,7 @@ status = "draft — needs native review"
 "Removed" = "Eliminado"
 "Removed from the server" = "Quitado del servidor"
 "Removed since it was marked" = "Eliminada desde que se marcó"
+"Removed since this version" = "Eliminado desde esta versión"
 "Rename" = "Cambiar nombre"
 "Rename duplicated layers" = "Renombrar capas duplicadas"
 "Rename folder" = "Cambiar nombre de la carpeta"
@@ -1072,6 +1125,7 @@ status = "draft — needs native review"
 "Rename on the server…" = "Cambiar el nombre en el servidor…"
 "Rename page" = "Cambiar nombre de página"
 "Rename to" = "Nuevo nombre"
+"Reorder selection" = "Reordenar selección"
 "Replace all" = "Reemplazar todo"
 "Replace mixed export settings" = "Reemplazar ajustes de exportación mixtos"
 "Replace with" = "Reemplazar con"
@@ -1091,6 +1145,7 @@ status = "draft — needs native review"
 "Resize by the nudge amount" = "Redimensionar según el desplazamiento"
 "Resize frames to the device's screen (or the window without a device): their constraints and auto layout respond" = "Ajusta los marcos a la pantalla del dispositivo (o a la ventana sin dispositivo): sus restricciones y su diseño automático se adaptan"
 "Resize to fit" = "Ajustar tamaño"
+"Resizing" = "Cambio de tamaño"
 "Resolve" = "Resolver"
 "Resolve change" = "Resolver cambio"
 "Resolved" = "Resuelto"
@@ -1106,6 +1161,7 @@ status = "draft — needs native review"
 "Review and merge" = "Revisar y fusionar"
 "Ribbon" = "Cinta"
 "Right" = "Derecha"
+"Right padding" = "Margen interno derecho"
 "Right side" = "Lado derecho"
 "Right side width" = "Ancho del lado derecho"
 "Rotate 90°" = "Girar 90°"
@@ -1116,6 +1172,7 @@ status = "draft — needs native review"
 "Rotation jitter" = "Variación de rotación"
 "Round" = "Redondo"
 "Rounded" = "Redondeado"
+"Rounded rectangle" = "Rectángulo redondeado"
 "Row" = "Fila"
 "Row gap" = "Espacio entre filas"
 "Row sizes" = "Tamaños de fila"
@@ -1152,8 +1209,11 @@ status = "draft — needs native review"
 "Search actions, layers and tools" = "Buscar acciones, capas y herramientas"
 "Search assets" = "Buscar recursos"
 "Search comments" = "Buscar comentarios"
+"Search files and templates" = "Buscar archivos y plantillas"
+"Search results" = "Resultados de búsqueda"
 "Search fonts" = "Buscar fuentes"
 "Search layers" = "Buscar capas"
+"Search pages" = "Buscar páginas"
 "Search shortcuts" = "Buscar atajos"
 "Section" = "Sección"
 "Section color" = "Color de sección"
@@ -1165,9 +1225,11 @@ status = "draft — needs native review"
 "Select all with same" = "Seleccionar todo con el mismo"
 "Select layer" = "Seleccionar capa"
 "Select layers to apply the style to" = "Selecciona capas para aplicarles el estilo"
+"Select layers with this color" = "Seleccionar capas con este color"
 "Select overlapping shapes" = "Selecciona formas superpuestas"
 "Select points to edit their position, radius and mirroring" = "Selecciona puntos para editar su posición, radio y reflejo"
 "Select slot" = "Seleccionar ranura"
+"Selection colors" = "Colores de la selección"
 "Selection" = "Selección"
 "Selection box, {w} by {h} at {x}, {y}: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "Cuadro de selección, {w} por {h} en {x}, {y}: las flechas lo mueven, Mayús+flechas o {cmd}+flechas cambian su tamaño, Intro selecciona, Esc cancela"
 "Selection box: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "Cuadro de selección: las flechas lo mueven, Mayús+flechas o {cmd}+flechas cambian su tamaño, Intro selecciona, Esc cancela"
@@ -1187,6 +1249,7 @@ status = "draft — needs native review"
 "Shape" = "Forma"
 "Shape builder" = "Generador de formas"
 "Shape tools" = "Herramientas de forma"
+"Shapes" = "Formas"
 "Share" = "Compartir"
 "Share this file" = "Compartir este archivo"
 "Share with a code" = "Comparte con un código"
@@ -1253,10 +1316,13 @@ status = "draft — needs native review"
 "Space+drag" = "Espacio+arrastrar"
 "Spacing" = "Espaciado"
 "Spam, stolen work, abuse…" = "Spam, obra robada, abuso…"
+"Speech bubble" = "Bocadillo"
 "Splay" = "Apertura"
 "Spotlight me" = "Ponerme en el foco"
 "Spread" = "Extensión"
 "Square" = "Cuadrado"
+"Stamp" = "Sello"
+"Stamps" = "Sellos"
 "Standard" = "Estándar"
 "Standard ligatures" = "Ligaduras estándar"
 "Star" = "Estrella"
@@ -1266,18 +1332,23 @@ status = "draft — needs native review"
 "Start from a blank canvas" = "Empieza con un lienzo en blanco"
 "Start from a template" = "Empieza con una plantilla"
 "Start on path" = "Inicio en el trazado"
+"Start on the Home screen" = "Empezar en Inicio"
 "Start point" = "Punto inicial"
 "Start sharing" = "Empezar a compartir"
 "Start sharing with the Share button, then pass on the code it gives" = "Empieza a compartir con el botón Compartir y pasa el código que te da"
 "Starting to share…" = "Empezando a compartir…"
 "Status" = "Estado"
 "Sticky" = "Adherido"
+"Sticky note" = "Nota adhesiva"
+"Sticky note colors" = "Colores de las notas adhesivas"
+"Sticky notes, shapes and connectors" = "Notas adhesivas, formas y conectores"
 "Stop" = "Parar"
 "Stop following {name}" = "Dejar de seguir a {name}"
 "Stop session" = "Detener sesión"
 "Stop sharing" = "Dejar de compartir"
 "Stop spotlighting" = "Salir del foco"
 "Stop {n}  {hex}" = "Parada {n}  {hex}"
+"Straight" = "Recto"
 "Stretch" = "Estirar"
 "Strikethrough" = "Tachado"
 "String" = "Cadena"
@@ -1322,6 +1393,7 @@ status = "draft — needs native review"
 "Text" = "Texto"
 "Text align" = "Alineación del texto"
 "Text content" = "Contenido de texto"
+"Text size" = "Tamaño del texto"
 "Text style" = "Estilo de texto"
 "Text styles" = "Estilos de texto"
 "Texts" = "Textos"
@@ -1339,6 +1411,7 @@ status = "draft — needs native review"
 "The selection uses several text styles: click to apply one" = "La selección usa varios estilos de texto: haz clic para aplicar uno"
 "The server deletes this file if nobody opens it before {date}." = "El servidor elimina este archivo si nadie lo abre antes del {date}."
 "The whole file" = "El archivo completo"
+"The window is too small for {size}%, so the interface is drawn at {drawn}%. Make the window larger to use {size}%." = "La ventana es demasiado pequeña para {size}%, así que la interfaz se dibuja al {drawn}%. Agranda la ventana para usar {size}%."
 "Theme" = "Tema"
 "There's no destination for that action" = "No hay destino para esa acción"
 "Thickness" = "Grosor"
@@ -1349,12 +1422,17 @@ status = "draft — needs native review"
 "This condition is edited as an expression" = "Esta condición se edita como expresión"
 "This file" = "Este archivo"
 "This file has unsaved changes" = "Este archivo tiene cambios sin guardar"
+"This file is too large to join here (up to {mb} MB)" = "Este archivo es demasiado grande para unirte aquí (hasta {mb} MB)"
+"This file uses fonts that aren't installed on this computer. Their text is drawn in a fallback font until you install them." = "Este archivo usa fuentes que no están instaladas en este equipo. Su texto se dibuja con una fuente de reserva hasta que las instales."
 "This file is on {server}, open only to you. Share it to let others in with a new code." = "Este archivo está en {server}, abierto solo para ti. Compártelo para dejar entrar a otros con un código nuevo."
 "This frame is new on the branch." = "Este marco es nuevo en la rama."
 "This frame isn't on the branch." = "Este marco no está en la rama."
 "This server is open to the public: no key needed." = "Este servidor está abierto al público: no hace falta clave."
 "This server needs its key: add ?key=… to the address (`figcraft-server key` prints it on the server's machine)." = "Este servidor necesita su clave: añade ?key=… a la dirección (`figcraft-server key` la muestra en el equipo del servidor)."
 "This server takes files only with its key: see Advanced." = "Este servidor solo acepta archivos con su clave: mira Avanzado."
+"Thumbs up" = "Pulgar arriba"
+"This version can't be read." = "No se puede leer esta versión."
+"This version doesn't have it: all of it is new." = "Esta versión no lo tiene: todo es nuevo."
 "Tidy up" = "Ordenar"
 "Tile" = "Mosaico"
 "Tile type" = "Tipo de mosaico"
@@ -1369,8 +1447,10 @@ status = "draft — needs native review"
 "Top" = "Arriba"
 "Top & bottom" = "Arriba y abajo"
 "Top left radius" = "Radio superior izquierdo"
+"Top padding" = "Margen interno superior"
 "Top right radius" = "Radio superior derecho"
 "Transform" = "Transformar"
+"Triangle" = "Triángulo"
 "Triangle arrow" = "Flecha triangular"
 "Trigger" = "Desencadenante"
 "True" = "Verdadero"
@@ -1378,6 +1458,7 @@ status = "draft — needs native review"
 "Truncate with an ellipsis" = "Truncar con puntos suspensivos"
 "Try again" = "Reintentar"
 "Try another search or filter." = "Prueba otra búsqueda u otro filtro."
+"Try another search, or browse templates." = "Prueba otra búsqueda o explora las plantillas."
 "Try another word, or look at every kind." = "Prueba con otra palabra o mira todos los tipos."
 "Turn a layer into a component, reuse it, and change every copy at once" = "Convierte una capa en componente, reutilízalo y cambia todas las copias a la vez"
 "Two digits" = "Dos dígitos"
@@ -1395,7 +1476,7 @@ status = "draft — needs native review"
 "Unread" = "No leídos"
 "Unresolve" = "Reabrir"
 "Unsaved changes" = "Cambios sin guardar"
-"Unsaved changes in {names}. Close the window and lose them?" = "Hay cambios sin guardar en {names}. ¿Cerrar la ventana y perderlos?"
+"Unsaved changes in {names}. Save them before closing?" = "Hay cambios sin guardar en {names}. ¿Guardarlos antes de cerrar?"
 "Unsaved changes: save first ({save}), or close the tab with {alt}-click to discard" = "Cambios sin guardar: guarda primero ({save}) o cierra la pestaña con {alt}+clic para descartarlos"
 "Unsaved changes: save first, or close again with {key} to discard" = "Cambios sin guardar: guarda primero o vuelve a cerrar con {key} para descartarlos"
 "Up" = "Arriba"
@@ -1414,7 +1495,9 @@ status = "draft — needs native review"
 "Use as mask" = "Usar como máscara"
 "Use auto layout" = "Usar diseño automático"
 "Use number keys for opacity" = "Usar teclas numéricas para la opacidad"
+"Use the .figcraft or .fig extension." = "Usa la extensión .figcraft o .fig."
 "Use the layer's fill" = "Usar el relleno de la capa"
+"Use your browser's zoom to change the interface size." = "Usa el zoom del navegador para cambiar el tamaño de la interfaz."
 "Used in {files} · {instances}" = "Usado en {files} · {instances}"
 "Username" = "Usuario"
 "Value" = "Valor"
@@ -1459,16 +1542,19 @@ status = "draft — needs native review"
 "WebSocket URL copied" = "URL de WebSocket copiada"
 "Wedge" = "Cuña"
 "Weight" = "Grosor"
+"What changed since a saved version" = "Qué cambió desde una versión guardada"
 "What you try here changes this preview and the code below, not the file" = "Lo que pruebes aquí cambia esta vista previa y el código de abajo, no el archivo"
 "What changed since it was marked ready for dev" = "Qué cambió desde que se marcó como listo para desarrollo"
 "What is wrong with this file? The server's operator gets your report." = "¿Qué tiene de malo este archivo? El operador del servidor recibirá tu denuncia."
 "What it's for" = "Para qué sirve"
 "What this changed from isn't known: it changed before FigCraft kept a copy of ready-for-dev frames. Resolve the change (or mark it ready again) to compare from now on." = "No se sabe desde qué cambió: cambió antes de que FigCraft guardara copias de los marcos listos para desarrollo. Resuelve el cambio (o vuelve a marcarlo como listo) para comparar a partir de ahora."
+"When marked ready" = "Al marcarlo como listo"
 "While hovering" = "Mientras se pasa el puntero"
 "While pressing" = "Mientras se presiona"
 "White" = "Blanco"
 "Who runs it, its terms and how long it keeps files" = "Quién lo gestiona, sus condiciones y cuánto tiempo conserva los archivos"
 "Why it changed" = "Por qué cambió"
+"Widget" = "Widget"
 "Widgets" = "Widgets"
 "Width" = "Ancho"
 "Width point" = "Punto de ancho"
@@ -1507,26 +1593,121 @@ status = "draft — needs native review"
 "call any command its access allows" = "llamar a cualquier comando que su acceso permita"
 "call only: {commands}" = "llamar solo a: {commands}"
 "can edit the document" = "puede editar el documento"
+"conditional prototype actions nested too deeply were skipped" = "se omitieron las acciones condicionales de prototipo anidadas a demasiada profundidad"
+"conditional prototype actions with conditions that can't be evaluated were skipped" = "se omitieron las acciones condicionales de prototipo con condiciones que no se pueden evaluar"
+"connector label background was skipped: style data is missing" = "se omitió el fondo de la etiqueta del conector: faltan los datos de estilo"
+"connector label was skipped: background bounds are invalid" = "se omitió la etiqueta del conector: los límites del fondo no son válidos"
+"connector label was skipped: background transform is invalid" = "se omitió la etiqueta del conector: la transformación del fondo no es válida"
+"connector label was skipped: composed text transform is invalid" = "se omitió la etiqueta del conector: la transformación compuesta del texto no es válida"
+"connector label was skipped: derived background bounds are missing" = "se omitió la etiqueta del conector: faltan los límites derivados del fondo"
+"connector label was skipped: derived text bounds are missing" = "se omitió la etiqueta del conector: faltan los límites derivados del texto"
+"connector label was skipped: text bounds are invalid" = "se omitió la etiqueta del conector: los límites del texto no son válidos"
+"connector label was skipped: text style data is missing" = "se omitió la etiqueta del conector: faltan los datos del estilo de texto"
+"connector label was skipped: text transform is invalid" = "se omitió la etiqueta del conector: la transformación del texto no es válida"
+"connector labels were skipped" = "se omitieron las etiquetas de los conectores"
+"connector layers import as static frame/vector snapshots with labels when present; live endpoint bindings are not retained" = "las capas de conector se importan como instantáneas estáticas de marco o vector, con sus etiquetas si las hay; no se conservan los vínculos dinámicos de los extremos"
+"connector snapshot vector data is missing; connector was left empty" = "faltan los datos vectoriales de la instantánea del conector; el conector quedó vacío"
+"connectors whose ends can't be placed are empty" = "los conectores cuyos extremos no se pueden colocar están vacíos"
 "crop marks" = "marcas de corte"
+"damaged vector geometry was skipped" = "se omitió la geometría vectorial dañada"
+"damaged vector networks import as outlines" = "las redes vectoriales dañadas se importan como contornos"
 "development: {path}" = "desarrollo: {path}"
+"document children other than pages were skipped" = "se omitieron los elementos del documento que no son páginas"
+"duplicate grid track sizing entries use equal tracks" = "las entradas duplicadas de tamaño de pista de cuadrícula usan pistas iguales"
 "e.g. count + 1" = "p. ej. count + 1"
 "e.g. count >= 3 and not done" = "p. ej. count >= 3 and not done"
+"elbowed and curved connectors without a saved path import as straight lines" = "los conectores angulares y curvos sin trazado guardado se importan como líneas rectas"
+"entries without a node type were skipped" = "se omitieron las entradas sin tipo de nodo"
 "figcraft:// links from a browser, chat or email open this app and join the session." = "Los enlaces figcraft:// de un navegador, chat o correo abren esta app y se unen a la sesión."
+"filled areas of a vector with their own fill use the layer's fill" = "las áreas rellenas de un vector con relleno propio usan el relleno de la capa"
 "from {server}" = "de {server}"
+"gamepad triggers without exactly one known controller button were skipped" = "se omitieron los desencadenantes de mando sin exactamente un botón de mando conocido"
+"grid track list exceeds 1000 entries; the tracks use the default equal sizing" = "la lista de pistas de cuadrícula supera las 1000 entradas; las pistas usan el tamaño igual predeterminado"
+"grid track sizing is unsupported or malformed; affected tracks use equal sizing" = "el tamaño de las pistas de cuadrícula no es compatible o está mal formado; las pistas afectadas usan tamaños iguales"
+"grid track sizing list exceeds 1000 entries; the tracks use the default equal sizing" = "la lista de tamaños de pista de cuadrícula supera las 1000 entradas; las pistas usan el tamaño igual predeterminado"
 "hidden" = "oculta"
 "iOS" = "iOS"
+"image filters are ambiguous because both filter containers are present; filter conversion was skipped" = "los filtros de imagen son ambiguos porque están los dos contenedores de filtros; se omitió la conversión de filtros"
+"image filters use FigCraft's approximate renderer" = "los filtros de imagen usan el renderizado aproximado de FigCraft"
+"instance swap properties whose default component isn't in the file were skipped" = "se omitieron las propiedades de intercambio de instancia cuyo componente predeterminado no está en el archivo"
+"instances inside their own main component were imported as frames" = "las instancias dentro de su propio componente principal se importaron como marcos"
+"instances of components that aren't in the file show no layers" = "las instancias de componentes que no están en el archivo no muestran capas"
+"instances of components that aren't in the file were imported as frames" = "las instancias de componentes que no están en el archivo se importaron como marcos"
+"instances that would nest a component inside itself were imported as frames" = "las instancias que anidarían un componente dentro de sí mismo se importaron como marcos"
+"instances without a main component were imported as empty frames" = "las instancias sin componente principal se importaron como marcos vacíos"
+"invalid internal .fig text path data was ignored" = "se ignoraron datos internos no válidos de texto en trazado del .fig"
+"invalid or oversized vector networks import as outlines" = "las redes vectoriales no válidas o demasiado grandes se importan como contornos"
+"invalid or oversized vector path data was skipped" = "se omitieron los datos de trazados vectoriales no válidos o demasiado grandes"
 "just now" = "justo ahora"
+"key triggers without a supported key were skipped" = "se omitieron los desencadenantes de tecla sin una tecla compatible"
+"key up triggers import as key presses" = "los desencadenantes al soltar una tecla se importan como pulsaciones de tecla"
+"layers without a position were placed at their parent's origin" = "las capas sin posición se colocaron en el origen de su elemento padre"
+"layers without a type were skipped" = "se omitieron las capas sin tipo"
+"legacy image filter container is unsupported; filter conversion was skipped" = "el contenedor antiguo de filtros de imagen no es compatible; se omitió la conversión de filtros"
 "locked" = "bloqueada"
+"malformed image filters container was skipped" = "se omitió el contenedor de filtros de imagen mal formado"
+"malformed image paintFilter container was skipped" = "se omitió el contenedor paintFilter de imagen mal formado"
+"malformed slot content assignment was skipped" = "se omitió una asignación de contenido de ranura mal formada"
 "no bleed" = "sin sangrado"
 "nobody else here yet" = "aún no hay nadie más"
+"non-default slot settings are not represented and were skipped" = "los ajustes de ranura no predeterminados no se representan y se omitieron"
 "now" = "ahora"
+"only in a text style or variable" = "solo en un estilo de texto o una variable"
 "or" = "o"
+"point stroke joins were preserved; dashed or variable-width strokes render with the layer join" = "se conservaron las uniones de trazo de los puntos; los trazos discontinuos o de ancho variable se dibujan con la unión de la capa"
+"preferred slot component keys cannot be resolved to file nodes and were skipped" = "las claves de componentes preferidos de las ranuras no corresponden a capas del archivo y se omitieron"
+"prototype actions of unknown types were skipped" = "se omitieron las acciones de prototipo de tipos desconocidos"
+"prototype actions without a destination in the file were skipped" = "se omitieron las acciones de prototipo sin destino en el archivo"
+"prototype expressions on variables that aren't in the variables JSON were skipped" = "se omitieron las expresiones de prototipo con variables que no están en el JSON de variables"
+"prototype expressions with unsupported functions were skipped" = "se omitieron las expresiones de prototipo con funciones no compatibles"
+"prototype interactions without supported actions were skipped" = "se omitieron las interacciones de prototipo sin acciones compatibles"
+"prototype navigations of unknown types were skipped" = "se omitieron las navegaciones de prototipo de tipos desconocidos"
+"prototype transitions of unknown types play instantly" = "las transiciones de prototipo de tipos desconocidos se reproducen al instante"
+"prototype triggers of unknown types were skipped" = "se omitieron los desencadenantes de prototipo de tipos desconocidos"
 "put a widget on the canvas" = "poner un widget en el lienzo"
 "read and edit the document" = "leer y editar el documento"
 "read the document" = "leer el documento"
 "reads the document" = "lee el documento"
+"set-variable actions on variables that aren't in the variables JSON were skipped" = "se omitieron las acciones «Establecer variable» sobre variables que no están en el JSON de variables"
+"set-variable actions with values that can't be evaluated were skipped" = "se omitieron las acciones «Establecer variable» con valores que no se pueden evaluar"
+"set-variable actions with values that don't fit the variable were skipped" = "se omitieron las acciones «Establecer variable» con valores que no encajan con la variable"
+"set-variable actions without a value were skipped" = "se omitieron las acciones «Establecer variable» sin valor"
+"set-variable-mode actions on collections or modes that aren't in the variables JSON were skipped" = "se omitieron las acciones «Establecer modo de variable» sobre colecciones o modos que no están en el JSON de variables"
+"slot content assignment target is missing or is not slot content" = "el destino de la asignación de contenido de ranura falta o no es contenido de ranura"
+"slot content assignment uses the empty GUID sentinel and was skipped" = "la asignación de contenido de ranura usa el GUID vacío como centinela y se omitió"
+"slot layers without a matching slot property were imported as frames" = "las capas de ranura sin una propiedad de ranura correspondiente se importaron como marcos"
+"some vector points refer to point settings missing from the file; they use the layer's joins and plain corners" = "algunos puntos vectoriales hacen referencia a ajustes de punto que faltan en el archivo; usan las uniones de la capa y esquinas simples"
+"some vector segments refer to style settings missing from the file; they use the layer's stroke" = "algunos segmentos vectoriales hacen referencia a ajustes de estilo que faltan en el archivo; usan el trazo de la capa"
+"stale or invalid grid track sizing entries were ignored" = "se ignoraron las entradas de tamaño de pista de cuadrícula obsoletas o no válidas"
+"stars and polygons without point counts or geometry use the default point count" = "las estrellas y los polígonos sin número de puntos ni geometría usan el número de puntos predeterminado"
+"style settings of some vector segments aren't supported; those segments use the layer's stroke" = "los ajustes de estilo de algunos segmentos vectoriales no son compatibles; esos segmentos usan el trazo de la capa"
+"text path underline or strikethrough decoration is not rendered" = "el subrayado o tachado del texto en trazado no se dibuja"
+"text style overrides refer to missing table entries" = "las anulaciones de estilo de texto hacen referencia a entradas de tabla que faltan"
+"the file has no pages" = "el archivo no tiene páginas"
 "the plugin" = "el plugin"
+"the variables JSON has no `variableCollections` (expected the local variables response) and was ignored" = "el JSON de variables no tiene `variableCollections` (se esperaba la respuesta de variables locales) y se ignoró"
 "this session only" = "solo esta sesión"
+"unknown component property types were skipped" = "se omitieron los tipos de propiedad de componente desconocidos"
+"variable aliases to variables that aren't in the variables JSON (or of another type) were skipped" = "se omitieron los alias a variables que no están en el JSON de variables (o son de otro tipo)"
+"variable bindings to properties the layer doesn't have were skipped" = "se omitieron las vinculaciones de variables a propiedades que la capa no tiene"
+"variable bindings to variables that aren't in the variables JSON (library variables) were skipped" = "se omitieron las vinculaciones a variables que no están en el JSON de variables (variables de biblioteca)"
+"variable bindings were skipped: the file JSON has no variable definitions (pass the local variables JSON as `variables`, or embed its `meta` next to the file JSON)" = "se omitieron las vinculaciones de variables: el JSON del archivo no tiene definiciones de variables (pasa el JSON de variables locales como `variables` o incrusta su `meta` junto al JSON del archivo)"
+"variable bindings whose variable type doesn't fit the property were skipped" = "se omitieron las vinculaciones de variables cuyo tipo no encaja con la propiedad"
+"variable collections without modes were skipped" = "se omitieron las colecciones de variables sin modos"
+"variable mode lookups in prototype expressions that aren't a variable and one of its modes were skipped" = "se omitieron las consultas de modo de variable en expresiones de prototipo que no son una variable y uno de sus modos"
+"variable modes of collections that aren't in the file were skipped" = "se omitieron los modos de variable de colecciones que no están en el archivo"
+"variable modes of collections that aren't in the variables JSON were skipped" = "se omitieron los modos de variable de colecciones que no están en el JSON de variables"
+"variable values that don't match their type (or composed colours) were skipped" = "se omitieron los valores de variable que no coinciden con su tipo (o colores compuestos)"
+"variables of unknown types were skipped" = "se omitieron las variables de tipos desconocidos"
+"variables whose collection isn't in the variables JSON were skipped" = "se omitieron las variables cuya colección no está en el JSON de variables"
+"variables without readable values were skipped" = "se omitieron las variables sin valores legibles"
+"vector points with unknown stroke joins use the layer join" = "los puntos vectoriales con uniones de trazo desconocidas usan la unión de la capa"
+"vectors without geometry are empty" = "los vectores sin geometría están vacíos"
+"vectors without geometry are empty (export the file JSON with geometry=paths)" = "los vectores sin geometría están vacíos (exporta el JSON del archivo con geometry=paths)"
+"very long text was cut to 1,048,576 characters" = "el texto muy largo se recortó a 1.048.576 caracteres"
+"very long vector paths were skipped" = "se omitieron los trazados vectoriales muy largos"
+"video actions are not supported and were skipped" = "las acciones de vídeo no son compatibles y se omitieron"
+"video triggers are not supported and were skipped" = "los desencadenantes de vídeo no son compatibles y se omitieron"
 "yesterday" = "ayer"
 "{instances} in {files}" = "{instances} en {files}"
 "{language}: draft translation, waiting for a native speaker's review." = "{language}: traducción en borrador, pendiente de revisión por un hablante nativo."
@@ -1536,6 +1717,7 @@ status = "draft — needs native review"
 "{name} is forgotten on this computer; the file stays on {server}" = "{name} se olvidó en este ordenador; el archivo se queda en {server}"
 "{name} is on the server." = "{name} está en el servidor."
 "{name} is spotlighting" = "{name} está en el foco"
+"{name} is too large to open in the browser (over 512 MB)." = "{name} es demasiado grande para abrirlo en el navegador (más de 512 MB)."
 "{name}\nClick to apply to the selection" = "{name}\nHaz clic para aplicarlo a la selección"
 "{name}\nDrag onto the canvas, or click to place in the middle of the view.\nHold Alt (Option) while dropping onto an instance to swap it." = "{name}\nArrastra al lienzo o haz clic para colocarlo en el centro de la vista.\nMantén Alt (Opción) al soltar sobre una instancia para intercambiarla."
 "{name} (from {library})" = "{name} (de {library})"
@@ -1571,6 +1753,7 @@ status = "draft — needs native review"
 "{n} matches" = { one = "{n} coincidencia", other = "{n} coincidencias" }
 "{n} minutes ago" = { one = "hace {n} minuto", other = "hace {n} minutos" }
 "{n} months ago" = { one = "hace {n} mes", other = "hace {n} meses" }
+"{n} more notes omitted from this report" = { one = "{n} nota más omitida de este informe", other = "{n} notas más omitidas de este informe" }
 "{n} of {total}" = "{n} de {total}"
 "{n} people joined" = { one = "{n} persona se ha unido", other = "{n} personas se han unido" }
 "{n} preferred components" = { one = "{n} componente preferido", other = "{n} componentes preferidos" }
@@ -1579,6 +1762,7 @@ status = "draft — needs native review"
 "{n} replies" = { one = "{n} respuesta", other = "{n} respuestas" }
 "{n} rows" = { one = "{n} fila", other = "{n} filas" }
 "{n} styles" = { one = "{n} estilo", other = "{n} estilos" }
+"{n} text layers" = { one = "{n} capa de texto", other = "{n} capas de texto" }
 "{n} variables" = { one = "{n} variable", other = "{n} variables" }
 "{n} weeks ago" = { one = "hace {n} semana", other = "hace {n} semanas" }
 "{n} years ago" = { one = "hace {n} año", other = "hace {n} años" }
@@ -1587,6 +1771,7 @@ status = "draft — needs native review"
 "{n}m" = "{n} min"
 "{n}w" = "{n} sem"
 "{page}, nothing selected" = "{page}, nada seleccionado"
+"{percent}%" = "{percent}%"
 "{profile} (current)" = "{profile} (actual)"
 "{property} is its value; {property ? \"a\" : \"b\"} picks a string. Other {…} stays as written." = "{property} es su valor; {property ? \"a\" : \"b\"} elige un texto. Cualquier otro {…} se queda tal cual."
 "{server} can't say what became of your files (it is older than this app)." = "{server} no puede decir qué fue de tus archivos (es anterior a esta aplicación)."
@@ -1629,8 +1814,19 @@ status = "draft — needs native review"
 "arrange.front" = "Traer al frente"
 "arrange.packH" = "Agrupar en horizontal"
 "arrange.packV" = "Agrupar en vertical"
+"arrange.reorder" = "Reordenar selección"
 "arrange.roundToPixels" = "Redondear a píxeles"
+"arrange.spacing" = "Espaciado"
 "arrange.tidy" = "Ordenar"
+"board.connector" = "Conector"
+"board.ink" = "Trazo de rotulador"
+"board.label" = "Etiqueta del conector"
+"board.nextSticky" = "Siguiente nota adhesiva"
+"board.setColor" = "Color en la pizarra"
+"board.setStyle" = "Estilo en la pizarra"
+"board.shape" = "Forma con texto"
+"board.stamp" = "Sello"
+"board.sticky" = "Nota adhesiva"
 "bool.exclude" = "Excluir selección"
 "bool.flatten" = "Acoplar booleana"
 "bool.intersect" = "Intersecar selección"
@@ -1731,6 +1927,7 @@ status = "draft — needs native review"
 "edit.duplicate" = "Duplicar"
 "edit.findReplace" = "Buscar y reemplazar"
 "edit.paste" = "Pegar"
+"edit.pasteDesignLayers" = "Pegar capas de diseño"
 "edit.pasteOver" = "Pegar sobre la selección"
 "edit.pasteProperties" = "Pegar propiedades"
 "edit.pasteReplace" = "Pegar para reemplazar"
@@ -1754,7 +1951,9 @@ status = "draft — needs native review"
 "file.exportLayers" = "Exportar capas"
 "file.exportSvg" = "Exportar selección como SVG"
 "file.import" = "Importar"
+"file.moveTab" = "Mover pestaña"
 "file.new" = "Nuevo archivo de diseño"
+"file.newBoard" = "Nueva pizarra"
 "file.newFromTemplate" = "Nuevo desde plantilla"
 "file.open" = "Abrir"
 "file.openRecent" = "Abrir reciente"
@@ -1839,6 +2038,7 @@ status = "draft — needs native review"
 "object.batchRename" = "Cambiar nombre en lote"
 "object.convertToFrame" = "Convertir en marco"
 "object.convertToGroup" = "Convertir en grupo"
+"object.convertToSection" = "Convertir en sección"
 "object.flipH" = "Voltear horizontalmente"
 "object.flipV" = "Voltear verticalmente"
 "object.frameSelection" = "Enmarcar selección"
@@ -1895,6 +2095,8 @@ status = "draft — needs native review"
 "pref.reduceMotion" = "Reducir movimiento"
 "pref.renameDuplicates" = "Renombrar capas duplicadas"
 "pref.showDimensions" = "Mostrar dimensiones en los objetos"
+"pref.startOnHome" = "Empezar en Inicio"
+"pref.uiScale" = "Tamaño de la interfaz"
 "pref.userName" = "Tu nombre en los comentarios"
 "proto.action.add" = "Añadir acción de prototipo"
 "proto.action.move" = "Reordenar acción de prototipo"
@@ -1938,6 +2140,10 @@ status = "draft — needs native review"
 "select.sameStroke" = "Seleccionar mismo trazo"
 "select.sameText" = "Seleccionar mismas propiedades de texto"
 "select.set" = "Seleccionar"
+"selection.applyColorStyle" = "Aplicar estilo de color a la selección"
+"selection.colors" = "Colores de la selección"
+"selection.selectColor" = "Seleccionar capas con este color"
+"selection.setPaint" = "Cambiar color de la selección"
 "shape.arrow" = "Flecha"
 "shape.ellipse" = "Elipse"
 "shape.line" = "Línea"
@@ -1996,14 +2202,18 @@ status = "draft — needs native review"
 "text.listIndent" = "Aumentar sangría de la lista"
 "text.listOutdent" = "Reducir sangría de la lista"
 "text.listStyle" = "Estilo de lista"
+"text.loadFont" = "Cargar archivo de fuente"
 "text.maxLines" = "Máximo de líneas"
+"text.missingFonts" = "Fuentes que faltan"
 "text.numberList" = "Lista numerada"
 "text.onPath" = "Texto en trazado"
 "text.paragraphIndent" = "Sangría de párrafo"
 "text.paragraphSpacing" = "Espacio entre párrafos"
 "text.pathOptions" = "Opciones de texto en trazado"
 "text.preview" = "Previsualizar cambio de texto"
+"text.refit" = "Ajustar texto a las fuentes"
 "text.removeFromPath" = "Quitar texto del trazado"
+"text.rescanFonts" = "Volver a buscar fuentes instaladas"
 "text.set" = "Establecer texto"
 "text.setFeatures" = "Funciones OpenType"
 "text.setVariations" = "Ejes de fuente variable"
@@ -2018,10 +2228,14 @@ status = "draft — needs native review"
 "text.weightUp" = "Aumentar peso de fuente"
 "tool.arrow" = "Flecha"
 "tool.comment" = "Comentario"
+"tool.connector" = "Conector"
 "tool.ellipse" = "Elipse"
+"tool.eraser" = "Borrador"
 "tool.frame" = "Marco"
 "tool.hand" = "Mano"
+"tool.highlighter" = "Resaltador"
 "tool.line" = "Línea"
+"tool.marker" = "Rotulador"
 "tool.move" = "Mover"
 "tool.pen" = "Pluma"
 "tool.pencil" = "Lápiz"
@@ -2033,9 +2247,12 @@ status = "draft — needs native review"
 "tool.scaleAnchor" = "Ancla de escala"
 "tool.section" = "Sección"
 "tool.set" = "Elegir herramienta"
+"tool.shape" = "Formas"
 "tool.shapeBuilder" = "Generador de formas"
 "tool.slice" = "Sector"
+"tool.stamp" = "Sello"
 "tool.star" = "Estrella"
+"tool.sticky" = "Nota adhesiva"
 "tool.text" = "Texto"
 "transform.move" = "Mover"
 "transform.moveTo" = "Mover a"
@@ -2097,11 +2314,13 @@ status = "draft — needs native review"
 "vector.edit.tool" = "Herramienta de edición vectorial"
 "vector.edit.transform" = "Transformar puntos"
 "vector.edit.widthPoint" = "Punto de ancho"
+"vector.fillRule" = "Establecer regla de relleno"
 "vector.flatten" = "Acoplar"
 "vector.join" = "Unir selección"
 "vector.offset" = "Desplazar trazado"
 "vector.outlineStroke" = "Contornear trazo"
 "vector.reverse" = "Invertir dirección del trazado"
+"vector.reverseLoop" = "Invertir bucle"
 "vector.simplify" = "Simplificar vector"
 "vector.smoothJoin" = "Unir selección con suavizado"
 "version.autosave" = "Guardar versión automáticamente"
diff --git a/crates/ui-egui/locales/fi.toml b/crates/ui-egui/locales/fi.toml
new file mode 100644
index 000000000..f18ffeaf4
--- /dev/null
+++ b/crates/ui-egui/locales/fi.toml
@@ -0,0 +1,2396 @@
+# Finnish interface catalog. Original translations; MIT OR Apache-2.0.
+# AI-assisted draft; not reviewed by a human Finnish/native speaker.
+# Sentence case, imperative commands. Integer plurals: 1 taso, 0/2/21 tasoa.
+# Product names, shortcut notation, numeric glyphs and code examples retain their identity.
+# Command ids and context suffixes are immutable keys; translated text is display-only.
+# Completeness measured against the English UI and live command/menu source sets; see tests.
+
+[meta]
+name = "Suomi"
+status = "draft — needs native review"
+
+[ui]
+"% of all commits" = "% kaikista muutoksista"
+"(no longer published)" = "(ei enää julkaistu)"
+"({n} warnings: some entries were skipped)" = { one = "({n} varoitus: joitakin kohteita ohitettiin)", other = "({n} varoitusta: joitakin kohteita ohitettiin)" }
+"+ Create variable" = "+ Luo muuttuja"
+".fig (experimental)" = ".fig (kokeellinen)"
+"1…9, 0" = "1…9, 0"
+"@{login}: {prs} PRs, {commits} commits, +{added} / −{deleted} lines (Δ {delta}), +{bin_added} / −{bin_deleted} binary assets, {first} – {last}" = "@{login}: PR:t {prs}, muutokset {commits}, rivit +{added} / −{deleted} (Δ {delta}), binääriresurssit +{bin_added} / −{bin_deleted}, {first} – {last}"
+"A .figcraft file with this name already exists. Choose its full name to confirm replacement." = "Tämänniminen .figcraft-tiedosto on jo olemassa. Vahvista korvaaminen valitsemalla sen koko nimi."
+"A collection of this file with these modes and variables: override their values per mode and add variables of its own" = "Tämän tiedoston kokoelma, joka sisältää nämä tilat ja muuttujat. Voit ohittaa niiden arvot tilakohtaisesti ja lisätä omia muuttujia."
+"A layer on its own aligns to its frame: select more layers, or one in a frame" = "Yksittäinen taso tasataan kehykseensä. Valitse useampia tasoja tai yksi kehyksen sisällä oleva taso."
+"A responsive product page: hero, features, figures, a quote and a footer" = "Mukautuva tuotesivu: pääosio, ominaisuudet, tunnusluvut, lainaus ja alatunniste"
+"A spring plays until it settles: its mass, stiffness and damping set how long" = "Jousi liikkuu, kunnes se asettuu. Sen massa, jäykkyys ja vaimennus määräävät keston."
+"A title, an agenda, a big figure, a chart and a closing slide" = "Otsikko, esityslista, suuri tunnusluku, kaavio ja päätösdia"
+"A to Z" = "A:sta Z:aan"
+"About" = "Tietoja"
+"About FigCraft" = "Tietoja FigCraftista"
+"About this server" = "Tietoja tästä palvelimesta"
+"Action" = "Toiminto"
+"Actions" = "Toiminnot"
+"Actions for {name}" = "Kohteen {name} toiminnot"
+"Actions…" = "Toiminnot…"
+"Active" = "Aktiivinen"
+"Actual size (100%)" = "Todellinen koko (100 %)"
+"Add a category" = "Lisää luokka"
+"Add a comment" = "Lisää kommentti"
+"Add a description" = "Lisää kuvaus"
+"Add a frame (F) or a shape (R) to get started" = "Aloita lisäämällä kehys (F) tai muoto (R)"
+"Add a layer or component to tile first" = "Lisää ensin laatoitettava taso tai komponentti"
+"Add a note for developers" = "Lisää huomautus kehittäjille"
+"Add action" = "Lisää toiminto"
+"Add actions for when no condition holds" = "Lisää toimintoja tilanteeseen, jossa mikään ehto ei täyty"
+"Add an annotation for developers" = "Lisää huomautus kehittäjille"
+"Add another condition" = "Lisää toinen ehto"
+"Add auto layout" = "Lisää automaattinen asettelu"
+"Add background behind overlay" = "Lisää tausta peittokuvan taakse"
+"Add content to this slot" = "Lisää sisältöä tähän sisältöpaikkaan"
+"Add dev resource" = "Lisää kehittäjäresurssi"
+"Add effect" = "Lisää tehoste"
+"Add export setting" = "Lisää vientiasetus"
+"Add fill" = "Lisää täyttö"
+"Add interaction" = "Lisää vuorovaikutus"
+"Add layout grid" = "Lisää asetteluruudukko"
+"Add library" = "Lisää kirjasto"
+"Add library file…" = "Lisää kirjastotiedosto…"
+"Add max height" = "Lisää enimmäiskorkeus"
+"Add max width" = "Lisää enimmäisleveys"
+"Add min height" = "Lisää vähimmäiskorkeus"
+"Add min width" = "Lisää vähimmäisleveys"
+"Add mode" = "Lisää tila"
+"Add new page" = "Lisää uusi sivu"
+"Add or update collections from a variables JSON" = "Lisää tai päivitä kokoelmia muuttujien JSON-tiedostosta"
+"Add properties to make instances configurable" = "Lisää ominaisuuksia, jotta ilmentymiä voi mukauttaa"
+"Add reaction" = "Lisää reaktio"
+"Add starting point" = "Lisää aloituspiste"
+"Add stroke" = "Lisää reunaviiva"
+"Add variant" = "Lisää variantti"
+"Add variant with a new value" = "Lisää variantti uudella arvolla"
+"Added" = "Lisätty"
+"Added the library \"{name}\"" = "Kirjasto ”{name}” lisätty"
+"Adding to {name}" = "Lisätään kohteeseen {name}"
+"Adjust" = "Säädä"
+"Adjustment presets" = "Säädön esiasetukset"
+"Advanced" = "Lisäasetukset"
+"Advanced stroke" = "Reunaviivan lisäasetukset"
+"After delay" = "Viiveen jälkeen"
+"After delay {ms}ms" = "Viiveen {ms}ms jälkeen"
+"Align" = "Tasaa"
+"Align bottom" = "Tasaa alas"
+"Align center" = "Keskitä"
+"Align horizontal centers" = "Keskitä vaakasuunnassa"
+"Align left" = "Tasaa vasemmalle"
+"Align middle" = "Tasaa keskelle"
+"Align right" = "Tasaa oikealle"
+"Align text baselines" = "Tasaa tekstin peruslinjat"
+"Align top" = "Tasaa ylös"
+"Align vertical centers" = "Keskitä pystysuunnassa"
+"Alignment" = "Tasaus"
+"All" = "Kaikki"
+"All categories" = "Kaikki luokat"
+"All comments" = "Kaikki kommentit"
+"All components" = "Kaikki komponentit"
+"All fonts" = "Kaikki fontit"
+"All supported properties" = "Kaikki tuetut ominaisuudet"
+"All the fonts this file uses are installed" = "Kaikki tämän tiedoston käyttämät fontit on asennettu"
+"All variables" = "Kaikki muuttujat"
+"Alpha" = "Alfa"
+"Alphabetical" = "Aakkosjärjestys"
+"Alt+drag" = "Alt+drag"
+"An analytics screen on a grid: figures, charts drawn from vectors and a table" = "Analytiikkanäkymä ruudukossa: tunnuslukuja, vektoreista piirrettyjä kaavioita ja taulukko"
+"An invite link that opens FigCraft and joins" = "Kutsulinkki, joka avaa FigCraftin ja liittyy istuntoon"
+"Anchor" = "Ankkuri"
+"Android" = "Android"
+"Angular" = "Kulmaliukuväri"
+"Animation" = "Animaatio"
+"Annotations" = "Huomautukset"
+"Annotations shown on the canvas" = "Piirtoalueella näytettävät huomautukset"
+"Another server, or one that needs its key. The usual server is set in Preferences." = "Toinen palvelin tai avainta tarvitseva palvelin. Tavallinen palvelin asetetaan asetuksissa."
+"Any status" = "Kaikki tilat"
+"Anyone on your network with this code can edit the file, while this app stays open." = "Kuka tahansa lähiverkossasi voi muokata tiedostoa tällä koodilla niin kauan kuin sovellus on auki."
+"Anyone with the edit link can change the file; the view link only lets people look. The links carry their secrets: share them like passwords. `figcraft-server links` makes more and revokes them." = "Kuka tahansa muokkauslinkin saanut voi muuttaa tiedostoa. Katselulinkillä voi vain katsella. Linkit sisältävät salaiset tunnisteet: jaa niitä kuin salasanoja. `figcraft-server links` luo lisää linkkejä ja peruu niitä."
+"Anyone with this code can edit the file." = "Kuka tahansa tämän koodin saanut voi muokata tiedostoa."
+"Anyone with this code can look at the file, not change it." = "Kuka tahansa tämän koodin saanut voi katsella tiedostoa, mutta ei muuttaa sitä."
+"Appearance" = "Ulkoasu"
+"Apply a component property" = "Käytä komponentin ominaisuutta"
+"Apply variable" = "Käytä muuttujaa"
+"Apply variable to text" = "Käytä muuttujaa tekstiin"
+"Apply variable to visibility" = "Käytä muuttujaa näkyvyyteen"
+"Apps" = "Sovellukset"
+"Apr" = "huhtik."
+"Arc" = "Kaari"
+"Arc ratio" = "Kaaren suhde"
+"Arc start" = "Kaaren alku"
+"Arc sweep" = "Kaaren pyyhkäisy"
+"Archive" = "Arkistoi"
+"Archived" = "Arkistoitu"
+"Arrange" = "Järjestä"
+"Arrow" = "Nuoli"
+"Arrow at the end" = "Nuoli loppuun"
+"As typed" = "Kirjoitetussa muodossa"
+"Asking the server…" = "Kysytään palvelimelta…"
+"Assets" = "Resurssit"
+"Aug" = "elok."
+"Auto" = "Automaattinen"
+"Auto (space around)" = "Automaattinen (tila ympärillä)"
+"Auto (space between)" = "Automaattinen (tila välissä)"
+"Auto (space evenly)" = "Automaattinen (tasavälein)"
+"Auto ({mode})" = "Automaattinen ({mode})"
+"Auto columns" = "Automaattiset sarakkeet"
+"Auto gap" = "Automaattinen väli"
+"Auto height" = "Automaattinen korkeus"
+"Auto layout" = "Automaattinen asettelu"
+"Auto rows" = "Automaattiset rivit"
+"Auto width" = "Automaattinen leveys"
+"Back" = "Takaisin"
+"Back to Ready for dev" = "Palauta kehitysvalmiiksi"
+"Back to Ready for dev: the next change compares with how it is now" = "Palauta kehitysvalmiiksi: seuraavaa muutosta verrataan nykyiseen tilaan"
+"Back to assets" = "Takaisin resursseihin"
+"Back to current" = "Takaisin nykyiseen"
+"Back to styles" = "Takaisin tyyleihin"
+"Back to the FigCraft server" = "Takaisin FigCraft-palvelimelle"
+"Back to the canvas from a focused region" = "Palaa kohdistetulta alueelta piirtoalueelle"
+"Back to the current version" = "Takaisin nykyiseen versioon"
+"Back to the font's value" = "Palauta fontin arvo"
+"Back to the values the font style implies" = "Palauta fonttityylin mukaiset arvot"
+"Background" = "Tausta"
+"Background blur" = "Taustan sumennus"
+"Basics" = "Perusteet"
+"Before" = "Ennen"
+"Bend" = "Taivutus"
+"Bevel" = "Viiste"
+"Binary assets added" = "Lisätyt binääriresurssit"
+"Binary assets removed" = "Poistetut binääriresurssit"
+"Black & white" = "Mustavalkoinen"
+"Bleed" = "Leikkuuvara"
+"Bleed marks" = "Leikkuuvaramerkit"
+"Bleed marks need a bleed" = "Leikkuuvaramerkit edellyttävät leikkuuvaraa"
+"Blend" = "Sekoitus"
+"Blend mode" = "Sekoitustila"
+"Blue" = "Sininen"
+"Blur" = "Sumennus"
+"Boolean" = "Totuusarvo"
+"Boolean groups" = "Boolen ryhmät"
+"Both directions" = "Molemmat suunnat"
+"Bottom" = "Alhaalta"
+"Bottom left radius" = "Vasemman alakulman säde"
+"Bottom right radius" = "Oikean alakulman säde"
+"Bound to {name}. Click to detach the variable." = "Sidottu muuttujaan {name}. Irrota muuttuja napsauttamalla."
+"Branch" = "Haara"
+"Branch archived" = "Haara arkistoitu"
+"Branch merged" = "Haara yhdistetty"
+"Branch name" = "Haaran nimi"
+"Branch of {file}" = "Tiedoston {file} haara"
+"Branch of {file} · merged or archived" = "Tiedoston {file} haara · yhdistetty tai arkistoitu"
+"Branch updated from main" = "Haara päivitetty päähaarasta"
+"Branch {name}" = "Haara {name}"
+"Branches" = "Haarat"
+"Bring forward" = "Tuo eteenpäin"
+"Bring the main file's changes into the branch" = "Tuo päätiedoston muutokset haaraan"
+"Bring to front" = "Tuo etummaiseksi"
+"Bristle" = "Harjas"
+"Browse" = "Selaa"
+"Brush" = "Sivellin"
+"Brush rotation jitter" = "Siveltimen kierron vaihtelu"
+"Brush scatter" = "Siveltimen hajonta"
+"Brush size jitter" = "Siveltimen koon vaihtelu"
+"Brush spacing" = "Siveltimen välistys"
+"Bulleted list" = "Luettelomerkitty luettelo"
+"C or Shift+C" = "C or Shift+C"
+"C or ⇧C" = "C or ⇧C"
+"CMYK colour" = "CMYK-väri"
+"CSS custom properties…" = "CSS:n mukautetut ominaisuudet…"
+"Can edit" = "Voi muokata"
+"Can view" = "Voi katsella"
+"Can't read this library: {e}" = "Kirjastoa ei voi lukea: {e}"
+"Cancel" = "Peruuta"
+"Canvas" = "Piirtoalue"
+"Canvas stacking" = "Piirtoalueen pinoamisjärjestys"
+"Cap height to baseline" = "Versaalikorkeudesta peruslinjaan"
+"Case" = "Kirjainkoko"
+"Case-sensitive forms" = "Kirjainkokoon mukautuvat muodot"
+"Categories" = "Luokat"
+"Center" = "Keskelle"
+"Change alias" = "Vaihda alias"
+"Change resolved" = "Muutos ratkaistu"
+"Change style" = "Vaihda tyyli"
+"Change to" = "Vaihda kohteeksi"
+"Change to needs a layer inside a variant" = "Vaihto edellyttää variantin sisällä olevaa tasoa"
+"Changed" = "Muutettu"
+"Changed on both sides: keep one" = "Muutettu molemmilla puolilla: säilytä toinen"
+"Changes on main" = "Päähaaran muutokset"
+"Changes on the branch" = "Haaran muutokset"
+"Changes unknown" = "Muutokset tuntemattomia"
+"Check" = "Valintamerkki"
+"Checking the fonts installed on this computer…" = "Tarkistetaan tämän tietokoneen asennettuja fontteja…"
+"Checking the server…" = "Tarkistetaan palvelinta…"
+"Chevron" = "Kulmanuoli"
+"Choose React, Leptos, SwiftUI or Compose above to connect this component to its code." = "Valitse yllä React, Leptos, SwiftUI tai Compose yhdistääksesi tämän komponentin sen koodiin."
+"Choose another profile to change it." = "Vaihda valitsemalla toinen profiili."
+"Choose collection" = "Valitse kokoelma"
+"Choose image" = "Valitse kuva"
+"Choose mode" = "Valitse tila"
+"Choose variable" = "Valitse muuttuja"
+"Circle" = "Ympyrä"
+"Clear from this list" = "Poista tästä luettelosta"
+"Clear recent" = "Tyhjennä viimeisimmät"
+"Click + to replace mixed content" = "Korvaa vaihteleva sisältö napsauttamalla +"
+"Click anywhere on the canvas to leave one." = "Lisää huomautus napsauttamalla mitä tahansa piirtoalueen kohtaa."
+"Click or drag to merge · {alt} removes" = "Yhdistä napsauttamalla tai vetämällä · {alt} poistaa"
+"Click or drag to remove · {alt} merges" = "Poista napsauttamalla tai vetämällä · {alt} yhdistää"
+"Click to record a key" = "Tallenna näppäin napsauttamalla"
+"Clip content" = "Leikkaa sisältö rajoihin"
+"Clip to shape" = "Leikkaa muotoon"
+"Close" = "Sulje"
+"Close overlay" = "Sulje peittokuva"
+"Close preview" = "Sulje esikatselu"
+"Close tab" = "Sulje välilehti"
+"Close version history" = "Sulje versiohistoria"
+"Close when clicking outside" = "Sulje napsautettaessa ulkopuolelle"
+"Code" = "Koodi"
+"Code or invite link" = "Koodi tai kutsulinkki"
+"Code syntax" = "Koodin syntaksi"
+"Collapse" = "Tiivistä muunnokset"
+"Collapse panel" = "Supista paneeli"
+"Collection" = "Kokoelma"
+"Collections" = "Kokoelmat"
+"Color" = "Väri"
+"Color burn" = "Värivarjostus"
+"Color dodge" = "Värilisävalotus"
+"Color format" = "Värimuoto"
+"Color profile" = "Väriprofiili"
+"Color profile: {name}" = "Väriprofiili: {name}"
+"Color styles" = "Värityylit"
+"Color values in this file are in this color space." = "Tämän tiedoston väriarvot ovat tässä väriavaruudessa."
+"Color variables" = "Värimuuttujat"
+"Colour" = "Väri"
+"Colour and text styles, Light and Dark variables, buttons, inputs and cards" = "Väri- ja tekstityylejä, vaalean ja tumman tilan muuttujia, painikkeita, syötekenttiä ja kortteja"
+"Column" = "Sarake"
+"Column gap" = "Sarakkeiden väli"
+"Column sizes" = "Sarakkeiden koot"
+"Column span" = "Sarakeulottuvuus"
+"Columns" = "Sarakkeet"
+"Columns {count}" = "Sarakkeita: {count}"
+"Comment" = "Kommentti"
+"Comments" = "Kommentit"
+"Commits" = "Muutokset"
+"Company" = "Yritys"
+"Compare changes" = "Vertaa muutoksia"
+"Compatibility notes" = "Yhteensopivuushuomautukset"
+"Completed" = "Valmis"
+"Component" = "Komponentti"
+"Component name" = "Komponentin nimi"
+"Component property" = "Komponentin ominaisuus"
+"Component set" = "Komponenttijoukko"
+"Component sets" = "Komponenttijoukot"
+"Components" = "Komponentit"
+"Conditional" = "Ehdollinen"
+"Confetti" = "Konfetti"
+"Conflicts" = "Ristiriidat"
+"Connect to code" = "Yhdistä koodiin"
+"Connected" = "Yhdistetty"
+"Connected to code: {from}" = "Yhdistetty koodiin: {from}"
+"Connection lost, reconnecting (attempt {attempt})…" = "Yhteys katkesi, yhdistetään uudelleen (yritys {attempt})…"
+"Connector" = "Yhdistin"
+"Constrain proportions" = "Säilytä mittasuhteet"
+"Constraints" = "Rajoitteet"
+"Content" = "Sisältö"
+"Contents hidden" = "Sisältö kätketty"
+"Contents only" = "Vain sisältö"
+"Contextual alternates" = "Kontekstuaaliset vaihtoehdot"
+"Contrast" = "Kontrasti"
+"Contributors" = "Tekijät"
+"Contributors: {people} · Commits: {commits}" = "Tekijät: {people} · Muutokset: {commits}"
+"Controller" = "Ohjain"
+"Convert to frame" = "Muunna kehykseksi"
+"Convert to section" = "Muunna osioksi"
+"Cool" = "Viileä"
+"Copied as CSS" = "Kopioitu CSS-muodossa"
+"Copied as PNG" = "Kopioitu PNG-muodossa"
+"Copied as SVG" = "Kopioitu SVG-muodossa"
+"Copied as text" = "Kopioitu tekstinä"
+"Copied {value}" = "Kopioitu: {value}"
+"Copy" = "Kopioi"
+"Copy as" = "Kopioi muodossa"
+"Copy as CSS" = "Kopioi CSS-muodossa"
+"Copy as PNG" = "Kopioi PNG-muodossa"
+"Copy as SVG" = "Kopioi SVG-muodossa"
+"Copy code" = "Kopioi koodi"
+"Copy link" = "Kopioi linkki"
+"Copy the {label}" = "Kopioi: {label}"
+"Copy {value}" = "Kopioi: {value}"
+"Corner radius" = "Kulman säde"
+"Corner smoothing" = "Kulman pehmennys"
+"Couldn't download the variables" = "Muuttujia ei voitu ladata"
+"Couldn't reach {server}: showing what this computer remembers." = "Palvelimeen {server} ei saatu yhteyttä. Näytetään tämän tietokoneen muistamat tiedot."
+"Couldn't read {name}." = "Tiedostoa {name} ei voitu lukea."
+"Couldn't save automatically: {error}" = "Automaattinen tallennus epäonnistui: {error}"
+"Count" = "Määrä"
+"Create" = "Luo"
+"Create a variable collection first" = "Luo ensin muuttujakokoelma"
+"Create a variable first" = "Luo ensin muuttuja"
+"Create alias" = "Luo alias"
+"Create branch" = "Luo haara"
+"Create collection" = "Luo kokoelma"
+"Create component" = "Luo komponentti"
+"Create component property" = "Luo komponentin ominaisuus"
+"Create components, styles or variables to publish them as a library." = "Luo komponentteja, tyylejä tai muuttujia, jotta voit julkaista ne kirjastona."
+"Create property…" = "Luo ominaisuus…"
+"Create style" = "Luo tyyli"
+"Create style from the selected text" = "Luo tyyli valitusta tekstistä"
+"Created" = "Luotu"
+"Crop" = "Rajaa"
+"Crop marks" = "Leikkausmerkit"
+"Ctrl+arrows" = "Ctrl+arrows"
+"Ctrl+click" = "Ctrl+click"
+"Ctrl+scroll" = "Ctrl+scroll"
+"Current name" = "Nykyinen nimi"
+"Current version" = "Nykyinen versio"
+"Cursor chat" = "Kohdistinkeskustelu"
+"Custom" = "Mukautettu"
+"Custom size" = "Mukautettu koko"
+"Cut" = "Leikkaa"
+"Dark" = "Tumma"
+"Darken" = "Tummenna"
+"Dash" = "Katkoviiva"
+"Dashboard" = "Koontinäkymä"
+"Date created" = "Luontipäivä"
+"Dec" = "jouluk."
+"Decoration" = "Koristelu"
+"Decoration style" = "Koristelun tyyli"
+"Deep select" = "Valitse sisäkkäinen kohde"
+"Default" = "Oletus"
+"Default content" = "Oletussisältö"
+"Default value (the top-left variant)" = "Oletusarvo (vasemman yläkulman variantti)"
+"Delay" = "Viive"
+"Delete" = "Poista"
+"Delete category (its annotations stay)" = "Poista luokka (sen huomautukset säilyvät)"
+"Delete collection" = "Poista kokoelma"
+"Delete group" = "Poista ryhmä"
+"Delete mode" = "Poista tila"
+"Delete page" = "Poista sivu"
+"Delete preset" = "Poista esiasetus"
+"Delete property" = "Poista ominaisuus"
+"Delete the style (layers keep their values)" = "Poista tyyli (tasojen arvot säilyvät)"
+"Delete thread" = "Poista keskustelu"
+"Delete variable" = "Poista muuttuja"
+"Delete “{name}”? This can't be undone." = "Poistetaanko ”{name}”? Tätä ei voi kumota."
+"Density" = "Tiheys"
+"Depth" = "Syvyys"
+"Describe how and when to use this component" = "Kuvaile, miten ja milloin tätä komponenttia käytetään"
+"Describe what changed" = "Kuvaile muutokset"
+"Description" = "Kuvaus"
+"Description (optional)" = "Kuvaus (valinnainen)"
+"Design" = "Suunnittelu"
+"Design panel" = "Suunnittelupaneeli"
+"Design system starter" = "Muotoilujärjestelmän aloituspohja"
+"Desktop" = "Työpöytä"
+"Destination" = "Kohde"
+"Detach alias" = "Irrota alias"
+"Detach instance" = "Irrota ilmentymä"
+"Detach property" = "Irrota ominaisuus"
+"Detach style" = "Irrota tyyli"
+"Detach styles" = "Irrota tyylit"
+"Detach variable" = "Irrota muuttuja"
+"Details" = "Tiedot"
+"Dev Mode" = "Kehittäjätila"
+"Dev resources" = "Kehittäjäresurssit"
+"Development" = "Kehitys"
+"Device" = "Laite"
+"Device at 100%" = "Laite koossa 100 %"
+"Diamond" = "Vinoneliö"
+"Difference" = "Erotus"
+"Dimensions" = "Mitat"
+"Direction" = "Suunta"
+"Disconnect from code" = "Katkaise yhteys koodiin"
+"Dispersion" = "Hajonta"
+"Display name" = "Näyttönimi"
+"Dissolve" = "Häivytys"
+"Distribute and tidy" = "Jaa ja järjestä"
+"Distribute horizontal spacing" = "Jaa vaakavälit tasan"
+"Distribute vertical spacing" = "Jaa pystyvälit tasan"
+"Divider" = "Erotin"
+"Don't Save" = "Älä tallenna"
+"Don't truncate" = "Älä lyhennä"
+"Done" = "Valmis"
+"Done editing" = "Lopeta muokkaus"
+"Dots" = "Pisteet"
+"Dotted" = "Pisteviiva"
+"Down" = "Alas"
+"Drafts" = "Luonnokset"
+"Drag the stroke to add a width point" = "Lisää leveyspiste vetämällä reunaviivaa"
+"Draw" = "Piirrä"
+"Draw a frame" = "Piirrä kehys"
+"Drawing tools" = "Piirtotyökalut"
+"Drop a .figcraft, .fig, .json, .svg or image file." = "Pudota .figcraft-, .fig-, .json-, .svg- tai kuvatiedosto."
+"Drop shadow" = "Heittovarjo"
+"Drop to import" = "Tuo pudottamalla"
+"Drop to open" = "Avaa pudottamalla"
+"Dual-licensed MIT OR Apache-2.0. Made by the ArtCraft team and community." = "Kaksoislisensoitu: MIT OR Apache-2.0. ArtCraft-tiimin ja yhteisön tekemä."
+"Duo" = "Kaksivärinen"
+"Duplicate" = "Monista"
+"Duplicate by dragging" = "Monista vetämällä"
+"Duplicate mode" = "Monista tila"
+"Duplicate page" = "Monista sivu"
+"Edit" = "Muokkaa"
+"Edit as an expression" = "Muokkaa lausekkeena"
+"Edit colour" = "Muokkaa väriä"
+"Edit comment" = "Muokkaa kommenttia"
+"Edit dev resource" = "Muokkaa kehittäjäresurssia"
+"Edit link" = "Muokkaa linkkiä"
+"Edit link copied" = "Muokkauslinkki kopioitu"
+"Edit style" = "Muokkaa tyyliä"
+"Edit variable" = "Muokkaa muuttujaa"
+"Edit with the builder" = "Muokkaa rakentimella"
+"Edited {when}" = "Muokattu {when}"
+"Effect settings" = "Tehosteen asetukset"
+"Effect styles" = "Tehostetyylit"
+"Effects" = "Tehosteet"
+"Elbow" = "Kulmikas"
+"Ellipse" = "Ellipsi"
+"Ellipses" = "Ellipsit"
+"Else" = "Muuten"
+"Else if" = "Muuten jos"
+"Embedded profile" = "Upotettu profiili"
+"Empty" = "Tyhjä"
+"End" = "Loppu"
+"End point" = "Loppupiste"
+"Ends the session; everyone keeps their copy" = "Lopettaa istunnon. Kaikki säilyttävät oman kopionsa."
+"Enter" = "Enter"
+"Enter the address of a figcraft-server and press Browse to see the plugins it offers." = "Anna figcraft-server-palvelimen osoite ja näytä sen tarjoamat liitännäiset painamalla Selaa."
+"Enter to save · Esc to cancel" = "Tallenna Enterillä · peruuta Escillä"
+"Eraser" = "Pyyhekumi"
+"Esc" = "Esc"
+"Essential" = "Olennainen"
+"Every conflict has a choice." = "Jokaiselle ristiriidalle on valittu ratkaisu."
+"Every top-level frame already starts a flow" = "Jokainen ylimmän tason kehys aloittaa jo kulun"
+"Exact opacity (4 then 5: 45%)" = "Tarkka peittävyys (4 ja sitten 5: 45 %)"
+"Exclude" = "Jätä pois"
+"Excluded" = "Jätetty pois"
+"Excluded from layout" = "Jätetty pois asettelusta"
+"Excludes" = "Poissulkee"
+"Exclusion" = "Poissulku"
+"Exit focus view (Esc)" = "Poistu kohdistusnäkymästä (Esc)"
+"Expand" = "Laajenna"
+"Export" = "Vie"
+"Export all" = "Vie kaikki"
+"Export frames and layers as PNG, JPG, SVG or PDF" = "Vie kehyksiä ja tasoja PNG-, JPG-, SVG- tai PDF-muodossa"
+"Export page as PNG" = "Vie sivu PNG-muodossa"
+"Export settings" = "Vientiasetukset"
+"Export variables" = "Vie muuttujat"
+"Export {name}" = "Vie {name}"
+"Export {n} layers" = { one = "Vie {n} taso", other = "Vie {n} tasoa" }
+"Exported {file}" = "Viety: {file}"
+"Exported {name}" = "Viety: {name}"
+"Exported {name}; {n} kinds of content were left out" = { one = "Viety {name}; {n} sisältötyyppi jätettiin pois", other = "Viety {name}; {n} sisältötyyppiä jätettiin pois" }
+"Exported {n} files" = { one = "Viety {n} tiedosto", other = "Viety {n} tiedostoa" }
+"Export…" = "Vie…"
+"Expose properties to instances" = "Tuo ominaisuudet ilmentymien käyttöön"
+"Exposure" = "Valotus"
+"Expression" = "Lauseke"
+"Extend collection" = "Laajenna kokoelmaa"
+"Extends \"{name}\": overridden values are marked" = "Laajentaa kokoelmaa ”{name}”: ohitetut arvot on merkitty"
+"Eye" = "Silmä"
+"F" = "F"
+"Fade" = "Häivytys"
+"False" = "Epätosi"
+"Feb" = "helmik."
+"Fetching from the server…" = "Haetaan palvelimelta…"
+"FigCraft couldn't open its window: {error}" = "FigCraft ei voinut avata ikkunaansa: {error}"
+"FigCraft doesn't support every feature of these files yet. The notes list what was left out or changed in the imported copy; the original file is unchanged." = "FigCraft ei vielä tue näiden tiedostojen kaikkia ominaisuuksia. Huomautukset kertovat, mitä tuodusta kopiosta jätettiin pois tai muutettiin. Alkuperäinen tiedosto säilyy ennallaan."
+"File" = "Tiedosto"
+"File name" = "Tiedostonimi"
+"File not found" = "Tiedostoa ei löydy"
+"File published" = "Tiedosto julkaistu"
+"Files aren't end-to-end encrypted: the server's operator can read them." = "Tiedostoja ei salata päästä päähän. Palvelimen ylläpitäjä voi lukea ne."
+"Files nobody opens for {n} days are deleted." = { one = "Tiedostot, joita kukaan ei avaa {n} päivään, poistetaan.", other = "Tiedostot, joita kukaan ei avaa {n} päivään, poistetaan." }
+"Fill" = "Täyttö"
+"Fill (fr)" = "Täytä (fr)"
+"Fill container" = "Täytä säilö"
+"Fill window" = "Täytä ikkuna"
+"Fills" = "Täytöt"
+"Fill|sizing" = "Täytä"
+"Filter and sort" = "Suodata ja lajittele"
+"Find" = "Etsi"
+"Find and replace" = "Etsi ja korvaa"
+"Find layers" = "Etsi tasoja"
+"First" = "Ensimmäinen"
+"First commit" = "Ensimmäinen muutos"
+"First on top" = "Ensimmäinen päällimmäisenä"
+"Fit" = "Sovita"
+"Fit device to window" = "Sovita laite ikkunaan"
+"Fit to contents" = "Sovita sisältöön"
+"Fit to window" = "Sovita ikkunaan"
+"Fit width" = "Sovita leveyteen"
+"Fixed" = "Kiinteä"
+"Fixed gap" = "Kiinteä väli"
+"Fixed size" = "Kiinteä koko"
+"Flatten" = "Yhdistä vektorimuodoksi"
+"Flip" = "Peilaa"
+"Flip horizontal" = "Peilaa vaakasuunnassa"
+"Flip text to the other side" = "Siirrä teksti toiselle puolelle"
+"Flip vertical" = "Peilaa pystysuunnassa"
+"Flip width profile" = "Peilaa leveysprofiili"
+"Flow starting point" = "Kulun aloituspiste"
+"Flow starting points" = "Kulkujen aloituspisteet"
+"Flows" = "Kulut"
+"Focus view" = "Kohdistusnäkymä"
+"Fold autosaves" = "Tiivistä automaattiset tallennukset"
+"Folder: click to collapse" = "Kansio: supista napsauttamalla"
+"Folder: click to expand" = "Kansio: laajenna napsauttamalla"
+"Follow" = "Seuraa"
+"Follow {name}" = "Seuraa käyttäjää {name}"
+"Following" = "Seurataan"
+"Following {name} · {key} to stop" = "Seurataan käyttäjää {name} · lopeta painamalla {key}"
+"Font" = "Fontti"
+"Font not installed" = "Fonttia ei ole asennettu"
+"Font size" = "Fonttikoko"
+"Font style" = "Fonttityyli"
+"Forget on this computer" = "Unohda tällä tietokoneella"
+"Four screens of a trail app with components and a prototype flow" = "Retkeilysovelluksen neljä näkymää, komponentit ja prototyypin kulku"
+"Fractions" = "Murtoluvut"
+"Frame" = "Kehys"
+"Frame selection" = "Kehystä valinta"
+"Frame tools" = "Kehystyökalut"
+"Frames" = "Kehykset"
+"From the library \"{name}\": read-only" = "Kirjastosta ”{name}”: vain luku"
+"From {name}" = "Lähteestä {name}"
+"From {server}" = "Palvelimelta {server}"
+"Frost" = "Huurre"
+"Gap" = "Väli"
+"Gap between columns" = "Sarakkeiden väli"
+"Gap between items" = "Kohteiden väli"
+"Gap between rows" = "Rivien väli"
+"Getting started" = "Aloittaminen"
+"Give the address of a server open to the public, or a server's address with its key (`figcraft-server key` prints it)." = "Anna julkisen palvelimen osoite tai palvelimen osoite avaimineen (`figcraft-server key` tulostaa avaimen)."
+"Glass" = "Lasi"
+"Go to main component" = "Siirry pääkomponenttiin"
+"Go to {name}" = "Siirry kohteeseen {name}"
+"Grab bag" = "Sekalaiset"
+"Gradient" = "Liukuväri"
+"Gray" = "Harmaa"
+"Green" = "Vihreä"
+"Greyscale components and two example screens to sketch a flow with" = "Harmaasävykomponentit ja kaksi esimerkkinäkymää kulun luonnosteluun"
+"Grid" = "Ruudukko"
+"Grid ({size})" = "Ruudukko ({size})"
+"Grid styles" = "Ruudukkotyylit"
+"Grid {size}" = "Ruudukko {size}"
+"Group" = "Ryhmä"
+"Group selection" = "Ryhmittele valinta"
+"Groups" = "Ryhmät"
+"Gutter" = "Palstaväli"
+"Hand tool" = "Käsityökalu"
+"Hanging list" = "Riippuva luettelo"
+"Hanging punctuation" = "Välimerkkien ulonnus"
+"Hard light" = "Kova valo"
+"Heart" = "Sydän"
+"Height" = "Korkeus"
+"Help" = "Ohje"
+"Help and resources" = "Ohje ja resurssit"
+"Help page" = "Ohjesivu"
+"Here: {names}" = "Paikalla: {names}"
+"Hidden" = "Kätketty"
+"Hide contents" = "Kätke sisältö"
+"Hide from publishing" = "Jätä julkaisematta"
+"Hide section contents" = "Kätke osion sisältö"
+"Hide these tips (Getting started in the Help menu shows them again)" = "Kätke nämä vinkit (Ohje-valikon Aloittaminen näyttää ne uudelleen)"
+"Hide when publishing" = "Kätke julkaistaessa"
+"Highlight layers on hover" = "Korosta tasot osoitettaessa"
+"Highlighter" = "Korostuskynä"
+"Highlights" = "Huippuvalot"
+"Hold Alt" = "Pidä Alt painettuna"
+"Hold Alt+Z" = "Pidä Alt+Z painettuna"
+"Hold Ctrl" = "Pidä Ctrl painettuna"
+"Hold Z" = "Pidä Z painettuna"
+"Hold ⌃ or ⌘" = "Pidä ⌃ tai ⌘ painettuna"
+"Hold ⌥" = "Pidä ⌥ painettuna"
+"Hold ⌥Z" = "Pidä ⌥Z painettuna"
+"Home" = "Aloitus"
+"Horizontal" = "Vaakasuunta"
+"Horizontal align" = "Vaakatasaus"
+"Horizontal hex" = "Vaakasuuntainen kuusikulmio"
+"Horizontal padding" = "Vaakasuuntainen sisämarginaali"
+"Horizontal spacing" = "Vaakavälistys"
+"Hosted by {operator}" = "Ylläpitäjä: {operator}"
+"Hover a layer to see its properties" = "Näytä tason ominaisuudet viemällä osoitin sen päälle"
+"Hover other layers to measure the distance" = "Mittaa etäisyys viemällä osoitin muiden tasojen päälle"
+"Hue" = "Sävy"
+"Hug" = "Sovita sisältöön"
+"Hug contents" = "Sovita sisältöön"
+"Icon components on a 24 px grid with keylines and a size preview" = "Kuvakekomponentteja 24 px:n ruudukossa, apulinjat ja koon esikatselu"
+"Icon set starter" = "Kuvakejoukon aloituspohja"
+"If" = "Jos"
+"If it keeps happening, please report it at {link} with this message." = "Jos ongelma jatkuu, ilmoita siitä osoitteessa {link} ja liitä tämä viesti mukaan."
+"If {condition}" = "Jos {condition}"
+"Ignore auto layout (absolute position)" = "Ohita automaattinen asettelu (absoluuttinen sijainti)"
+"Image" = "Kuva"
+"Images" = "Kuvat"
+"Import" = "Tuo"
+"Import path" = "Tuontipolku"
+"Import plugin from manifest" = "Tuo liitännäinen manifestista"
+"Import plugin from manifest…" = "Tuo liitännäinen manifestista…"
+"Import report" = "Tuontiraportti"
+"Import variables" = "Tuo muuttujat"
+"Imported document" = "Tuotu asiakirja"
+"Imported {name}" = "Tuotu: {name}"
+"Imported {n} new variables, updated {updated}" = { one = "Tuotu {n} uusi muuttuja, päivitetty {updated}", other = "Tuotu {n} uutta muuttujaa, päivitetty {updated}" }
+"Import…" = "Tuo…"
+"In an instance, this comes from the main component" = "Ilmentymässä tämä arvo tulee pääkomponentista"
+"In the browser you can join sessions the desktop app hosts and files on a FigCraft server. A page opened over https reaches other computers only through wss:// links (a server behind TLS)." = "Selaimessa voit liittyä työpöytäsovelluksen isännöimiin istuntoihin ja FigCraft-palvelimen tiedostoihin. https-sivu tavoittaa muut tietokoneet vain wss://-linkeillä (TLS:n takana oleva palvelin)."
+"Include bounding box" = "Sisällytä rajauslaatikko"
+"Include id attribute" = "Sisällytä id-määrite"
+"Included" = "Sisällytetty"
+"Included in layout" = "Sisällytetty asetteluun"
+"Individual corners" = "Kulmat erikseen"
+"Individual strokes" = "Reunaviivat erikseen"
+"Ink" = "Muste"
+"Inner shadow" = "Sisävarjo"
+"Inside" = "Sisäpuolella"
+"Inspect" = "Tarkastele"
+"Inspect the layer under the pointer: size, colours, typography" = "Tarkastele osoittimen alla olevaa tasoa: koko, värit ja typografia"
+"Install" = "Asenna"
+"Install plugin" = "Asenna liitännäinen"
+"Installed" = "Asennettu"
+"Installed {name}" = "Asennettu: {name}"
+"Installing…" = "Asennetaan…"
+"Instance" = "Ilmentymä"
+"Instance properties" = "Ilmentymän ominaisuudet"
+"Instance swap" = "Ilmentymän vaihto"
+"Instance swap (no other component)" = "Ilmentymän vaihto (ei muuta komponenttia)"
+"Instances" = "Ilmentymät"
+"Instant" = "Välitön"
+"Intensity" = "Vahvuus"
+"Interaction" = "Vuorovaikutus"
+"Interactions" = "Vuorovaikutukset"
+"Interface design and prototyping. A free, open-source, clean-room design tool written from scratch in Rust, part of the ArtCraft Crafting Apps." = "Käyttöliittymien suunnittelu ja prototyypit. Ilmainen avoimen lähdekoodin suunnittelutyökalu, joka on toteutettu riippumattomasti alusta alkaen Rustilla. Osa ArtCraft-sovellusperhettä."
+"Intersect" = "Leikkaus"
+"Intersects" = "Leikkaa"
+"Invalid color" = "Virheellinen väri"
+"Invite link" = "Kutsulinkki"
+"Invite link copied" = "Kutsulinkki kopioitu"
+"It asks permission to:" = "Se pyytää oikeutta:"
+"Jan" = "tammik."
+"Join" = "Liity"
+"Join code copied" = "Liittymiskoodi kopioitu"
+"Join code or invite link" = "Liittymiskoodi tai kutsulinkki"
+"Join live session" = "Liity reaaliaikaiseen istuntoon"
+"Join us on Discord" = "Liity yhteisöömme Discordissa"
+"Join with a code" = "Liity koodilla"
+"Joined" = "Liitytty"
+"Joined {file}" = "Liitytty tiedostoon {file}"
+"Joining…" = "Liitytään…"
+"Join|stroke" = "Liitos"
+"Jul" = "heinäk."
+"Jun" = "kesäk."
+"Just now" = "Juuri nyt"
+"Justify" = "Tasaa molemmat reunat"
+"Keep appearance" = "Säilytä ulkoasu"
+"Keep appearance converts every color value to {profile} so colors look the same. Keep values leaves the numbers as they are, so colors shift." = "Säilytä ulkoasu muuntaa kaikki väriarvot profiiliin {profile}, jotta värit näyttävät samoilta. Säilytä arvot jättää lukuarvot ennalleen, jolloin värit muuttuvat."
+"Keep tool selected after use" = "Pidä työkalu valittuna käytön jälkeen"
+"Keep values" = "Säilytä arvot"
+"Key/Gamepad" = "Näppäin/peliohjain"
+"Key/Gamepad {key}" = "Näppäin/peliohjain {key}"
+"Keyboard shortcuts" = "Pikanäppäimet"
+"Kits" = "Paketit"
+"Landing page" = "Laskeutumissivu"
+"Language" = "Kieli"
+"Lasso" = "Lasso"
+"Last" = "Viimeinen"
+"Last change: {note}" = "Viimeisin muutos: {note}"
+"Last commit" = "Viimeisin muutos"
+"Last modified" = "Viimeksi muokattu"
+"Last on top" = "Viimeinen päällimmäisenä"
+"Layer blur" = "Tason sumennus"
+"Layer name" = "Tason nimi"
+"Layers" = "Tasot"
+"Layers in an instance take their position from the main component" = "Ilmentymän tasot saavat sijaintinsa pääkomponentista"
+"Layout" = "Asettelu"
+"Layout grid" = "Asetteluruudukko"
+"Layout grid settings" = "Asetteluruudukon asetukset"
+"Layout grids" = "Asetteluruudukot"
+"Leave session" = "Poistu istunnosta"
+"Leaves" = "Lehdet"
+"Left" = "Vasen"
+"Left & right" = "Vasen ja oikea"
+"Left side" = "Vasen puoli"
+"Left side width" = "Vasemman puolen leveys"
+"Letter case" = "Kirjainkoko"
+"Letter spacing" = "Merkkiväli"
+"Libraries" = "Kirjastot"
+"Libraries in this file" = "Tämän tiedoston kirjastot"
+"Library updates available" = "Kirjastopäivityksiä saatavilla"
+"Library: click to collapse" = "Kirjasto: supista napsauttamalla"
+"Library: click to expand" = "Kirjasto: laajenna napsauttamalla"
+"Library: its variables are read-only here; edit them in the library file and publish it" = "Kirjasto: sen muuttujat ovat tässä vain luettavissa. Muokkaa niitä kirjastotiedostossa ja julkaise se."
+"Light" = "Vaalea"
+"Lighten" = "Vaalenna"
+"Light|glass" = "Valo"
+"Line" = "Viiva"
+"Line arrow" = "Viivanuoli"
+"Line delta" = "Rivimuutos"
+"Line height" = "Rivikorkeus"
+"Linear" = "Lineaarinen"
+"Lines" = "Viivat"
+"Lines +/−" = "Rivit +/−"
+"Lines added" = "Lisätyt rivit"
+"Lines deleted" = "Poistetut rivit"
+"Link" = "Linkki"
+"Link copied" = "Linkki kopioitu"
+"Link docs, code or tickets for developers." = "Linkitä dokumentaatiota, koodia tai tehtäviä kehittäjille."
+"Link frames on the Prototype tab, then present the flow" = "Linkitä kehykset Prototyyppi-välilehdellä ja esitä sitten kulku"
+"Link this component to its code component: instances then show your real snippet with their values." = "Yhdistä tämä komponentti sen koodikomponenttiin. Ilmentymät näyttävät sitten todellisen koodikatkelmasi omilla arvoillaan."
+"List spacing" = "Luettelon välistys"
+"List style" = "Luettelotyyli"
+"Live session" = "Reaaliaikainen istunto"
+"Live · {people}" = "Reaaliaikainen · {people}"
+"Local components" = "Paikalliset komponentit"
+"Local network" = "Paikallisverkko"
+"Local styles" = "Paikalliset tyylit"
+"Local variables" = "Paikalliset muuttujat"
+"Lock/Unlock" = "Lukitse/avaa lukitus"
+"Locked" = "Lukittu"
+"Lowercase" = "Pienet kirjaimet"
+"Luminance" = "Luminanssi"
+"Luminosity" = "Valoisuus"
+"Main" = "Päähaara"
+"Main component deleted" = "Pääkomponentti poistettu"
+"Main menu" = "Päävalikko"
+"Make a component" = "Luo komponentti"
+"Make slot" = "Luo sisältöpaikka"
+"Mar" = "maalisk."
+"Margin" = "Marginaali"
+"Mark all as read" = "Merkitse kaikki luetuiksi"
+"Mark as resolved" = "Merkitse ratkaistuksi"
+"Mark as unread" = "Merkitse lukemattomaksi"
+"Mark as unresolved" = "Merkitse ratkaisemattomaksi"
+"Marker" = "Tussi"
+"Mask" = "Maski"
+"Mass · Stiffness · Damping" = "Massa · jäykkyys · vaimennus"
+"Match (empty: the whole name)" = "Etsittävä (tyhjä: koko nimi)"
+"Max H" = "Enimmäiskorkeus"
+"Max W" = "Enimmäisleveys"
+"Max lines" = "Rivien enimmäismäärä"
+"Maximize" = "Suurenna"
+"May" = "toukok."
+"Measure to the selection" = "Mittaa valintaan"
+"Merge into main" = "Yhdistä päähaaraan"
+"Merge regions" = "Yhdistä alueet"
+"Merge the branch into the main file (one undo step) and archive it" = "Yhdistä haara päätiedostoon (yksi kumottava toiminto) ja arkistoi se"
+"Merged" = "Yhdistetty"
+"Merged PRs" = "Yhdistetyt PR:t"
+"Min H" = "Vähimmäiskorkeus"
+"Min W" = "Vähimmäisleveys"
+"Minimize" = "Pienennä"
+"Mirror angle" = "Peilaa kulma"
+"Mirror angle and length" = "Peilaa kulma ja pituus"
+"Mirroring" = "Peilaus"
+"Missing" = "Puuttuu"
+"Missing fonts" = "Puuttuvat fontit"
+"Missing layer" = "Puuttuva taso"
+"Missing style" = "Puuttuva tyyli"
+"Missing variable" = "Puuttuva muuttuja"
+"Miter" = "Jiiri"
+"Miter angle" = "Jiirikulma"
+"Mixed" = "Useita arvoja"
+"Mixed fonts" = "Useita fontteja"
+"Mixed interactions: click + to replace them" = "Vaihtelevia vuorovaikutuksia: korvaa napsauttamalla +"
+"Mobile app" = "Mobiilisovellus"
+"Mode" = "Tila"
+"Model" = "Malli"
+"Models" = "Mallit"
+"Mono" = "Yksivärinen"
+"More" = "Lisää"
+"More instance actions" = "Lisää ilmentymän toimintoja"
+"Mouse down" = "Hiiren painallus"
+"Mouse enter" = "Osoitin saapuu"
+"Mouse leave" = "Osoitin poistuu"
+"Mouse up" = "Hiiren vapautus"
+"Move" = "Siirrä"
+"Move along the toolbar or the layer rows" = "Siirry työkalurivillä tai tasoriveillä"
+"Move column left" = "Siirrä sarake vasemmalle"
+"Move column right" = "Siirrä sarake oikealle"
+"Move down" = "Siirrä alas"
+"Move in" = "Siirry sisään"
+"Move out" = "Siirry ulos"
+"Move tools" = "Siirtotyökalut"
+"Move up" = "Siirrä ylös"
+"Moved to {name}" = "Siirretty kohteeseen {name}"
+"Multi" = "Monivärinen"
+"Multiply" = "Kerro"
+"Muted" = "Hillitty"
+"Name" = "Nimi"
+"Name (A–Z)" = "Nimi (A–Z)"
+"Named instance" = "Nimetty ilmentymä"
+"Navigate to" = "Siirry kohteeseen"
+"Nested instance" = "Sisäkkäinen ilmentymä"
+"New board" = "Uusi taulu"
+"New design file" = "Uusi suunnittelutiedosto"
+"Newest first" = "Uusimmat ensin"
+"Next frame" = "Seuraava kehys"
+"Next or previous control in the focused region" = "Seuraava tai edellinen säädin kohdistetulla alueella"
+"Next ready for dev" = "Seuraava kehitysvalmis"
+"Next size option" = "Seuraava kokovaihtoehto"
+"No assets: no export settings, icons or images. Add export settings in the Design tab." = "Ei resursseja: ei vientiasetuksia, kuvakkeita tai kuvia. Lisää vientiasetuksia Suunnittelu-välilehdellä."
+"No boolean variables fit here." = "Tähän ei sovi totuusarvomuuttujia."
+"No boolean variables yet. Create them in Local variables." = "Ei vielä totuusarvomuuttujia. Luo niitä Paikalliset muuttujat -näkymässä."
+"No branches. A branch is a copy of the file to try changes in, then review and merge." = "Ei haaroja. Haara on tiedoston kopio, jossa voi kokeilla muutoksia ja sitten tarkistaa ja yhdistää ne."
+"No category" = "Ei luokkaa"
+"No changes" = "Ei muutoksia"
+"No color styles" = "Ei värityylejä"
+"No colour variables fit here." = "Tähän ei sovi värimuuttujia."
+"No colour variables yet. Create them in Local variables." = "Ei vielä värimuuttujia. Luo niitä Paikalliset muuttujat -näkymässä."
+"No comments yet" = "Ei vielä kommentteja"
+"No compatibility warnings reported" = "Yhteensopivuusvaroituksia ei ilmoitettu"
+"No components yet. Select layers and press {keys}." = "Ei vielä komponentteja. Valitse tasoja ja paina {keys}."
+"No conflicts." = "Ei ristiriitoja."
+"No contributor data was built into this copy." = "Tähän versioon ei ole sisällytetty tekijätietoja."
+"No device" = "Ei laitetta"
+"No files or templates match your search" = "Hakua vastaavia tiedostoja tai malleja ei löydy"
+"No fonts match" = "Vastaavia fontteja ei löydy"
+"No join code here (the server is older than join codes, or this address can't be put in one): share the link instead." = "Liittymiskoodia ei ole (palvelin on liittymiskoodeja vanhempi tai tätä osoitetta ei voi sisällyttää koodiin). Jaa linkki sen sijaan."
+"No layer changes to show." = "Ei näytettäviä tasomuutoksia."
+"No libraries yet. Add a .figcraft file that was published as a library, or paste a team library's link." = "Ei vielä kirjastoja. Lisää kirjastona julkaistu .figcraft-tiedosto tai liitä tiimikirjaston linkki."
+"No list" = "Ei luetteloa"
+"No matching comments" = "Vastaavia kommentteja ei löydy"
+"No matching components" = "Vastaavia komponentteja ei löydy"
+"No matching layers" = "Vastaavia tasoja ei löydy"
+"No matching styles" = "Vastaavia tyylejä ei löydy"
+"No matching variables" = "Vastaavia muuttujia ei löydy"
+"No mirroring" = "Ei peilausta"
+"No model credits were built into this copy." = "Tähän versioon ei ole sisällytetty mallien tekijätietoja."
+"No number variables fit here." = "Tähän ei sovi lukumuuttujia."
+"No number variables yet. Create them in Local variables." = "Ei vielä lukumuuttujia. Luo niitä Paikalliset muuttujat -näkymässä."
+"No other pages" = "Ei muita sivuja"
+"No paints" = "Ei täyttöjä"
+"No plugins on {server}." = "Palvelimella {server} ei ole liitännäisiä."
+"No plugins yet. Import a development plugin from its figcraft-plugin.json." = "Ei vielä liitännäisiä. Tuo kehitysliitännäinen sen figcraft-plugin.json-tiedostosta."
+"No preferred components" = "Ei ensisijaisia komponentteja"
+"No preset" = "Ei esiasetusta"
+"No saved versions yet. Save a version to mark a point in your work you can come back to." = "Ei vielä tallennettuja versioita. Tallenna versio, jotta voit palata tähän työvaiheeseen myöhemmin."
+"No scrolling" = "Ei vieritystä"
+"No shortcuts match" = "Vastaavia pikanäppäimiä ei löydy"
+"No status" = "Ei tilaa"
+"No string variables fit here." = "Tähän ei sovi merkkijonomuuttujia."
+"No string variables yet. Create them in Local variables." = "Ei vielä merkkijonomuuttujia. Luo niitä Paikalliset muuttujat -näkymässä."
+"No styles yet." = "Ei vielä tyylejä."
+"No styles yet. Click + to create one from the selection." = "Ei vielä tyylejä. Luo tyyli valinnasta napsauttamalla +."
+"No templates match your search" = "Hakua vastaavia malleja ei löydy"
+"No text styles yet. Click + to create one from the selected text." = "Ei vielä tekstityylejä. Luo tyyli valitusta tekstistä napsauttamalla +."
+"No variables fit here." = "Tähän ei sovi muuttujia."
+"No variables yet. Create them in Local variables." = "Ei vielä muuttujia. Luo niitä Paikalliset muuttujat -näkymässä."
+"Nobody else is here yet" = "Kukaan muu ei ole vielä paikalla"
+"Noise" = "Kohina"
+"None" = "Ei mitään"
+"None." = "Ei mitään."
+"Normal" = "Normaali"
+"Not bound" = "Ei sidottu"
+"Not in a live session" = "Ei reaaliaikaisessa istunnossa"
+"Not in this font" = "Ei tässä fontissa"
+"Not properties, kept as written: {names}" = "Eivät ole ominaisuuksia, säilytetään sellaisinaan: {names}"
+"Not read yet" = "Ei vielä luettu"
+"Not shared" = "Ei jaettu"
+"Note {n}" = "Huomautus {n}"
+"Nothing changed since this was marked ready for dev." = "Mikään ei ole muuttunut kehitysvalmiiksi merkitsemisen jälkeen."
+"Nothing here yet. Set a frame's status to list it." = "Ei vielä sisältöä. Lisää kehys luetteloon asettamalla sen tila."
+"Nothing online yet. Use Share on a file to put it online and it is listed here." = "Ei vielä verkkotiedostoja. Julkaise tiedosto verkkoon Jaa-toiminnolla, niin se näkyy tässä."
+"Nothing to export" = "Ei vietävää"
+"Nov" = "marrask."
+"Now" = "Nyt"
+"Nudge (Shift: big nudge)" = "Siirrä askel (Shift: suuri askel)"
+"Nudge amount" = "Siirtoaskeleen koko"
+"Number" = "Luku"
+"Number ↑" = "Luku ↑"
+"Number ↓" = "Luku ↓"
+"Numbered list" = "Numeroitu luettelo"
+"Object" = "Objekti"
+"Oct" = "lokak."
+"Off" = "Ei käytössä"
+"Offered first when filling the slot (any content is allowed)" = "Ehdotetaan ensin sisältöpaikkaa täytettäessä (kaikki sisältö sallitaan)"
+"Offered first when swapping the instance (any component is allowed)" = "Ehdotetaan ensin ilmentymää vaihdettaessa (kaikki komponentit sallitaan)"
+"Offset" = "Siirtymä"
+"Oldest first" = "Vanhimmat ensin"
+"On click" = "Napsautettaessa"
+"On drag" = "Vedettäessä"
+"On this page" = "Tällä sivulla"
+"One announcement in five common sizes: square, portrait, story, link and banner" = "Yksi ilmoitus viidessä tavallisessa koossa: neliö, pysty, tarina, linkki ja banneri"
+"Online" = "Verkossa"
+"Online files" = "Verkkotiedostot"
+"Online sharing is off: files are shared on the local network only." = "Verkkojakaminen on pois käytöstä. Tiedostoja jaetaan vain lähiverkossa."
+"Only the first changed layers are listed." = "Vain ensimmäiset muuttuneet tasot näytetään."
+"Only the first {n} changed layers are listed." = "Vain ensimmäiset {n} muuttunutta tasoa näytetään."
+"Only your threads" = "Vain omat keskustelut"
+"Opacity" = "Peittävyys"
+"Opacity & blend" = "Peittävyys ja sekoitus"
+"Opacity 10%…90%, 0: 100%" = "Peittävyys 10 %…90 %, 0: 100 %"
+"Open" = "Avaa"
+"Open .figcraft, .svg or images" = "Avaa .figcraft-, .svg- tai kuvatiedostoja"
+"Open branch" = "Avaa haara"
+"Open file" = "Avaa tiedosto"
+"Open files" = "Avaa tiedostoja"
+"Open presentations" = "Avoimet esitykset"
+"Open in focus view" = "Avaa kohdistusnäkymässä"
+"Open in new window" = "Avaa uudessa ikkunassa"
+"Open invite links in FigCraft" = "Avaa kutsulinkit FigCraftissa"
+"Open link" = "Avaa linkki"
+"Open link {url}" = "Avaa linkki {url}"
+"Open overlay" = "Avaa peittokuva"
+"Open prototype preview" = "Avaa prototyypin esikatselu"
+"Open variables ({count})" = "Avaa muuttujat ({count})"
+"Opened as a new document" = "Avattu uutena asiakirjana"
+"Opened “{name}” in a new tab" = "”{name}” avattu uudessa välilehdessä"
+"Opening the file…" = "Avataan tiedostoa…"
+"Opening {n} files as new files" = { one = "Avataan uutena tiedostona", other = "Avataan uusia tiedostoja: {n}" }
+"Open|comments" = "Avoin"
+"Options" = "Asetukset"
+"Orange" = "Oranssi"
+"Order" = "Järjestys"
+"Other" = "Muu"
+"Other apps may not open every .fig file exported here." = "Muut sovellukset eivät välttämättä avaa kaikkia tässä vietyjä .fig-tiedostoja."
+"Others lose access and keep their copy; the file stays on the server for you" = "Muiden käyttöoikeus päättyy, ja he säilyttävät kopionsa. Tiedosto jää palvelimelle käyttöösi."
+"Others type this under Share ▸ Join with a code" = "Muut kirjoittavat tämän kohtaan Jaa ▸ Liity koodilla"
+"Outline stroke" = "Muunna reunaviiva poluksi"
+"Outline text" = "Muunna teksti poluiksi"
+"Outlines" = "Ääriviivat"
+"Outside" = "Ulkopuolella"
+"Overflow" = "Ylivuoto"
+"Overlay" = "Peittokuva"
+"Overlay position" = "Peittokuvan sijainti"
+"Overridden here (the collection it extends has another value)" = "Ohitettu tässä (laajennetussa kokoelmassa on toinen arvo)"
+"Overrides" = "Ohitukset"
+"Owner token" = "Omistajan tunniste"
+"Owner token copied" = "Omistajan tunniste kopioitu"
+"PDF print options" = "PDF-tulostusasetukset"
+"PDF print settings" = "PDF-tulostusasetukset"
+"Padding" = "Sisämarginaali"
+"Page" = "Sivu"
+"Page deleted" = "Sivu poistettu"
+"Pages" = "Sivut"
+"Pages added to the document" = "Sivut lisätty asiakirjaan"
+"Pages: {pages}" = "Sivut: {pages}"
+"Paint bucket" = "Maalipurkki"
+"Pan the canvas" = "Siirrä piirtoaluetta"
+"Pan with nothing selected (Shift: farther)" = "Siirrä näkymää ilman valintaa (Shift: pidemmälle)"
+"Panels" = "Paneelit"
+"Paper" = "Paperi"
+"Paragraph indent" = "Kappaleen sisennys"
+"Paragraph indent applies to left-aligned text" = "Kappaleen sisennys koskee vasemmalle tasattua tekstiä"
+"Paragraph spacing" = "Kappaleväli"
+"Pass through" = "Läpivienti"
+"Paste a link (https://…)" = "Liitä linkki (https://…)"
+"Paste a team library link (a view link)" = "Liitä tiimikirjaston linkki (katselulinkki)"
+"Paste here" = "Liitä tähän"
+"Paste to replace" = "Liitä korvaten"
+"Pasted design layers; {n} kinds of content were left out" = { one = "Suunnittelutasot liitetty; {n} sisältötyyppi jätettiin pois", other = "Suunnittelutasot liitetty; {n} sisältötyyppiä jätettiin pois" }
+"Pattern" = "Kuvio"
+"Pattern alignment" = "Kuvion tasaus"
+"Pattern scale" = "Kuvion skaalaus"
+"Pattern source" = "Kuvion lähde"
+"Pen" = "Kynä"
+"Pencil" = "Lyijykynä"
+"People in this file" = "Tämän tiedoston käyttäjät"
+"People join from anywhere with a code. The file is kept on {server} while you share it." = "Käyttäjät voivat liittyä koodilla mistä tahansa. Tiedosto säilytetään palvelimella {server} jakamisen ajan."
+"People on your network join with a code. Nothing goes through a server." = "Lähiverkkosi käyttäjät liittyvät koodilla. Mitään ei kulje palvelimen kautta."
+"Phone" = "Puhelin"
+"Pick color" = "Poimi väri"
+"Pick color (I)" = "Poimi väri (I)"
+"Pick one font family first" = "Valitse ensin yksi fonttiperhe"
+"Pick the Frame tool, then drag on the canvas or choose a device size" = "Valitse Kehys-työkalu ja vedä piirtoalueella tai valitse laitteen koko"
+"Pin a property" = "Kiinnitä ominaisuus"
+"Pinch" = "Nipistys"
+"Pink" = "Vaaleanpunainen"
+"Pixel grid" = "Pikseliruudukko"
+"Pixel preview 1x" = "Pikseliesikatselu 1x"
+"Pixel preview 2x" = "Pikseliesikatselu 2x"
+"Place a shape or frame (its tool chosen)" = "Sijoita muoto tai kehys (sen työkalu valittuna)"
+"Place automatically" = "Sijoita automaattisesti"
+"Place image" = "Sijoita kuva"
+"Placed on the current page" = "Sijoitettu nykyiselle sivulle"
+"Playground" = "Kokeilualue"
+"Plugin" = "Liitännäinen"
+"Plugins" = "Liitännäiset"
+"Plugins & widgets" = "Liitännäiset ja pienoisohjelmat"
+"Plugins run in FigCraft's sandbox, without files, network or clock. Install only plugins you trust." = "Liitännäiset toimivat FigCraftin eristetyssä ympäristössä ilman tiedostoja, verkkoa tai kelloa. Asenna vain luottamiasi liitännäisiä."
+"Plus darker" = "Tummempi summa"
+"Plus lighter" = "Vaaleampi summa"
+"Plus one" = "Plus yksi"
+"Point" = "Piste"
+"Points" = "Pisteet"
+"Polygon" = "Monikulmio"
+"Polygons" = "Monikulmiot"
+"Port" = "Portti"
+"Position" = "Sijainti"
+"Post" = "Lähetä"
+"Preferences" = "Asetukset"
+"Preferred" = "Ensisijainen"
+"Present" = "Esitä"
+"Present or preview" = "Esitä tai esikatsele"
+"Present this flow" = "Esitä tämä kulku"
+"Presentation" = "Esitys"
+"Presentation slides" = "Esitysdiat"
+"Presenting: comments" = "Esitys: kommentit"
+"Presenting: cycle the size options" = "Esitys: kierrä kokovaihtoehtoja"
+"Presenting: full screen" = "Esitys: koko näyttö"
+"Presenting: next frame" = "Esitys: seuraava kehys"
+"Presenting: previous frame" = "Esitys: edellinen kehys"
+"Presenting: restart" = "Esitys: aloita uudelleen"
+"Preserve scroll position" = "Säilytä vierityksen sijainti"
+"Presets" = "Esiasetukset"
+"Press a key…" = "Paina näppäintä…"
+"Preview" = "Esikatselu"
+"Preview this flow" = "Esikatsele tätä kulkua"
+"Preview this frame" = "Esikatsele tätä kehystä"
+"Previous frame" = "Edellinen kehys"
+"Previous ready for dev" = "Edellinen kehitysvalmis"
+"Progressive" = "Asteittainen"
+"Properties" = "Ominaisuudet"
+"Prototype" = "Prototyyppi"
+"Prototype preview" = "Prototyypin esikatselu"
+"Prototype settings" = "Prototyypin asetukset"
+"Publish" = "Julkaise"
+"Publish changes" = "Julkaise muutokset"
+"Publish to another server…" = "Julkaise toiselle palvelimelle…"
+"Publish to server" = "Julkaise palvelimelle"
+"Published version {v}" = "Julkaistu versio {v}"
+"Published version {v} to the server" = "Versio {v} julkaistu palvelimelle"
+"Published version {v}: save the file so other files can use it" = "Versio {v} julkaistu: tallenna tiedosto, jotta muut tiedostot voivat käyttää sitä"
+"Published · {people}" = "Julkaistu · {people}"
+"Publishing to a server needs the desktop app; in the browser you can join a server's files" = "Palvelimelle julkaiseminen vaatii työpöytäsovelluksen. Selaimessa voit liittyä palvelimen tiedostoihin."
+"Publishing with the server's key." = "Julkaistaan palvelimen avaimella."
+"Publishing…" = "Julkaistaan…"
+"Push" = "Työntö"
+"Push changes to main component" = "Siirrä muutokset pääkomponenttiin"
+"Put text on path" = "Sijoita teksti polulle"
+"Question" = "Kysymys"
+"R" = "R"
+"Radial" = "Säteittäinen"
+"Radius" = "Säde"
+"Ratio" = "Suhde"
+"Reading the library…" = "Luetaan kirjastoa…"
+"Ready for dev" = "Kehitysvalmis"
+"Real name" = "Oikea nimi"
+"Recent" = "Viimeisimmät"
+"Recent files" = "Viimeksi avatut tiedostot"
+"Recents" = "Viimeisimmät"
+"Recovered {n} unsaved files after the app quit unexpectedly: save them to keep them" = { one = "Tallentamaton tiedosto palautettiin sovelluksen sulkeuduttua odottamatta. Tallenna se säilyttääksesi sen.", other = "Palautettu {n} tallentamatonta tiedostoa sovelluksen sulkeuduttua odottamatta. Tallenna ne säilyttääksesi ne." }
+"Rectangle" = "Suorakulmio"
+"Rectangles" = "Suorakulmiot"
+"Red" = "Punainen"
+"Reduce motion" = "Vähennä liikettä"
+"Refraction" = "Taittuminen"
+"Regular expression" = "Säännöllinen lauseke"
+"Remove" = "Poista"
+"Remove all" = "Poista kaikki"
+"Remove annotation" = "Poista huomautus"
+"Remove auto layout" = "Poista automaattinen asettelu"
+"Remove dev resource" = "Poista kehittäjäresurssi"
+"Remove export setting" = "Poista vientiasetus"
+"Remove from recents" = "Poista viimeisimmistä"
+"Remove from server" = "Poista palvelimelta"
+"Remove from server…" = "Poista palvelimelta…"
+"Remove guide" = "Poista apuviiva"
+"Remove interaction" = "Poista vuorovaikutus"
+"Remove library from this file" = "Poista kirjasto tästä tiedostosta"
+"Remove min and max" = "Poista vähimmäis- ja enimmäisrajat"
+"Remove min and max height" = "Poista korkeuden vähimmäis- ja enimmäisrajat"
+"Remove min and max width" = "Poista leveyden vähimmäis- ja enimmäisrajat"
+"Remove regions" = "Poista alueet"
+"Remove slot" = "Poista sisältöpaikka"
+"Remove starting point" = "Poista aloituspiste"
+"Remove stop" = "Poista liukuvärin piste"
+"Remove text from path" = "Poista teksti polulta"
+"Remove the else and its actions" = "Poista muuten-haara ja sen toiminnot"
+"Remove this condition and its actions" = "Poista tämä ehto ja sen toiminnot"
+"Remove this file from the server? It can't be shared or opened from there again. Your copy stays open here." = "Poistetaanko tämä tiedosto palvelimelta? Sitä ei voi enää jakaa tai avata sieltä. Oma kopiosi pysyy auki tässä."
+"Remove {name} from session" = "Poista {name} istunnosta"
+"Remove {name} from {server}?" = "Poistetaanko {name} palvelimelta {server}?"
+"Removed" = "Poistettu"
+"Removed from the server" = "Poistettu palvelimelta"
+"Removed since it was marked" = "Poistettu merkitsemisen jälkeen"
+"Rename" = "Nimeä uudelleen"
+"Rename duplicated layers" = "Nimeä monistetut tasot uudelleen"
+"Rename folder" = "Nimeä kansio uudelleen"
+"Rename group" = "Nimeä ryhmä uudelleen"
+"Rename layers" = "Nimeä tasot uudelleen"
+"Rename mode" = "Nimeä tila uudelleen"
+"Rename on the server" = "Nimeä uudelleen palvelimella"
+"Rename on the server…" = "Nimeä uudelleen palvelimella…"
+"Rename page" = "Nimeä sivu uudelleen"
+"Rename to" = "Uusi nimi"
+"Replace all" = "Korvaa kaikki"
+"Replace mixed export settings" = "Korvaa vaihtelevat vientiasetukset"
+"Replace with" = "Korvaa kohteella"
+"Replace with a new interaction" = "Korvaa uudella vuorovaikutuksella"
+"Reply" = "Vastaa"
+"Report" = "Ilmoita"
+"Report this file…" = "Ilmoita tästä tiedostosta…"
+"Reset" = "Palauta"
+"Reset adjustments" = "Palauta säädöt"
+"Reset all changes" = "Palauta kaikki muutokset"
+"Reset all overrides on this layer" = "Palauta kaikki tämän tason ohitukset"
+"Reset overrides" = "Palauta ohitukset"
+"Reset slot" = "Palauta sisältöpaikka"
+"Reset this override" = "Palauta tämä ohitus"
+"Reset to style" = "Palauta tyylin arvo"
+"Reset to the inherited value" = "Palauta peritty arvo"
+"Resize by the nudge amount" = "Muuta kokoa siirtoaskeleen verran"
+"Resize frames to the device's screen (or the window without a device): their constraints and auto layout respond" = "Sovita kehysten koko laitteen näyttöön (tai ikkunaan ilman laitetta). Rajoitteet ja automaattinen asettelu mukautuvat."
+"Resize to fit" = "Sovita koko"
+"Resizing" = "Koon muuttaminen"
+"Resolve" = "Ratkaise"
+"Resolve change" = "Ratkaise muutos"
+"Resolved" = "Ratkaistu"
+"Resources" = "Resurssit"
+"Responsive" = "Mukautuva"
+"Restart" = "Aloita uudelleen"
+"Restore" = "Palauta"
+"Restore main component" = "Palauta pääkomponentti"
+"Restore this version" = "Palauta tämä versio"
+"Restored “{name}”" = "”{name}” palautettu"
+"Reverse the order" = "Käännä järjestys"
+"Reversed triangle" = "Käänteinen kolmio"
+"Review and merge" = "Tarkista ja yhdistä"
+"Ribbon" = "Valintanauha"
+"Right" = "Oikea"
+"Right side" = "Oikea puoli"
+"Right side width" = "Oikean puolen leveys"
+"Rotate 90°" = "Kierrä 90°"
+"Rotate 90° right" = "Kierrä 90° oikealle"
+"Rotate to landscape" = "Käännä vaakasuuntaan"
+"Rotate to portrait" = "Käännä pystysuuntaan"
+"Rotation" = "Kierto"
+"Rotation jitter" = "Kierron vaihtelu"
+"Round" = "Pyöreä"
+"Rounded" = "Pyöristetty"
+"Rounded rectangle" = "Pyöristetty suorakulmio"
+"Row" = "Rivi"
+"Row gap" = "Rivien väli"
+"Row sizes" = "Rivien koot"
+"Row span" = "Riviulottuvuus"
+"Rows" = "Rivit"
+"Rows {count}" = "Rivejä: {count}"
+"Rulers" = "Viivaimet"
+"Run" = "Suorita"
+"Run {label}" = "Suorita {label}"
+"SHA-256: {sha}…" = "SHA-256: {sha}…"
+"Same as layer" = "Sama kuin tasolla"
+"Saturation" = "Kylläisyys"
+"Save" = "Tallenna"
+"Save as" = "Tallenna nimellä"
+"Save as preset…" = "Tallenna esiasetuksena…"
+"Save files automatically" = "Tallenna tiedostot automaattisesti"
+"Save version  {key}" = "Tallenna versio  {key}"
+"Saved" = "Tallennettu"
+"Saved {name}" = "Tallennettu: {name}"
+"Say something" = "Kirjoita viesti"
+"Scale" = "Skaalaus"
+"Scatter" = "Hajonta"
+"Scoping: where pickers offer it" = "Käyttöalue: missä valitsimet tarjoavat tätä"
+"Screen" = "Rasteri"
+"Scroll behavior" = "Vierityksen toiminta"
+"Scroll to" = "Vieritä kohteeseen"
+"Scroll to layer" = "Vieritä tasoon"
+"Scroll with parent" = "Vieritä emotason mukana"
+"Search" = "Etsi"
+"Search actions, layers and tools" = "Etsi toimintoja, tasoja ja työkaluja"
+"Search assets" = "Etsi resursseja"
+"Search comments" = "Etsi kommentteja"
+"Search files and templates" = "Etsi tiedostoja ja malleja"
+"Search fonts" = "Etsi fontteja"
+"Search layers" = "Etsi tasoja"
+"Search plugins" = "Etsi liitännäisiä"
+"Search results" = "Hakutulokset"
+"Search shortcuts" = "Etsi pikanäppäimiä"
+"Search templates" = "Etsi malleja"
+"Section" = "Osio"
+"Section color" = "Osion väri"
+"Sections" = "Osiot"
+"See all templates" = "Näytä kaikki mallit"
+"Select a frame and add a starting point to present it as a flow." = "Valitse kehys ja lisää aloituspiste, jotta voit esittää sen kulkuna."
+"Select a frame to preview it" = "Valitse kehys esikatseltavaksi"
+"Select a layer to see its properties and code" = "Valitse taso, jotta näet sen ominaisuudet ja koodin"
+"Select all" = "Valitse kaikki"
+"Select all with same" = "Valitse kaikki samalla ominaisuudella"
+"Select layer" = "Valitse taso"
+"Select layers and they space themselves as their content changes" = "Valitse tasoja, niin niiden välit mukautuvat sisällön muuttuessa"
+"Select layers to apply the style to" = "Valitse tasot, joihin tyyliä käytetään"
+"Select layers with this color" = "Valitse tämänväriset tasot"
+"Select overlapping shapes" = "Valitse päällekkäiset muodot"
+"Select points to edit their position, radius and mirroring" = "Valitse pisteitä muokataksesi niiden sijaintia, sädettä ja peilausta"
+"Select slot" = "Valitse sisältöpaikka"
+"Selection" = "Valinta"
+"Selection box, {w} by {h} at {x}, {y}: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "Valintalaatikko, {w} × {h} kohdassa {x}, {y}: nuolet siirtävät, Shift+nuolet tai {cmd}+nuolet muuttavat kokoa, Enter valitsee, Escape peruuttaa"
+"Selection box: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "Valintalaatikko: nuolet siirtävät, Shift+nuolet tai {cmd}+nuolet muuttavat kokoa, Enter valitsee, Escape peruuttaa"
+"Selection colors" = "Valinnan värit"
+"Send backward" = "Vie taaksepäin"
+"Send report" = "Lähetä ilmoitus"
+"Send to back" = "Vie takimmaiseksi"
+"Sep" = "syysk."
+"Server address" = "Palvelimen osoite"
+"Server address (ws://host:47900/)" = "Palvelimen osoite (ws://host:47900/)"
+"Server for online sharing" = "Verkkojakamisen palvelin"
+"Set as default" = "Aseta oletukseksi"
+"Set variable" = "Aseta muuttuja"
+"Set variable mode" = "Aseta muuttujan tila"
+"Set variable {name}" = "Aseta muuttuja {name}"
+"Set {name} to {value}" = "Aseta {name} arvoon {value}"
+"Shadows" = "Varjot"
+"Shape" = "Muoto"
+"Shape builder" = "Muodonrakennin"
+"Shape tools" = "Muototyökalut"
+"Shapes" = "Muodot"
+"Share" = "Jaa"
+"Share this file" = "Jaa tämä tiedosto"
+"Share with a code" = "Jaa koodilla"
+"Share: live session, export" = "Jaa: reaaliaikainen istunto, vienti"
+"Shared" = "Jaettu"
+"Shared: copy its code from the file's menu" = "Jaettu: kopioi koodi tiedoston valikosta"
+"Sharing a file needs the desktop app; here you can join one." = "Tiedoston jakaminen vaatii työpöytäsovelluksen. Tässä voit liittyä jaettuun tiedostoon."
+"Sharing on the local network (online sharing is off: no server is set in Preferences)." = "Jaetaan lähiverkossa (verkkojakaminen on pois käytöstä: asetuksissa ei ole palvelinta)."
+"Sharing on your network · {people}" = "Jaetaan lähiverkossasi · {people}"
+"Sharing online · {people}" = "Jaetaan verkossa · {people}"
+"Sharing stopped: the file stays on the server, open only to you" = "Jakaminen lopetettu: tiedosto jää palvelimelle vain sinun käyttöösi"
+"Show" = "Näytä"
+"Show all templates" = "Näytä kaikki mallit"
+"Show as grid" = "Näytä ruudukkona"
+"Show as list" = "Näytä luettelona"
+"Show autosaves" = "Näytä automaattiset tallennukset"
+"Show behind transparent areas" = "Näytä läpinäkyvien alueiden takana"
+"Show comments (Shift+C)" = "Näytä kommentit (Shift+C)"
+"Show device frame" = "Näytä laitteen kehys"
+"Show dimensions on objects" = "Näytä objektien mitat"
+"Show hotspot hints" = "Näytä aktiivisten kohtien vihjeet"
+"Show in Explorer" = "Näytä Resurssienhallinnassa"
+"Show in Finder" = "Näytä Finderissa"
+"Show in folder" = "Näytä kansiossa"
+"Show only this on the canvas" = "Näytä piirtoalueella vain tämä"
+"Show open" = "Näytä avoimet"
+"Show section contents" = "Näytä osion sisältö"
+"Show this layer" = "Näytä tämä taso"
+"Show usage" = "Näytä käyttö"
+"Show/Hide" = "Näytä/kätke"
+"Show/Hide UI" = "Näytä/kätke käyttöliittymä"
+"Side by side" = "Vierekkäin"
+"Sidebar" = "Sivupalkki"
+"Simplify stroke" = "Yksinkertaista reunaviiva"
+"Size" = "Koko"
+"Size jitter" = "Koon vaihtelu"
+"Skip ink" = "Väistä merkkien viivoja"
+"Slashed zero" = "Viivallinen nolla"
+"Slice" = "Viipale"
+"Slices" = "Viipaleet"
+"Slide in" = "Liu'u sisään"
+"Slide out" = "Liu'u ulos"
+"Slot" = "Sisältöpaikka"
+"Slot content" = "Sisältöpaikan sisältö"
+"Small capitals" = "Kapiteelit"
+"Small caps" = "Kapiteelit"
+"Smart animate" = "Älykäs animointi"
+"Snap to pixel grid" = "Tartu pikseliruudukkoon"
+"Social and slides" = "Some ja diat"
+"Social media" = "Sosiaalinen media"
+"Social post sizes" = "Somejulkaisujen koot"
+"Soft light" = "Pehmeä valo"
+"Solid" = "Yksivärinen"
+"Some variants have the same property values: give each one a unique combination" = "Joillakin varianteilla on samat ominaisuusarvot. Anna kullekin yksilöllinen yhdistelmä."
+"Sort" = "Lajittele"
+"Sort by" = "Lajitteluperuste"
+"Sort by date" = "Lajittele päivämäärän mukaan"
+"Sort by page" = "Lajittele sivun mukaan"
+"Sort by {column}" = "Lajittele sarakkeen {column} mukaan"
+"Space around" = "Tila ympärillä"
+"Space between" = "Tila välissä"
+"Space drag" = "Space drag"
+"Space evenly" = "Tasavälein"
+"Space+drag" = "Space+drag"
+"Spacing" = "Välistys"
+"Spam, stolen work, abuse…" = "Roskaposti, varastettu työ, väärinkäyttö…"
+"Speech bubble" = "Puhekupla"
+"Splay" = "Harotus"
+"Spotlight me" = "Nosta minut esiin"
+"Spread" = "Leviäminen"
+"Square" = "Neliö"
+"Stamp" = "Leima"
+"Stamps" = "Leimat"
+"Standard" = "Vakio"
+"Standard ligatures" = "Tavalliset ligatuurit"
+"Star" = "Tähti"
+"Stars" = "Tähdet"
+"Start" = "Alku"
+"Start ascending from / stop descending at" = "Nousevan osan alku / laskevan osan loppu"
+"Start from a blank canvas" = "Aloita tyhjältä piirtoalueelta"
+"Start from a template" = "Aloita mallista"
+"Start on path" = "Aloituskohta polulla"
+"Start on the Home screen" = "Aloita Aloitus-näkymästä"
+"Start point" = "Alkupiste"
+"Start sharing" = "Aloita jakaminen"
+"Start sharing with the Share button, then pass on the code it gives" = "Aloita jakaminen Jaa-painikkeella ja välitä sen antama koodi"
+"Starting to share…" = "Aloitetaan jakamista…"
+"Status" = "Tila"
+"Sticky" = "Kiinnittyvä"
+"Sticky note" = "Muistilappu"
+"Sticky note colors" = "Muistilappujen värit"
+"Sticky notes, shapes and connectors" = "Muistilaput, muodot ja yhdistimet"
+"Stop" = "Pysäytä"
+"Stop following {name}" = "Lopeta käyttäjän {name} seuraaminen"
+"Stop session" = "Lopeta istunto"
+"Stop sharing" = "Lopeta jakaminen"
+"Stop spotlighting" = "Lopeta esiin nostaminen"
+"Stop {n}  {hex}" = "Piste {n}  {hex}"
+"Straight" = "Suora"
+"Stretch" = "Venytys"
+"Strikethrough" = "Yliviivaus"
+"String" = "Merkkijono"
+"Stroke" = "Reunaviiva"
+"Stroke style" = "Reunaviivan tyyli"
+"Stroke weight" = "Reunaviivan paksuus"
+"Strokes" = "Reunaviivat"
+"Style" = "Tyyli"
+"Styles" = "Tyylit"
+"Stylistic set 1" = "Tyylijoukko 1"
+"Stylistic set 2" = "Tyylijoukko 2"
+"Stylistic set 3" = "Tyylijoukko 3"
+"Stylistic set 4" = "Tyylijoukko 4"
+"Stylistic set 5" = "Tyylijoukko 5"
+"Subtract" = "Vähennä"
+"Subtracts" = "Vähentää"
+"Suffix" = "Jälkiliite"
+"Suspend snapping while dragging" = "Keskeytä tarttuminen vetämisen ajaksi"
+"Swap instance" = "Vaihda ilmentymä"
+"Swap library: use another library's assets of the same names" = "Vaihda kirjasto: käytä toisen kirjaston samannimisiä resursseja"
+"Swap orientation" = "Vaihda suunta"
+"Swap overlay" = "Vaihda peittokuva"
+"Swap to {name}" = "Vaihda kohteeseen {name}"
+"Swap width and height" = "Vaihda leveys ja korkeus keskenään"
+"Swapped instance" = "Ilmentymä vaihdettu"
+"Swapped {n} assets" = { one = "Vaihdettu {n} resurssi", other = "Vaihdettu {n} resurssia" }
+"Swapped {n} assets; {missed} had no match and still use the old library" = { one = "Vaihdettu {n} resurssi; ilman vastinetta jäi {missed}, ja ne käyttävät yhä vanhaa kirjastoa", other = "Vaihdettu {n} resurssia; ilman vastinetta jäi {missed}, ja ne käyttävät yhä vanhaa kirjastoa" }
+"Sweep" = "Pyyhkäisy"
+"System" = "Järjestelmä"
+"Tab / Shift+Tab" = "Tab / Shift+Tab"
+"Table" = "Taulukko"
+"Tablet" = "Tabletti"
+"Tabular numbers" = "Tasalevyiset numerot"
+"Take the values from the first selected layer" = "Ota arvot ensimmäisestä valitusta tasosta"
+"Taper" = "Kapeneminen"
+"Taper both ends" = "Kavenna molemmat päät"
+"Tell the server's operator what is wrong with it" = "Kerro palvelimen ylläpitäjälle, mikä siinä on vikana"
+"Temperature" = "Lämpötila"
+"Template" = "Malli"
+"Templates" = "Mallit"
+"Terms" = "Ehdot"
+"Text" = "Teksti"
+"Text align" = "Tekstin tasaus"
+"Text content" = "Tekstisisältö"
+"Text size" = "Tekstin koko"
+"Text style" = "Tekstityyli"
+"Text styles" = "Tekstityylit"
+"Texts" = "Tekstit"
+"Texture" = "Tekstuuri"
+"The canvas previews colors in sRGB; exported PNG, JPG and WebP files are tagged Display P3." = "Piirtoalue esikatselee värit sRGB-muodossa. Vietäviin PNG-, JPG- ja WebP-tiedostoihin merkitään Display P3 -profiili."
+"The destination document is unavailable. Nothing was imported." = "Kohdeasiakirja ei ole käytettävissä. Mitään ei tuotu."
+"The destination document was closed. Nothing was imported." = "Kohdeasiakirja suljettiin. Mitään ei tuotu."
+"The destination page was removed. Nothing was imported." = "Kohdesivu poistettiin. Mitään ei tuotu."
+"The file is deleted from the server: nobody can open or join it from there again, and this can't be undone. Copies that are open stay with whoever has them." = "Tiedosto poistetaan palvelimelta. Kukaan ei voi enää avata sitä tai liittyä siihen sieltä, eikä tätä voi kumota. Avoimet kopiot säilyvät käyttäjillään."
+"The file now holds another library" = "Tiedosto sisältää nyt toisen kirjaston"
+"The file now holds another library (\"{name}\")" = "Tiedosto sisältää nyt toisen kirjaston (”{name}”)"
+"The files you shared or published online from this computer. They stay on their server until you remove them." = "Tältä tietokoneelta verkossa jakamasi tai julkaisemasi tiedostot. Ne säilyvät palvelimellaan, kunnes poistat ne."
+"The link carries the session's secret: share it only with people you invite." = "Linkki sisältää istunnon salaisen tunnisteen. Jaa se vain kutsumillesi henkilöille."
+"The name in your online files and on the server. The document inside keeps its own name." = "Nimi verkkotiedostoissasi ja palvelimella. Sisällä oleva asiakirja säilyttää oman nimensä."
+"The selection uses several text styles: click to apply one" = "Valinta käyttää useita tekstityylejä. Käytä yhtä niistä napsauttamalla."
+"The server deletes this file if nobody opens it before {date}." = "Palvelin poistaa tämän tiedoston, ellei kukaan avaa sitä ennen päivää {date}."
+"The whole file" = "Koko tiedosto"
+"Theme" = "Teema"
+"There's no destination for that action" = "Toiminnolla ei ole kohdetta"
+"Thickness" = "Paksuus"
+"This branch can't be reviewed: {e}" = "Tätä haaraa ei voi tarkistaa: {e}"
+"This branch was merged or archived." = "Tämä haara on yhdistetty tai arkistoitu."
+"This computer only" = "Vain tämä tietokone"
+"This computer remembers the owner token, so the file can be managed from the home screen's Online list. Copy it to manage the file from somewhere else: it is a password for this file and won't be shown again." = "Tämä tietokone muistaa omistajan tunnisteen, joten tiedostoa voi hallita aloitusnäkymän Verkossa-luettelosta. Kopioi tunniste hallitaksesi tiedostoa muualla. Se on tämän tiedoston salasana, eikä sitä näytetä uudelleen."
+"This condition is edited as an expression" = "Tätä ehtoa muokataan lausekkeena"
+"This file" = "Tämä tiedosto"
+"This file has unsaved changes" = "Tässä tiedostossa on tallentamattomia muutoksia"
+"This file is on {server}, open only to you. Share it to let others in with a new code." = "Tämä tiedosto on palvelimella {server} vain sinun käytössäsi. Jaa se, jotta muut voivat liittyä uudella koodilla."
+"This file uses fonts that aren't installed on this computer. Their text is drawn in a fallback font until you install them." = "Tämä tiedosto käyttää fontteja, joita ei ole asennettu tälle tietokoneelle. Teksti piirretään korvaavalla fontilla, kunnes asennat puuttuvat fontit."
+"This frame is new on the branch." = "Tämä kehys on uusi haarassa."
+"This frame isn't on the branch." = "Tätä kehystä ei ole haarassa."
+"This server is open to the public: no key needed." = "Tämä palvelin on julkinen: avainta ei tarvita."
+"This server needs its key: add ?key=… to the address (`figcraft-server key` prints it on the server's machine)." = "Tämä palvelin tarvitsee avaimen. Lisää osoitteeseen ?key=… (`figcraft-server key` tulostaa avaimen palvelimen koneella)."
+"This server takes files only with its key: see Advanced." = "Tämä palvelin ottaa tiedostoja vastaan vain avaimellaan. Katso Lisäasetukset."
+"Thumbs up" = "Peukku ylös"
+"Tidy up" = "Järjestä tasavälein"
+"Tile" = "Laatoitus"
+"Tile type" = "Laatan tyyppi"
+"Tint" = "Sävytys"
+"Title" = "Otsikko"
+"Title case" = "Sanojen isot alkukirjaimet"
+"To share this library with your team, publish the file to a server (Share ▸ Publish to server…), then publish the library there." = "Jaa tämä kirjasto tiimillesi julkaisemalla tiedosto palvelimelle (Jaa ▸ Julkaise palvelimelle…) ja julkaisemalla kirjasto siellä."
+"Toggle" = "Vaihda tila"
+"Toggle light/dark theme" = "Vaihda vaalea/tumma teema"
+"Toggle visibility" = "Vaihda näkyvyys"
+"Tools" = "Työkalut"
+"Top" = "Ylhäältä"
+"Top & bottom" = "Ylä- ja alareuna"
+"Top left radius" = "Vasemman yläkulman säde"
+"Top right radius" = "Oikean yläkulman säde"
+"Transform" = "Muunna"
+"Triangle" = "Kolmio"
+"Triangle arrow" = "Kolmionuoli"
+"Trigger" = "Laukaisin"
+"True" = "Tosi"
+"Truncate text" = "Lyhennä tekstiä"
+"Truncate with an ellipsis" = "Lyhennä kolmella pisteellä"
+"Try again" = "Yritä uudelleen"
+"Try another search or filter." = "Kokeile toista hakua tai suodatinta."
+"Try another search, or browse templates." = "Kokeile toista hakua tai selaa malleja."
+"Try another word, or look at every kind." = "Kokeile toista sanaa tai katso kaikki tyypit."
+"Turn a layer into a component, reuse it, and change every copy at once" = "Muunna taso komponentiksi, käytä sitä uudelleen ja muuta kaikkia kopioita kerralla"
+"Two digits" = "Kaksi numeroa"
+"Type" = "Teksti"
+"Type settings" = "Tekstiasetukset"
+"Type the join code you were given, or paste an invite link." = "Kirjoita saamasi liittymiskoodi tai liitä kutsulinkki."
+"Typography" = "Typografia"
+"Underline" = "Alleviivaus"
+"Undo takes back only your own changes; what others changed since stays." = "Kumoaminen peruu vain omat muutoksesi. Muiden sen jälkeen tekemät muutokset säilyvät."
+"Ungroup" = "Pura ryhmittely"
+"Uniform" = "Tasainen"
+"Union" = "Yhdiste"
+"Unions" = "Yhdistää"
+"Unknown — treated as sRGB" = "Tuntematon — käsitellään sRGB:nä"
+"Unread" = "Lukematon"
+"Unresolve" = "Merkitse ratkaisemattomaksi"
+"Unsaved changes" = "Tallentamattomat muutokset"
+"Unsaved changes in {names}. Save them before closing?" = "Tallentamattomia muutoksia kohteissa {names}. Tallennetaanko ne ennen sulkemista?"
+"Unsaved changes: save first ({save}), or close the tab with {alt}-click to discard" = "Tallentamattomia muutoksia: tallenna ensin ({save}) tai hylkää sulkemalla välilehti {alt}-napsautuksella"
+"Unsaved changes: save first, or close again with {key} to discard" = "Tallentamattomia muutoksia: tallenna ensin tai hylkää sulkemalla uudelleen näppäimellä {key}"
+"Up" = "Ylös"
+"Update" = "Päivitä"
+"Update from main" = "Päivitä päähaarasta"
+"Update from selection" = "Päivitä valinnasta"
+"Update plugin" = "Päivitä liitännäinen"
+"Updated {components} and {styles}" = "Päivitetty {components} ja {styles}"
+"Updated {name}" = "Päivitetty: {name}"
+"Updating the graphics driver often helps. To use OpenGL only, start FigCraft from a Command Prompt with:" = "Näytönohjainajurin päivittäminen auttaa usein. Käytä vain OpenGL:ää käynnistämällä FigCraft komentokehotteesta näin:"
+"Updating the graphics driver often helps. WGPU_BACKEND (vulkan, gl, metal) names another graphics API to try." = "Näytönohjainajurin päivittäminen auttaa usein. WGPU_BACKEND (vulkan, gl, metal) määrittää toisen kokeiltavan grafiikkarajapinnan."
+"Uploads this file to a FigCraft server and keeps this tab in sync with it. You get a link to edit and a link to view." = "Lataa tämän tiedoston FigCraft-palvelimelle ja pitää tämän välilehden synkronoituna sen kanssa. Saat muokkauslinkin ja katselulinkin."
+"Uppercase" = "Isot kirjaimet"
+"Use a fixed value" = "Käytä kiinteää arvoa"
+"Use an expression, e.g. count + 1" = "Käytä lauseketta, esim. count + 1"
+"Use as mask" = "Käytä maskina"
+"Use auto layout" = "Käytä automaattista asettelua"
+"Use number keys for opacity" = "Säädä peittävyyttä numeronäppäimillä"
+"Use the .figcraft or .fig extension." = "Käytä .figcraft- tai .fig-tiedostopäätettä."
+"Use the layer's fill" = "Käytä tason täyttöä"
+"Used in {files} · {instances}" = "Käytössä tiedostoissa {files} · {instances}"
+"Username" = "Käyttäjänimi"
+"Uses variables: each layer shows them in its own mode" = "Käyttää muuttujia: kukin taso näyttää ne omassa tilassaan"
+"Value" = "Arvo"
+"Variable" = "Muuttuja"
+"Variable collections" = "Muuttujakokoelmat"
+"Variable modes" = "Muuttujatilat"
+"Variable width" = "Vaihteleva leveys"
+"Variables" = "Muuttujat"
+"Variables JSON…" = "Muuttujat JSON…"
+"Variables store reusable values (colours, numbers, strings, booleans) with modes such as Light and Dark." = "Muuttujat tallentavat uudelleenkäytettäviä arvoja (värejä, lukuja, merkkijonoja ja totuusarvoja). Niillä voi olla tiloja, kuten vaalea ja tumma."
+"Variant" = "Variantti"
+"Vector" = "Vektori"
+"Vectors" = "Vektorit"
+"Version" = "Versio"
+"Version history" = "Versiohistoria"
+"Version {version}" = "Versio {version}"
+"Version {v} · {components} · {styles} · {variables}" = "Versio {v} · {components} · {styles} · {variables}"
+"Vertical" = "Pystysuunta"
+"Vertical align" = "Pystytasaus"
+"Vertical hex" = "Pystysuuntainen kuusikulmio"
+"Vertical padding" = "Pystysuuntainen sisämarginaali"
+"Vertical spacing" = "Pystyvälistys"
+"Vertical trim" = "Pystysuuntainen rajaus"
+"View" = "Näytä"
+"View link" = "Katselulinkki"
+"View link copied" = "Katselulinkki kopioitu"
+"View only" = "Vain katselu"
+"View only: you see every change as it happens but can't edit. Leave to keep a copy you can edit." = "Vain katselu: näet kaikki muutokset reaaliajassa, mutta et voi muokata. Poistu säilyttääksesi muokattavan kopion."
+"Viewing “{name}”" = "Katsellaan tiedostoa ”{name}”"
+"Violet" = "Violetti"
+"Visibility" = "Näkyvyys"
+"Visible" = "Näkyvä"
+"Vivid" = "Kirkas"
+"WGPU_BACKEND is set and names the graphics API to use; unsetting it lets FigCraft choose." = "WGPU_BACKEND on asetettu ja määrittää käytettävän grafiikkarajapinnan. Poista se käytöstä, jotta FigCraft voi valita."
+"Warm" = "Lämmin"
+"Watch" = "Seuraa"
+"Wavy" = "Aaltoileva"
+"Web" = "Verkko"
+"WebSocket URL" = "WebSocket-URL"
+"WebSocket URL copied" = "WebSocket-URL kopioitu"
+"Websites" = "Verkkosivustot"
+"Wedge" = "Kiila"
+"Weight" = "Paksuus"
+"What changed since it was marked ready for dev" = "Muutokset kehitysvalmiiksi merkitsemisen jälkeen"
+"What is wrong with this file? The server's operator gets your report." = "Mikä tässä tiedostossa on vikana? Palvelimen ylläpitäjä saa ilmoituksesi."
+"What it's for" = "Käyttötarkoitus"
+"What this changed from isn't known: it changed before FigCraft kept a copy of ready-for-dev frames. Resolve the change (or mark it ready again) to compare from now on." = "Aiempi tila ei ole tiedossa: muutos tehtiin ennen kuin FigCraft tallensi kopioita kehitysvalmiista kehyksistä. Ratkaise muutos tai merkitse kehys uudelleen valmiiksi, jotta jatkossa vertailu onnistuu."
+"What you try here changes this preview and the code below, not the file" = "Tässä kokeilemasi asiat muuttavat esikatselua ja alla olevaa koodia, eivät tiedostoa"
+"While hovering" = "Osoitettaessa"
+"While pressing" = "Painettaessa"
+"White" = "Valkoinen"
+"Who runs it, its terms and how long it keeps files" = "Ylläpitäjä, käyttöehdot ja tiedostojen säilytysaika"
+"Why it changed" = "Muutoksen syy"
+"Widget" = "Pienoisohjelma"
+"Widgets" = "Pienoisohjelmat"
+"Width" = "Leveys"
+"Width point" = "Leveyspiste"
+"Width profile" = "Leveysprofiili"
+"Wireframe kit" = "Rautalankapaketti"
+"With the layers' export settings" = "Tasojen vientiasetuksilla"
+"Wrap" = "Rivitys"
+"Wrap in new section" = "Ympäröi uudella osiolla"
+"Yellow" = "Keltainen"
+"Yesterday" = "Eilen"
+"You" = "Sinä"
+"You'll get the shared file as a new tab and edit it together." = "Jaettu tiedosto avautuu uuteen välilehteen, ja voitte muokata sitä yhdessä."
+"You're spotlighting: everyone follows your view" = "Olet esillä: kaikki seuraavat näkymääsi"
+"Your copy of the file stays open" = "Oma kopiosi tiedostosta pysyy auki"
+"Your copy stays open; the file stays on the server" = "Oma kopiosi pysyy auki, ja tiedosto jää palvelimelle"
+"Your name" = "Nimesi"
+"Your name in comments" = "Nimesi kommenteissa"
+"Your system asks for reduced motion: animations stay off." = "Järjestelmäsi pyytää vähennettyä liikettä. Animaatiot pidetään pois käytöstä."
+"Z" = "Z"
+"Z to A" = "Z:sta A:han"
+"Zoom" = "Zoomaus"
+"Zoom around the pointer" = "Zoomaa osoittimen ympärillä"
+"Zoom device to fill window" = "Zoomaa laite ikkunan kokoiseksi"
+"Zoom in" = "Lähennä"
+"Zoom out" = "Loitonna"
+"Zoom to 100%" = "Zoomaa kokoon 100 %"
+"Zoom to 200%" = "Zoomaa kokoon 200 %"
+"Zoom to 50%" = "Zoomaa kokoon 50 %"
+"Zoom to fit" = "Sovita näkymään"
+"Zoom to selection" = "Zoomaa valintaan"
+"Zoom tool: click to zoom in, drag an area" = "Zoomaustyökalu: lähennä napsauttamalla tai vedä alue"
+"Zoom tool: zoom out" = "Zoomaustyökalu: loitonna"
+"and {n} more" = { one = "ja vielä {n}", other = "ja vielä {n}" }
+"bleed marks" = "leikkuuvaramerkit"
+"by {author}" = "tekijä: {author}"
+"call any command its access allows" = "kutsua kaikkia käyttöoikeuksiensa sallimia komentoja"
+"call only: {commands}" = "kutsua vain: {commands}"
+"can edit the document" = "voi muokata asiakirjaa"
+"conditional prototype actions nested too deeply were skipped" = "liian syvälle sisäkkäiset ehdolliset prototyyppitoiminnot ohitettiin"
+"conditional prototype actions with conditions that can't be evaluated were skipped" = "ehdolliset prototyyppitoiminnot ohitettiin, koska niiden ehtoja ei voi laskea"
+"connector label background was skipped: style data is missing" = "yhdistimen tekstin tausta ohitettiin: tyylitiedot puuttuvat"
+"connector label was skipped: background bounds are invalid" = "yhdistimen teksti ohitettiin: taustan rajat ovat virheelliset"
+"connector label was skipped: background transform is invalid" = "yhdistimen teksti ohitettiin: taustan muunnos on virheellinen"
+"connector label was skipped: composed text transform is invalid" = "yhdistimen teksti ohitettiin: yhdistetty tekstimuunnos on virheellinen"
+"connector label was skipped: derived background bounds are missing" = "yhdistimen teksti ohitettiin: johdetut taustan rajat puuttuvat"
+"connector label was skipped: derived text bounds are missing" = "yhdistimen teksti ohitettiin: johdetut tekstin rajat puuttuvat"
+"connector label was skipped: text bounds are invalid" = "yhdistimen teksti ohitettiin: tekstin rajat ovat virheelliset"
+"connector label was skipped: text style data is missing" = "yhdistimen teksti ohitettiin: tekstin tyylitiedot puuttuvat"
+"connector label was skipped: text transform is invalid" = "yhdistimen teksti ohitettiin: tekstin muunnos on virheellinen"
+"connector labels were skipped" = "yhdistimien tekstit ohitettiin"
+"connector layers import as static frame/vector snapshots with labels when present; live endpoint bindings are not retained" = "yhdistintasot tuodaan staattisina kehys- ja vektorikuvina mahdollisine teksteineen; päiden reaaliaikaisia sidoksia ei säilytetä"
+"connector snapshot vector data is missing; connector was left empty" = "yhdistimen vektorikuvatiedot puuttuvat; yhdistin jätettiin tyhjäksi"
+"connectors whose ends can't be placed are empty" = "yhdistimet, joiden päitä ei voi sijoittaa, ovat tyhjiä"
+"crop marks" = "leikkausmerkit"
+"damaged vector geometry was skipped" = "vaurioitunut vektorigeometria ohitettiin"
+"damaged vector networks import as outlines" = "vaurioituneet vektoriverkot tuodaan ääriviivoina"
+"development: {path}" = "kehitys: {path}"
+"document children other than pages were skipped" = "asiakirjan muut kuin sivuina olevat alikohteet ohitettiin"
+"duplicate grid track sizing entries use equal tracks" = "päällekkäiset ruudukon kokomääritykset käyttävät tasakokoisia osia"
+"e.g. count + 1" = "esim. count + 1"
+"e.g. count >= 3 and not done" = "esim. count >= 3 and not done"
+"elbowed and curved connectors without a saved path import as straight lines" = "mutkaiset ja kaarevat yhdistimet, joilla ei ole tallennettua polkua, tuodaan suorina viivoina"
+"entries without a node type were skipped" = "kohteet, joilta puuttuu solmutyyppi, ohitettiin"
+"figcraft:// links from a browser, chat or email open this app and join the session." = "selaimen, keskustelun tai sähköpostin figcraft://-linkit avaavat tämän sovelluksen ja liittyvät istuntoon."
+"filled areas of a vector with their own fill use the layer's fill" = "vektorin omalla täytöllä määritetyt alueet käyttävät tason täyttöä"
+"from {server}" = "palvelimelta {server}"
+"gamepad triggers without exactly one known controller button were skipped" = "peliohjainlaukaisimet, joilla ei ole täsmälleen yhtä tunnettua ohjainpainiketta, ohitettiin"
+"grid track list exceeds 1000 entries; the tracks use the default equal sizing" = "ruudukon osien luettelo ylittää 1000 kohdetta; osat käyttävät oletuksen mukaista tasakokoa"
+"grid track sizing is unsupported or malformed; affected tracks use equal sizing" = "ruudukon kokomääritys on virheellinen tai sitä ei tueta; kyseiset osat käyttävät tasakokoa"
+"grid track sizing list exceeds 1000 entries; the tracks use the default equal sizing" = "ruudukon kokomääritysten luettelo ylittää 1000 kohdetta; osat käyttävät oletuksen mukaista tasakokoa"
+"hidden" = "kätketty"
+"iOS" = "iOS"
+"image filters are ambiguous because both filter containers are present; filter conversion was skipped" = "kuvasuotimet ovat monitulkintaisia, koska molemmat suodinsäilöt ovat läsnä; suotimien muunnos ohitettiin"
+"image filters use FigCraft's approximate renderer" = "kuvasuotimet käyttävät FigCraftin likimääräistä renderöijää"
+"instance swap properties whose default component isn't in the file were skipped" = "ilmentymän vaihto-ominaisuudet ohitettiin, koska niiden oletuskomponenttia ei ole tiedostossa"
+"instances inside their own main component were imported as frames" = "oman pääkomponenttinsa sisällä olevat ilmentymät tuotiin kehyksinä"
+"instances of components that aren't in the file show no layers" = "tiedostosta puuttuvien komponenttien ilmentymät eivät näytä tasoja"
+"instances of components that aren't in the file were imported as frames" = "tiedostosta puuttuvien komponenttien ilmentymät tuotiin kehyksinä"
+"instances that would nest a component inside itself were imported as frames" = "ilmentymät, jotka sijoittaisivat komponentin itsensä sisään, tuotiin kehyksinä"
+"instances without a main component were imported as empty frames" = "ilmentymät, joilta puuttuu pääkomponentti, tuotiin tyhjinä kehyksinä"
+"invalid internal .fig text path data was ignored" = "virheelliset sisäiset .fig-tekstipolun tiedot ohitettiin"
+"invalid or oversized vector networks import as outlines" = "virheelliset tai liian suuret vektoriverkot tuodaan ääriviivoina"
+"invalid or oversized vector path data was skipped" = "virheelliset tai liian suuret vektoripolun tiedot ohitettiin"
+"just now" = "juuri nyt"
+"key triggers without a supported key were skipped" = "näppäinlaukaisimet, joilla ei ole tuettua näppäintä, ohitettiin"
+"key up triggers import as key presses" = "näppäimen vapautuslaukaisimet tuodaan näppäimen painalluksina"
+"layers without a position were placed at their parent's origin" = "tasot, joilta puuttuu sijainti, sijoitettiin emotasonsa origoon"
+"layers without a type were skipped" = "tasot, joilta puuttuu tyyppi, ohitettiin"
+"legacy image filter container is unsupported; filter conversion was skipped" = "vanhaa kuvasuodinsäilöä ei tueta; suotimien muunnos ohitettiin"
+"locked" = "lukittu"
+"malformed image filters container was skipped" = "virheellinen image filters -säilö ohitettiin"
+"malformed image paintFilter container was skipped" = "virheellinen image paintFilter -säilö ohitettiin"
+"malformed slot content assignment was skipped" = "virheellinen sisältöpaikan sisällön määritys ohitettiin"
+"no bleed" = "ei leikkuuvaraa"
+"nobody else here yet" = "kukaan muu ei ole vielä paikalla"
+"non-default slot settings are not represented and were skipped" = "oletuksesta poikkeavia sisältöpaikan asetuksia ei esitetä, ja ne ohitettiin"
+"now" = "nyt"
+"only in a text style or variable" = "vain tekstityylissä tai muuttujassa"
+"or" = "tai"
+"point stroke joins were preserved; dashed or variable-width strokes render with the layer join" = "pisteiden viivaliitokset säilytettiin; katko- ja vaihtelevanlevyiset viivat käyttävät tason liitostyyliä"
+"preferred slot component keys cannot be resolved to file nodes and were skipped" = "sisältöpaikan ensisijaisten komponenttien avaimia ei voitu yhdistää tiedoston solmuihin, ja ne ohitettiin"
+"prototype actions of unknown types were skipped" = "tuntemattoman tyyppiset prototyyppitoiminnot ohitettiin"
+"prototype actions without a destination in the file were skipped" = "prototyyppitoiminnot, joiden kohdetta ei ole tiedostossa, ohitettiin"
+"prototype expressions on variables that aren't in the variables JSON were skipped" = "muuttujiin viittaavat prototyyppilausekkeet ohitettiin, koska muuttujia ei ole muuttujien JSON-tiedostossa"
+"prototype expressions with unsupported functions were skipped" = "prototyyppilausekkeet, joissa on tukemattomia funktioita, ohitettiin"
+"prototype interactions without supported actions were skipped" = "prototyypin vuorovaikutukset, joissa ei ole tuettuja toimintoja, ohitettiin"
+"prototype navigations of unknown types were skipped" = "tuntemattoman tyyppiset prototyypin siirtymät kohteeseen ohitettiin"
+"prototype transitions of unknown types play instantly" = "tuntemattoman tyyppiset prototyypin siirtymäanimaatiot toistuvat välittömästi"
+"prototype triggers of unknown types were skipped" = "tuntemattoman tyyppiset prototyypin laukaisimet ohitettiin"
+"put a widget on the canvas" = "lisätä pienoisohjelman piirtoalueelle"
+"read and edit the document" = "lukea ja muokata asiakirjaa"
+"read the document" = "lukea asiakirjan"
+"reads the document" = "lukee asiakirjan"
+"set-variable actions on variables that aren't in the variables JSON were skipped" = "muuttujan asetustoiminnot ohitettiin, koska muuttujia ei ole muuttujien JSON-tiedostossa"
+"set-variable actions with values that can't be evaluated were skipped" = "muuttujan asetustoiminnot ohitettiin, koska arvoja ei voi laskea"
+"set-variable actions with values that don't fit the variable were skipped" = "muuttujan asetustoiminnot ohitettiin, koska arvot eivät sovi muuttujaan"
+"set-variable actions without a value were skipped" = "muuttujan asetustoiminnot, joilta puuttuu arvo, ohitettiin"
+"set-variable-mode actions on collections or modes that aren't in the variables JSON were skipped" = "muuttujatilan asetustoiminnot ohitettiin, koska kokoelmia tai tiloja ei ole muuttujien JSON-tiedostossa"
+"slot content assignment target is missing or is not slot content" = "sisältöpaikan määrityksen kohde puuttuu tai ei ole sisältöpaikan sisältöä"
+"slot content assignment uses the empty GUID sentinel and was skipped" = "sisältöpaikan määritys käyttää tyhjää GUID-erikoisarvoa, ja se ohitettiin"
+"slot layers without a matching slot property were imported as frames" = "sisältöpaikkatasot, joilla ei ole vastaavaa sisältöpaikkaominaisuutta, tuotiin kehyksinä"
+"some vector points refer to point settings missing from the file; they use the layer's joins and plain corners" = "jotkin vektoripisteet viittaavat tiedostosta puuttuviin pisteasetuksiin; ne käyttävät tason liitostyyliä ja tavallisia kulmia"
+"some vector segments refer to style settings missing from the file; they use the layer's stroke" = "jotkin vektorisegmentit viittaavat tiedostosta puuttuviin tyyliasetuksiin; ne käyttävät tason reunaviivaa"
+"stale or invalid grid track sizing entries were ignored" = "vanhentuneet tai virheelliset ruudukon kokomääritykset ohitettiin"
+"stars and polygons without point counts or geometry use the default point count" = "tähdet ja monikulmiot, joilta puuttuu pistemäärä tai geometria, käyttävät oletuspistemäärää"
+"style settings of some vector segments aren't supported; those segments use the layer's stroke" = "joidenkin vektorisegmenttien tyyliasetuksia ei tueta; nämä segmentit käyttävät tason reunaviivaa"
+"text path underline or strikethrough decoration is not rendered" = "tekstipolun alleviivausta tai yliviivausta ei renderöidä"
+"text style overrides refer to missing table entries" = "tekstityylin ohitukset viittaavat puuttuviin taulukkokohteisiin"
+"the file has no pages" = "tiedostossa ei ole sivuja"
+"the plugin" = "liitännäinen"
+"the variables JSON has no `variableCollections` (expected the local variables response) and was ignored" = "muuttujien JSON-tiedostosta puuttuu `variableCollections` (odotettiin paikallisten muuttujien vastausta), ja tiedosto ohitettiin"
+"this session only" = "vain tämä istunto"
+"unknown component property types were skipped" = "tuntemattoman tyyppiset komponenttiominaisuudet ohitettiin"
+"variable aliases to variables that aren't in the variables JSON (or of another type) were skipped" = "muuttuja-aliakset ohitettiin, koska kohdemuuttujia ei ole muuttujien JSON-tiedostossa tai ne ovat eri tyyppiä"
+"variable bindings to properties the layer doesn't have were skipped" = "muuttujasidokset ominaisuuksiin, joita tasolla ei ole, ohitettiin"
+"variable bindings to variables that aren't in the variables JSON (library variables) were skipped" = "muuttujasidokset muuttujiin, joita ei ole muuttujien JSON-tiedostossa (kirjastomuuttujat), ohitettiin"
+"variable bindings were skipped: the file JSON has no variable definitions (pass the local variables JSON as `variables`, or embed its `meta` next to the file JSON)" = "muuttujasidokset ohitettiin: tiedoston JSON ei määritä muuttujia (anna paikallisten muuttujien JSON arvona `variables` tai sisällytä sen `meta` tiedoston JSONin viereen)"
+"variable bindings whose variable type doesn't fit the property were skipped" = "muuttujasidokset, joiden muuttujatyyppi ei sovi ominaisuuteen, ohitettiin"
+"variable collections without modes were skipped" = "muuttujakokoelmat, joilla ei ole tiloja, ohitettiin"
+"variable mode lookups in prototype expressions that aren't a variable and one of its modes were skipped" = "prototyyppilausekkeiden muuttujatilahaut, jotka eivät ole muuttuja ja jokin sen tiloista, ohitettiin"
+"variable modes of collections that aren't in the file were skipped" = "tiedostosta puuttuvien kokoelmien muuttujatilat ohitettiin"
+"variable modes of collections that aren't in the variables JSON were skipped" = "muuttujien JSON-tiedostosta puuttuvien kokoelmien muuttujatilat ohitettiin"
+"variable values that don't match their type (or composed colours) were skipped" = "muuttujien arvot, jotka eivät vastaa tyyppiään (tai yhdistettyjä värejä), ohitettiin"
+"variables of unknown types were skipped" = "tuntemattoman tyyppiset muuttujat ohitettiin"
+"variables whose collection isn't in the variables JSON were skipped" = "muuttujat, joiden kokoelmaa ei ole muuttujien JSON-tiedostossa, ohitettiin"
+"variables without readable values were skipped" = "muuttujat, joiden arvoja ei voi lukea, ohitettiin"
+"vector points with unknown stroke joins use the layer join" = "vektoripisteet, joilla on tuntematon liitostyyli, käyttävät tason liitostyyliä"
+"vectors without geometry are empty" = "vektorit ilman geometriaa ovat tyhjiä"
+"vectors without geometry are empty (export the file JSON with geometry=paths)" = "vektorit ilman geometriaa ovat tyhjiä (vie tiedoston JSON asetuksella geometry=paths)"
+"very long text was cut to 1,048,576 characters" = "erittäin pitkä teksti katkaistiin 1 048 576 merkkiin"
+"very long vector paths were skipped" = "erittäin pitkät vektoripolut ohitettiin"
+"video actions are not supported and were skipped" = "videotoimintoja ei tueta, ja ne ohitettiin"
+"video triggers are not supported and were skipped" = "videolaukaisimia ei tueta, ja ne ohitettiin"
+"yesterday" = "eilen"
+"{instances} in {files}" = "{instances} tiedostoissa {files}"
+"{language}: draft translation, waiting for a native speaker's review." = "{language}: käännösluonnos, joka odottaa äidinkielisen puhujan tarkistusta."
+"{length} bleed" = "Leikkuuvara {length}"
+"{month} {day}, {year}" = "{day}. {month} {year}"
+"{name}\nClick to apply to the selection" = "{name}\nKäytä valintaan napsauttamalla"
+"{name}\nDrag onto the canvas, or click to place in the middle of the view.\nHold Alt (Option) while dropping onto an instance to swap it." = "{name}\nVedä piirtoalueelle tai sijoita näkymän keskelle napsauttamalla.\nVaihda ilmentymä pudottamalla sen päälle Alt (Option) painettuna."
+"{name} (from {library})" = "{name} (kirjastosta {library})"
+"{name} (you)" = "{name} (sinä)"
+"{name} ({layers} layers)" = "{name} (tasoja: {layers})"
+"{name} ({tag}): {min} – {max}, default {default}. Double-click the slider to go back to the style's value; Escape while dragging cancels." = "{name} ({tag}): {min} – {max}, oletus {default}. Palauta tyylin arvo kaksoisnapsauttamalla liukusäädintä. Escape peruuttaa vetämisen."
+"{name} cleared from the list" = "{name} poistettu luettelosta"
+"{name} from {path}" = "{name} polusta {path}"
+"{name} is forgotten on this computer; the file stays on {server}" = "{name} on unohdettu tällä tietokoneella. Tiedosto jää palvelimelle {server}."
+"{name} is on the server." = "{name} on palvelimella."
+"{name} is spotlighting" = "{name} nostaa näkymäänsä esiin"
+"{name} is too large to open in the browser (over 512 MB)." = "{name} on liian suuri avattavaksi selaimessa (yli 512 Mt)."
+"{name} was removed from the server" = "{name} poistettiin palvelimelta"
+"{name} · deleted on main" = "{name} · poistettu päähaarassa"
+"{name} · deleted on the branch" = "{name} · poistettu haarassa"
+"{name} · not published" = "{name} · ei julkaistu"
+"{name} · on a server" = "{name} · palvelimella"
+"{name} · published version {v}" = "{name} · julkaistu versio {v}"
+"{name} · version {v} on the server" = "{name} · versio {v} palvelimella"
+"{name}, in a live session" = "{name}, reaaliaikaisessa istunnossa"
+"{name}, online, open only to you" = "{name}, verkossa, vain sinun käytössäsi"
+"{name}, {kind}, {w} by {h}, selected" = "{name}, {kind}, {w} × {h}, valittu"
+"{n} added" = { one = "Lisätty: {n}", other = "Lisätty: {n}" }
+"{n} autosave versions" = { one = "{n} automaattisesti tallennettu versio", other = "{n} automaattisesti tallennettua versiota" }
+"{n} changed" = { one = "Muutettu: {n}", other = "Muutettu: {n}" }
+"{n} columns" = { one = "{n} sarake", other = "{n} saraketta" }
+"{n} components" = { one = "{n} komponentti", other = "{n} komponenttia" }
+"{n} components and styles have newer versions" = { one = "Uudempi versio saatavilla: {n} komponentti tai tyyli", other = "Uudempia versioita saatavilla: {n} komponenttia ja tyyliä" }
+"{n} conflicts to resolve" = { one = "{n} ratkaistava ristiriita", other = "{n} ratkaistavaa ristiriitaa" }
+"{n} days ago" = { one = "{n} päivä sitten", other = "{n} päivää sitten" }
+"{n} files" = { one = "{n} tiedosto", other = "{n} tiedostoa" }
+"{n} hours ago" = { one = "{n} tunti sitten", other = "{n} tuntia sitten" }
+"{n} instances" = { one = "{n} ilmentymä", other = "{n} ilmentymää" }
+"{n} layers" = { one = "{n} taso", other = "{n} tasoa" }
+"{n} layers as one file" = { one = "{n} taso yhtenä tiedostona", other = "{n} tasoa yhtenä tiedostona" }
+"{n} layers selected" = { one = "{n} taso valittu", other = "{n} tasoa valittu" }
+"{n} layers · {parts}" = { one = "{n} taso · {parts}", other = "{n} tasoa · {parts}" }
+"{n} matches" = { one = "{n} osuma", other = "{n} osumaa" }
+"{n} minutes ago" = { one = "{n} minuutti sitten", other = "{n} minuuttia sitten" }
+"{n} months ago" = { one = "{n} kuukausi sitten", other = "{n} kuukautta sitten" }
+"{n} more notes omitted from this report" = { one = "Tästä raportista on jätetty pois vielä {n} huomautus", other = "Tästä raportista on jätetty pois vielä {n} huomautusta" }
+"{n} of {total}" = "{n} / {total}"
+"{n} people joined" = { one = "{n} henkilö liittyi", other = "{n} henkilöä liittyi" }
+"{n} preferred components" = { one = "{n} ensisijainen komponentti", other = "{n} ensisijaista komponenttia" }
+"{n} ready" = { one = "{n} valmis", other = "{n} valmista" }
+"{n} removed" = { one = "Poistettu: {n}", other = "Poistettu: {n}" }
+"{n} replies" = { one = "{n} vastaus", other = "{n} vastausta" }
+"{n} rows" = { one = "{n} rivi", other = "{n} riviä" }
+"{n} styles" = { one = "{n} tyyli", other = "{n} tyyliä" }
+"{n} text layers" = { one = "{n} tekstitaso", other = "{n} tekstitasoa" }
+"{n} variables" = { one = "{n} muuttuja", other = "{n} muuttujaa" }
+"{n} weeks ago" = { one = "{n} viikko sitten", other = "{n} viikkoa sitten" }
+"{n} years ago" = { one = "{n} vuosi sitten", other = "{n} vuotta sitten" }
+"{n}d" = "{n}pv"
+"{n}h" = "{n}t"
+"{n}m" = "{n}min"
+"{n}w" = "{n}vk"
+"{page}, nothing selected" = "{page}, ei valintaa"
+"{profile} (current)" = "{profile} (nykyinen)"
+"{property} is its value; {property ? \"a\" : \"b\"} picks a string. Other {…} stays as written." = "{property} on sen arvo. {property ? \"a\" : \"b\"} valitsee merkkijonon. Muut {…}-ilmaukset säilyvät sellaisinaan."
+"{server} can't say what became of your files (it is older than this app)." = "{server} ei pysty kertomaan tiedostojesi tilaa (se on tätä sovellusta vanhempi)."
+"{server} · No longer on the server" = "{server} · Ei enää palvelimella"
+"{server} · {shared} · Opened {date}" = "{server} · {shared} · Avattu {date}"
+"{tool}  hold {key}" = "{tool}  pidä {key} painettuna"
+"{value} isn't a colour" = "{value} ei ole väri"
+"{when} · edited" = "{when} · muokattu"
+"←" = "←"
+"← ↑ → ↓" = "← ↑ → ↓"
+"← → ↑ ↓" = "← → ↑ ↓"
+"→, Space or N" = "→, Space or N"
+"↵" = "↵"
+"⇥ / ⇧⇥" = "⇥ / ⇧⇥"
+"⌘ arrows" = "⌘ arrows"
+"⌘ click" = "⌘ click"
+"⌘ scroll" = "⌘ scroll"
+"⌥ drag" = "⌥ drag"
+
+[commands]
+"align.bottom" = "Tasaa alas"
+"align.hcenter" = "Keskitä vaakasuunnassa"
+"align.left" = "Tasaa vasemmalle"
+"align.right" = "Tasaa oikealle"
+"align.top" = "Tasaa ylös"
+"align.vcenter" = "Keskitä pystysuunnassa"
+"annotation.add" = "Lisää huomautus"
+"annotation.addCategory" = "Lisää huomautusluokka"
+"annotation.categories" = "Huomautusten luokat"
+"annotation.edit" = "Muokkaa huomautusta"
+"annotation.editCategory" = "Muokkaa huomautusluokkaa"
+"annotation.list" = "Luettele huomautukset"
+"annotation.remove" = "Poista huomautus"
+"annotation.removeCategory" = "Poista huomautusluokka"
+"app.actions" = "Toiminnot"
+"app.preferences" = "Asetukset"
+"arrange.back" = "Vie takimmaiseksi"
+"arrange.backward" = "Vie taaksepäin"
+"arrange.forward" = "Tuo eteenpäin"
+"arrange.front" = "Tuo etummaiseksi"
+"arrange.packH" = "Pakkaa vaakasuunnassa"
+"arrange.packV" = "Pakkaa pystysuunnassa"
+"arrange.roundToPixels" = "Pyöristä pikseleihin"
+"arrange.spacing" = "Välistys"
+"arrange.tidy" = "Järjestä tasavälein"
+"board.connector" = "Yhdistin"
+"board.ink" = "Tussiviiva"
+"board.label" = "Yhdistimen nimiö"
+"board.nextSticky" = "Seuraava muistilappu"
+"board.setColor" = "Taulun väri"
+"board.setStyle" = "Taulun tyyli"
+"board.shape" = "Muoto ja teksti"
+"board.stamp" = "Leima"
+"board.sticky" = "Muistilappu"
+"bool.exclude" = "Sulje valinnan päällekkäinen alue pois"
+"bool.flatten" = "Yhdistä Boolen muoto vektoriksi"
+"bool.intersect" = "Leikkaa valinnan yhteinen alue"
+"bool.subtract" = "Vähennä valinta"
+"bool.union" = "Yhdistä valinta"
+"branch.archive" = "Arkistoi haara"
+"branch.create" = "Luo haara"
+"branch.list" = "Luettele haarat"
+"branch.merge" = "Yhdistä haara"
+"branch.open" = "Avaa haara"
+"branch.review" = "Tarkista haara"
+"branch.updateFromMain" = "Päivitä päähaarasta"
+"codeConnect.export" = "Vie koodiyhteydet"
+"codeConnect.import" = "Tuo koodiyhteydet"
+"codeConnect.remove" = "Katkaise yhteys koodiin"
+"codeConnect.set" = "Yhdistä koodiin"
+"collab.cursor" = "Näytä kohdistin kohdassa"
+"collab.cursorChat" = "Kohdistinkeskustelu"
+"collab.diff" = "Näytä synkronoinnin muutokset"
+"collab.files" = "Omat verkkotiedostot"
+"collab.follow" = "Seuraa"
+"collab.forgetFile" = "Unohda verkkotiedosto"
+"collab.host" = "Aloita reaaliaikainen istunto"
+"collab.join" = "Liity reaaliaikaiseen istuntoon"
+"collab.leave" = "Poistu reaaliaikaisesta istunnosta"
+"collab.manageFile" = "Hallitse julkaistua tiedostoa"
+"collab.openFile" = "Avaa verkkotiedosto"
+"collab.peers" = "Tämän tiedoston käyttäjät"
+"collab.publish" = "Julkaise palvelimelle"
+"collab.recoverFile" = "Palauta verkkotiedosto"
+"collab.registerLinks" = "Avaa kutsulinkit FigCraftissa"
+"collab.removePerson" = "Poista istunnosta"
+"collab.report" = "Ilmoita tiedostosta palvelimen ylläpitäjälle"
+"collab.serverInfo" = "Palvelimen tiedot"
+"collab.share" = "Jaa liittymiskoodilla"
+"collab.spotlight" = "Nosta minut esiin"
+"collab.stop" = "Lopeta reaaliaikainen istunto"
+"command.batch" = "Suorita useita komentoja"
+"comment.add" = "Lisää kommentti"
+"comment.delete" = "Poista kommentti"
+"comment.edit" = "Muokkaa kommenttia"
+"comment.link" = "Kopioi linkki kommenttiin"
+"comment.list" = "Luettele kommentit"
+"comment.markRead" = "Merkitse kommentti luetuksi"
+"comment.move" = "Siirrä kommentti"
+"comment.next" = "Seuraava kommentti"
+"comment.open" = "Avaa kommentti"
+"comment.people" = "Kommenttien osallistujat"
+"comment.react" = "Reagoi kommenttiin"
+"comment.reply" = "Vastaa kommenttiin"
+"comment.resolve" = "Ratkaise kommentti"
+"comment.zoom" = "Zoomaa kommentteihin"
+"component.addProperty" = "Lisää komponentin ominaisuus"
+"component.addVariant" = "Lisää variantti"
+"component.bindProperty" = "Sido taso ominaisuuteen"
+"component.combineVariants" = "Yhdistä varianteiksi"
+"component.create" = "Luo komponentti"
+"component.createMultiple" = "Luo useita komponentteja"
+"component.deleteProperty" = "Poista komponentin ominaisuus"
+"component.detach" = "Irrota ilmentymä"
+"component.editProperty" = "Muokkaa komponentin ominaisuutta"
+"component.exposeInstance" = "Tuo sisäkkäinen ilmentymä käyttöön"
+"component.goToMain" = "Siirry pääkomponenttiin"
+"component.hideWhenPublishing" = "Kätke julkaistaessa"
+"component.list" = "Luettele komponentit"
+"component.makeSlot" = "Luo sisältöpaikka"
+"component.playground" = "Komponenttien kokeilualue"
+"component.properties" = "Komponentin ominaisuudet"
+"component.pushChanges" = "Siirrä muutokset pääkomponenttiin"
+"component.removeSlot" = "Poista sisältöpaikka"
+"component.resetInstance" = "Palauta kaikki muutokset"
+"component.resetOverride" = "Palauta ohitus"
+"component.restoreMain" = "Palauta pääkomponentti"
+"dev.compare" = "Vertaa muutoksia"
+"dev.focus" = "Kohdistusnäkymä"
+"dev.resolveChange" = "Ratkaise muutos"
+"dev.unfocus" = "Poistu kohdistusnäkymästä"
+"devResource.add" = "Lisää kehittäjäresurssi"
+"devResource.edit" = "Muokkaa kehittäjäresurssia"
+"devResource.list" = "Luettele kehittäjäresurssit"
+"devResource.remove" = "Poista kehittäjäresurssi"
+"distribute.horizontal" = "Jaa vaakavälit tasan"
+"distribute.vertical" = "Jaa pystyvälit tasan"
+"doc.home" = "Aloitus"
+"doc.list" = "Luettele asiakirjat"
+"doc.nextTab" = "Seuraava välilehti"
+"doc.previousTab" = "Edellinen välilehti"
+"doc.switch" = "Vaihda asiakirjaa"
+"edit.copy" = "Kopioi"
+"edit.copyAsCss" = "Kopioi CSS-muodossa"
+"edit.copyAsPng" = "Kopioi PNG-muodossa"
+"edit.copyAsSvg" = "Kopioi SVG-muodossa"
+"edit.copyAsText" = "Kopioi tekstinä"
+"edit.copyLink" = "Kopioi linkki valintaan"
+"edit.copyProperties" = "Kopioi ominaisuudet"
+"edit.cut" = "Leikkaa"
+"edit.delete" = "Poista"
+"edit.duplicate" = "Monista"
+"edit.findReplace" = "Etsi ja korvaa"
+"edit.paste" = "Liitä"
+"edit.pasteDesignLayers" = "Liitä suunnittelutasoja"
+"edit.pasteOver" = "Liitä valinnan päälle"
+"edit.pasteProperties" = "Liitä ominaisuudet"
+"edit.pasteReplace" = "Liitä korvaten"
+"edit.pickColor" = "Poimi väri"
+"edit.redo" = "Tee uudelleen"
+"edit.repeat" = "Toista viimeisin komento"
+"edit.setDefaultProperties" = "Aseta oletusominaisuudet"
+"edit.undo" = "Kumoa"
+"effect.add" = "Lisää tehoste"
+"effect.move" = "Siirrä tehoste"
+"effect.remove" = "Poista tehoste"
+"effect.set" = "Aseta tehoste"
+"export.add" = "Lisää vientiasetus"
+"export.remove" = "Poista vientiasetus"
+"export.update" = "Muokkaa vientiasetusta"
+"file.close" = "Sulje välilehti"
+"file.colorProfile" = "Väriprofiili"
+"file.duplicate" = "Monista tiedosto"
+"file.export" = "Vie"
+"file.exportFramesPdf" = "Vie kehykset PDF-muodossa"
+"file.exportLayers" = "Vie tasot"
+"file.exportSvg" = "Vie valinta SVG-muodossa"
+"file.import" = "Tuo"
+"file.moveTab" = "Siirrä välilehti"
+"file.new" = "Uusi suunnittelutiedosto"
+"file.newBoard" = "Uusi taulu"
+"file.newFromTemplate" = "Uusi mallista"
+"file.open" = "Avaa"
+"file.openRecent" = "Avaa viimeksi avattu"
+"file.placeImage" = "Sijoita kuva"
+"file.recover" = "Palauta tiedosto"
+"file.rename" = "Nimeä tiedosto uudelleen"
+"file.revert" = "Palauta tallennettu"
+"file.save" = "Tallenna"
+"file.saveAs" = "Tallenna nimellä"
+"file.saveVersion" = "Tallenna versiohistoriaan"
+"file.versionHistory" = "Näytä versiohistoria"
+"fill.add" = "Lisää täyttö"
+"fill.move" = "Siirrä täyttö"
+"fill.pattern" = "Kuviotäyttö"
+"fill.remove" = "Poista täyttö"
+"fill.set" = "Aseta täyttö"
+"frame.create" = "Luo kehys"
+"frame.presets" = "Luettele kehysten esiasetukset"
+"frame.swapOrientation" = "Vaihda suunta"
+"grid.add" = "Lisää asetteluruudukko"
+"grid.move" = "Siirrä asetteluruudukko"
+"grid.remove" = "Poista asetteluruudukko"
+"guide.add" = "Lisää apuviiva"
+"guide.clear" = "Poista kaikki apuviivat"
+"guide.move" = "Siirrä apuviiva"
+"guide.remove" = "Poista apuviiva"
+"guide.select" = "Valitse apuviiva"
+"help.about" = "Tietoja FigCraftista"
+"help.gettingStarted" = "Aloittaminen"
+"help.page" = "Ohjesivu"
+"help.shortcuts" = "Pikanäppäimet"
+"image.adjust" = "Säädä kuvaa"
+"image.deletePreset" = "Poista kuvan esiasetus"
+"image.place" = "Sijoita kuva"
+"image.presets" = "Kuvan esiasetukset"
+"image.savePreset" = "Tallenna kuvan esiasetus"
+"inspect.assets" = "Tarkastele resursseja"
+"inspect.code" = "Tason koodi"
+"inspect.componentCode" = "Komponentin koodi"
+"inspect.properties" = "Tarkastele ominaisuuksia"
+"inspect.readyForDev" = "Kehitysvalmis"
+"instance.create" = "Luo ilmentymä"
+"instance.exposed" = "Käyttöön tuodut sisäkkäiset ilmentymät"
+"instance.place" = "Sijoita ilmentymä"
+"instance.resetSlot" = "Palauta sisältöpaikka"
+"instance.setProperties" = "Aseta ilmentymän ominaisuudet"
+"instance.slotInsert" = "Lisää sisältöpaikkaan"
+"instance.swap" = "Vaihda ilmentymä"
+"instance.swapAt" = "Vaihda ilmentymä pisteessä"
+"layers.collapseAll" = "Supista tasot"
+"layout.add" = "Lisää automaattinen asettelu"
+"layout.remove" = "Poista automaattinen asettelu"
+"layout.setTrack" = "Aseta ruudukon osan koko"
+"layout.suggest" = "Ehdota automaattista asettelua"
+"libraries.open" = "Kirjastot"
+"libraries.publish" = "Julkaise kirjasto…"
+"library.acceptUpdates" = "Hyväksy kirjaston päivitykset"
+"library.add" = "Lisää kirjasto"
+"library.aliasVariable" = "Luo alias kirjastomuuttujaan"
+"library.applyStyle" = "Käytä kirjastotyyliä"
+"library.bindVariable" = "Sido kirjastomuuttuja"
+"library.extendCollection" = "Laajenna kirjastokokoelmaa"
+"library.import" = "Tuo kirjastokomponentti"
+"library.importVariable" = "Tuo kirjastomuuttuja"
+"library.list" = "Luettele kirjastot"
+"library.place" = "Sijoita kirjastokomponentti"
+"library.publish" = "Julkaise kirjasto"
+"library.publishToServer" = "Julkaise kirjasto palvelimelle"
+"library.remove" = "Poista kirjasto"
+"library.setVariableMode" = "Aseta kirjastomuuttujan tila"
+"library.swap" = "Vaihda kirjasto"
+"library.swapAt" = "Vaihda ilmentymä kirjastokomponenttiin"
+"library.updates" = "Kirjaston päivitykset"
+"library.usage" = "Kirjaston käyttö"
+"measure.distances" = "Mittaa etäisyyksiä"
+"measure.padding" = "Mittaa automaattisen asettelun sisämarginaali"
+"node.create" = "Luo taso"
+"node.get" = "Hae taso"
+"node.reorder" = "Muuta tason järjestystä"
+"node.reparent" = "Siirrä taso kohteeseen"
+"node.set" = "Aseta ominaisuudet"
+"object.batchRename" = "Nimeä joukko uudelleen"
+"object.convertToFrame" = "Muunna kehykseksi"
+"object.convertToGroup" = "Muunna ryhmäksi"
+"object.convertToSection" = "Muunna osioksi"
+"object.flipH" = "Peilaa vaakasuunnassa"
+"object.flipV" = "Peilaa pystysuunnassa"
+"object.frameSelection" = "Kehystä valinta"
+"object.group" = "Ryhmittele valinta"
+"object.hideOthers" = "Kätke muut tasot"
+"object.mask" = "Käytä maskina"
+"object.moveToPage" = "Siirrä sivulle"
+"object.opacityKeys" = "Peittävyys numeronäppäimillä"
+"object.rasterize" = "Rasteroi valinta"
+"object.releaseMask" = "Vapauta maski"
+"object.removeFill" = "Poista täyttö"
+"object.removeFrame" = "Poista kehys"
+"object.removeStroke" = "Poista reunaviiva"
+"object.rename" = "Nimeä uudelleen"
+"object.resizeToFit" = "Sovita koko"
+"object.rotate180" = "Kierrä 180°"
+"object.rotateLeft" = "Kierrä 90° vasemmalle"
+"object.rotateRight" = "Kierrä 90° oikealle"
+"object.setThumbnail" = "Aseta pikkukuvaksi"
+"object.swapFillStroke" = "Vaihda täyttö ja reunaviiva keskenään"
+"object.toggleLock" = "Lukitse/avaa valinnan lukitus"
+"object.toggleVisible" = "Näytä/kätke valinta"
+"object.ungroup" = "Pura valinnan ryhmittely"
+"object.wrapInSection" = "Ympäröi uudella osiolla"
+"page.add" = "Lisää sivu"
+"page.delete" = "Poista sivu"
+"page.duplicate" = "Monista sivu"
+"page.list" = "Luettele sivut"
+"page.move" = "Siirrä sivu"
+"page.rename" = "Nimeä sivu uudelleen"
+"page.select" = "Siirry sivulle"
+"page.setBackground" = "Sivun tausta"
+"paint.documentColors" = "Asiakirjan värit"
+"plugin.close" = "Sulje liitännäispaneeli"
+"plugin.directory.install" = "Asenna liitännäinen hakemistosta"
+"plugin.directory.list" = "Selaa liitännäishakemistoa"
+"plugin.directory.publish" = "Julkaise liitännäinen hakemistoon"
+"plugin.directory.unpublish" = "Peru liitännäisen julkaisu hakemistosta"
+"plugin.event" = "Käytä liitännäispaneelin säädintä"
+"plugin.import" = "Tuo liitännäinen manifestista…"
+"plugin.list" = "Luettele liitännäiset"
+"plugin.remove" = "Poista liitännäinen"
+"plugin.run" = "Suorita liitännäinen"
+"plugin.ui" = "Liitännäispaneeli"
+"plugins.manage" = "Hallitse liitännäisiä…"
+"plugins.runLast" = "Suorita viimeisin liitännäinen"
+"pref.autoSave" = "Tallenna tiedostot automaattisesti"
+"pref.highlightHover" = "Korosta tasot osoitettaessa"
+"pref.keepTool" = "Pidä työkalu valittuna käytön jälkeen"
+"pref.language" = "Käyttöliittymän kieli"
+"pref.nudge" = "Siirtoaskeleen koko"
+"pref.numberKeysOpacity" = "Säädä peittävyyttä numeronäppäimillä"
+"pref.publishServer" = "Verkkojakamisen palvelin"
+"pref.reduceMotion" = "Vähennä liikettä"
+"pref.renameDuplicates" = "Nimeä monistetut tasot uudelleen"
+"pref.showDimensions" = "Näytä objektien mitat"
+"pref.startOnHome" = "Aloita Aloitus-näkymästä"
+"pref.userName" = "Nimesi kommenteissa"
+"proto.action.add" = "Lisää prototyyppitoiminto"
+"proto.action.move" = "Muuta prototyyppitoimintojen järjestystä"
+"proto.action.remove" = "Poista prototyyppitoiminto"
+"proto.action.set" = "Muokkaa prototyyppitoimintoa"
+"proto.closePreview" = "Sulje prototyypin esikatselu"
+"proto.conditional.addBlock" = "Lisää muuten jos / muuten"
+"proto.conditional.removeBlock" = "Poista jos / muuten jos / muuten"
+"proto.conditional.setCondition" = "Muokkaa ehtoa"
+"proto.evaluate" = "Laske prototyyppilauseke"
+"proto.flow.add" = "Lisää kulun aloituspiste"
+"proto.flow.remove" = "Poista kulku"
+"proto.flow.rename" = "Nimeä kulku uudelleen"
+"proto.interaction.add" = "Lisää vuorovaikutus"
+"proto.interaction.clear" = "Poista kaikki vuorovaikutukset"
+"proto.interaction.remove" = "Poista vuorovaikutus"
+"proto.interaction.set" = "Muokkaa vuorovaikutusta"
+"proto.present" = "Esitä"
+"proto.presentOptions" = "Esityksen asetukset"
+"proto.preview" = "Avaa prototyypin esikatselu"
+"proto.settings" = "Prototyypin asetukset"
+"section.toggleContents" = "Kätke/näytä osion sisältö"
+"select.add" = "Lisää valintaan"
+"select.all" = "Valitse kaikki"
+"select.area" = "Valitse alue"
+"select.byName" = "Valitse tasoja nimen perusteella"
+"select.children" = "Valitse alikohteet"
+"select.inverse" = "Käännä valinta"
+"select.layersAt" = "Pisteessä olevat tasot"
+"select.matching" = "Valitse vastaavat tasot"
+"select.next" = "Valitse seuraava rinnakkaiskohde"
+"select.none" = "Poista valinta"
+"select.parent" = "Valitse emotaso"
+"select.previous" = "Valitse edellinen rinnakkaiskohde"
+"select.remove" = "Poista valinnasta"
+"select.sameEffect" = "Valitse sama tehoste"
+"select.sameFill" = "Valitse sama täyttö"
+"select.sameFont" = "Valitse sama fontti"
+"select.sameInstance" = "Valitse sama ilmentymä"
+"select.sameProperties" = "Valitse samat ominaisuudet"
+"select.sameStroke" = "Valitse sama reunaviiva"
+"select.sameText" = "Valitse samat tekstiominaisuudet"
+"select.set" = "Valitse"
+"selection.applyColorStyle" = "Käytä valinnan värityyliä"
+"selection.colors" = "Valinnan värit"
+"selection.selectColor" = "Valitse tämänväriset tasot"
+"selection.setPaint" = "Muuta valinnan väriä"
+"shape.arrow" = "Nuoli"
+"shape.ellipse" = "Ellipsi"
+"shape.line" = "Viiva"
+"shape.polygon" = "Monikulmio"
+"shape.rectangle" = "Suorakulmio"
+"shape.star" = "Tähti"
+"shapeBuilder.merge" = "Yhdistä alueet"
+"shapeBuilder.mode" = "Muodonrakentimen tila"
+"shapeBuilder.regions" = "Muodonrakentimen alueet"
+"shapeBuilder.remove" = "Poista alueet"
+"stroke.add" = "Lisää reunaviiva"
+"stroke.brush" = "Sivellin"
+"stroke.move" = "Siirrä reunaviiva"
+"stroke.remove" = "Poista reunaviiva"
+"stroke.set" = "Aseta reunaviiva"
+"stroke.widthProfile" = "Leveysprofiili"
+"style.apply" = "Käytä tyyliä"
+"style.bind" = "Sido muuttuja tyylissä"
+"style.create" = "Luo tyyli"
+"style.delete" = "Poista tyyli"
+"style.detach" = "Irrota tyyli"
+"style.duplicate" = "Monista tyyli"
+"style.list" = "Luettele tyylit"
+"style.move" = "Siirrä tyylejä"
+"style.renameFolder" = "Nimeä tyylikansio uudelleen"
+"style.update" = "Muokkaa tyyliä"
+"template.list" = "Luettele mallit"
+"text.alignCenter" = "Keskitä"
+"text.alignJustify" = "Tasaa molemmat reunat"
+"text.alignLeft" = "Tasaa vasemmalle"
+"text.alignRight" = "Tasaa oikealle"
+"text.bold" = "Lihavointi"
+"text.bulletList" = "Luettelomerkitty luettelo"
+"text.case" = "Kirjainkoko"
+"text.caseLower" = "Pienet kirjaimet"
+"text.caseOriginal" = "Alkuperäinen kirjainkoko"
+"text.caseSmallCaps" = "Kapiteelit"
+"text.caseTitle" = "Sanojen isot alkukirjaimet"
+"text.caseUpper" = "Isot kirjaimet"
+"text.create" = "Teksti"
+"text.decoration" = "Koristelu"
+"text.edit.begin" = "Muokkaa tekstiä"
+"text.edit.caret" = "Aseta kohdistin"
+"text.edit.end" = "Lopeta tekstin muokkaus"
+"text.edit.insert" = "Kirjoita tekstiä"
+"text.edit.key" = "Tekstinäppäin"
+"text.edit.preedit" = "Koosta tekstiä (IME)"
+"text.edit.selectLine" = "Valitse rivi"
+"text.edit.selectWord" = "Valitse sana"
+"text.edit.selection" = "Tekstivalinta"
+"text.endPreview" = "Lopeta tekstin esikatselu"
+"text.fonts" = "Luettele fontit"
+"text.italic" = "Kursivointi"
+"text.lineHeightDown" = "Pienennä rivikorkeutta"
+"text.lineHeightUp" = "Suurenna rivikorkeutta"
+"text.link" = "Luo linkki"
+"text.listIndent" = "Sisennä luettelo"
+"text.listOutdent" = "Vähennä luettelon sisennystä"
+"text.listStyle" = "Luettelotyyli"
+"text.loadFont" = "Lataa fonttitiedosto"
+"text.maxLines" = "Rivien enimmäismäärä"
+"text.missingFonts" = "Puuttuvat fontit"
+"text.numberList" = "Numeroitu luettelo"
+"text.onPath" = "Teksti polulla"
+"text.paragraphIndent" = "Kappaleen sisennys"
+"text.paragraphSpacing" = "Kappaleväli"
+"text.pathOptions" = "Tekstipolun asetukset"
+"text.preview" = "Esikatsele tekstimuutosta"
+"text.refit" = "Sovita teksti fontteihin"
+"text.removeFromPath" = "Poista teksti polulta"
+"text.rescanFonts" = "Etsi asennetut fontit uudelleen"
+"text.set" = "Aseta teksti"
+"text.setFeatures" = "OpenType-ominaisuudet"
+"text.setVariations" = "Muuttuvan fontin akselit"
+"text.sizeDown" = "Pienennä fonttikokoa"
+"text.sizeUp" = "Suurenna fonttikokoa"
+"text.strikethrough" = "Yliviivaus"
+"text.style" = "Muotoile tekstialue"
+"text.trackingDown" = "Pienennä merkkiväliä"
+"text.trackingUp" = "Suurenna merkkiväliä"
+"text.underline" = "Alleviivaus"
+"text.weightDown" = "Vähennä fontin paksuutta"
+"text.weightUp" = "Lisää fontin paksuutta"
+"tool.arrow" = "Nuoli"
+"tool.comment" = "Kommentti"
+"tool.connector" = "Yhdistin"
+"tool.ellipse" = "Ellipsi"
+"tool.eraser" = "Pyyhekumi"
+"tool.frame" = "Kehys"
+"tool.hand" = "Käsi"
+"tool.highlighter" = "Korostuskynä"
+"tool.line" = "Viiva"
+"tool.marker" = "Tussi"
+"tool.move" = "Siirrä"
+"tool.pen" = "Kynä"
+"tool.pencil" = "Lyijykynä"
+"tool.pencilBrush" = "Lyijykynäsivellin"
+"tool.place" = "Sijoita työkalulla"
+"tool.polygon" = "Monikulmio"
+"tool.rectangle" = "Suorakulmio"
+"tool.scale" = "Skaalaus"
+"tool.scaleAnchor" = "Skaalauksen ankkuri"
+"tool.section" = "Osio"
+"tool.set" = "Valitse työkalu"
+"tool.shape" = "Muodot"
+"tool.shapeBuilder" = "Muodonrakennin"
+"tool.slice" = "Viipale"
+"tool.stamp" = "Leima"
+"tool.star" = "Tähti"
+"tool.sticky" = "Muistilappu"
+"tool.text" = "Teksti"
+"transform.move" = "Siirrä"
+"transform.moveTo" = "Siirrä kohteeseen"
+"transform.nudge" = "Siirrä askelittain"
+"transform.nudgeSize" = "Muuta kokoa askelittain"
+"transform.resize" = "Muuta kokoa"
+"transform.rotate" = "Kierrä"
+"transform.rotationOrigin" = "Siirrä kiertokeskipistettä"
+"transform.scale" = "Skaalaus"
+"transform.setRotationOrigin" = "Aseta kiertokeskipiste"
+"variable.addMode" = "Lisää tila"
+"variable.bind" = "Sido muuttuja"
+"variable.create" = "Luo muuttuja"
+"variable.createCollection" = "Luo muuttujakokoelma"
+"variable.delete" = "Poista muuttuja"
+"variable.deleteCollection" = "Poista kokoelma"
+"variable.duplicate" = "Monista muuttuja"
+"variable.export" = "Vie muuttujat"
+"variable.import" = "Tuo muuttujat"
+"variable.list" = "Luettele muuttujat"
+"variable.moveMode" = "Siirrä tila"
+"variable.removeMode" = "Poista tila"
+"variable.renameCollection" = "Nimeä kokoelma uudelleen"
+"variable.renameMode" = "Nimeä tila uudelleen"
+"variable.resetOverride" = "Palauta muuttujan ohitus"
+"variable.set" = "Aseta muuttujan arvo"
+"variable.setMode" = "Aseta muuttujan tila"
+"variable.update" = "Muokkaa muuttujaa"
+"vector.create" = "Vektori"
+"vector.deleteHeal" = "Poista ja korjaa valinta"
+"vector.edit.addVertex" = "Lisää piste"
+"vector.edit.begin" = "Muokkaa vektoria"
+"vector.edit.bend" = "Taivuta segmenttiä"
+"vector.edit.bounds" = "Valittujen pisteiden rajat"
+"vector.edit.connect" = "Yhdistä pisteet"
+"vector.edit.cornerRadius" = "Pisteen kulmasäde"
+"vector.edit.cut" = "Leikkaa polku"
+"vector.edit.delete" = "Poista pisteet"
+"vector.edit.end" = "Lopeta muokkaus"
+"vector.edit.erase" = "Pyyhi"
+"vector.edit.lasso" = "Valitse lassolla"
+"vector.edit.mirroring" = "Kahvojen peilaus"
+"vector.edit.moveHandles" = "Siirrä kahvoja"
+"vector.edit.moveVertices" = "Siirrä pisteitä"
+"vector.edit.nudge" = "Siirrä pisteitä askelittain"
+"vector.edit.paint" = "Maalipurkki"
+"vector.edit.pen" = "Kynän piste"
+"vector.edit.penEnd" = "Päätä kynäpolku"
+"vector.edit.position" = "Pisteen sijainti"
+"vector.edit.resize" = "Muuta pisteiden kokoa"
+"vector.edit.rotate" = "Kierrä pisteitä"
+"vector.edit.select" = "Valitse pisteitä"
+"vector.edit.selectAll" = "Valitse kaikki pisteet"
+"vector.edit.setHandle" = "Aseta kahva"
+"vector.edit.smooth" = "Pehmennä tai terävöitä pisteitä"
+"vector.edit.state" = "Vektorimuokkauksen tila"
+"vector.edit.strokeCap" = "Pisteen viivanpää"
+"vector.edit.strokeJoin" = "Pisteen viivaliitos"
+"vector.edit.tool" = "Vektorimuokkauksen työkalu"
+"vector.edit.transform" = "Muunna pisteitä"
+"vector.edit.widthPoint" = "Leveyspiste"
+"vector.flatten" = "Yhdistä vektorimuodoksi"
+"vector.join" = "Yhdistä valinta"
+"vector.offset" = "Siirrä polun reunaa"
+"vector.outlineStroke" = "Muunna reunaviiva poluksi"
+"vector.reverse" = "Käännä polun suunta"
+"vector.simplify" = "Yksinkertaista vektori"
+"vector.smoothJoin" = "Yhdistä valinta pehmeästi"
+"version.autosave" = "Tallenna versio automaattisesti"
+"version.delete" = "Poista versio"
+"version.duplicate" = "Monista versio"
+"version.exitPreview" = "Takaisin nykyiseen versioon"
+"version.list" = "Luettele versiot"
+"version.preview" = "Katsele versiota"
+"version.rename" = "Nimeä versio uudelleen"
+"version.restore" = "Palauta versio"
+"view.assets" = "Resurssipaneeli"
+"view.comments" = "Kommentit"
+"view.contextMenu" = "Näytä pikavalikko"
+"view.design" = "Suunnittelupaneeli"
+"view.designPrototype" = "Vaihda suunnittelun ja prototyypin välillä"
+"view.devMode" = "Kehittäjätila"
+"view.frameOutlines" = "Kehysten ääriviivat"
+"view.fullscreen" = "Koko näyttö"
+"view.get" = "Hae näkymä"
+"view.layers" = "Tasopaneeli"
+"view.layoutGrids" = "Asetteluruudukot"
+"view.leftSidebar" = "Näytä/kätke vasen sivupalkki"
+"view.maskOutlines" = "Maskien ääriviivat"
+"view.multiplayerCursors" = "Yhteiskäytön kohdistimet"
+"view.nextFrame" = "Zoomaa seuraavaan kehykseen"
+"view.nextPage" = "Seuraava sivu"
+"view.nextRegion" = "Kohdista seuraava alue"
+"view.outlines" = "Ääriviivat"
+"view.outlinesHiddenLayers" = "Sisällytä kätketyt tasot ääriviivoihin"
+"view.outlinesObjectBounds" = "Sisällytä objektien rajat ääriviivoihin"
+"view.outlinesSelection" = "Valinnan ääriviivat"
+"view.pan" = "Siirrä näkymää"
+"view.panelWidths" = "Palauta paneelien leveydet"
+"view.pixelGrid" = "Pikseliruudukko"
+"view.pixelPreview" = "Pikseliesikatselu"
+"view.prevFrame" = "Zoomaa edelliseen kehykseen"
+"view.prevPage" = "Edellinen sivu"
+"view.previousRegion" = "Kohdista edellinen alue"
+"view.proofSrgb" = "sRGB-vedossimulointi"
+"view.prototype" = "Prototyyppipaneeli"
+"view.rulers" = "Viivaimet"
+"view.set" = "Aseta näkymä"
+"view.slices" = "Viipaleet"
+"view.snapGeometry" = "Tartu geometriaan"
+"view.snapObjects" = "Tartu objekteihin"
+"view.snapPixel" = "Tartu pikseliruudukkoon"
+"view.themeDark" = "Tumma teema"
+"view.themeLight" = "Vaalea teema"
+"view.themeSystem" = "Seuraa järjestelmän teemaa"
+"view.toggleUi" = "Näytä/kätke käyttöliittymä"
+"view.zoom100" = "Zoomaa kokoon 100 %"
+"view.zoom200" = "Zoomaa kokoon 200 %"
+"view.zoom50" = "Zoomaa kokoon 50 %"
+"view.zoomAt" = "Zoomaustyökalu"
+"view.zoomFit" = "Sovita näkymään"
+"view.zoomIn" = "Lähennä"
+"view.zoomOut" = "Loitonna"
+"view.zoomSelection" = "Zoomaa valintaan"
+"widget.click" = "Napsauta pienoisohjelmaa"
+"widget.insert" = "Lisää pienoisohjelma"
+"widget.list" = "Luettele pienoisohjelmat"
+"window.focus" = "Tuo ikkuna etummaiseksi"
+"window.new" = "Uusi ikkuna"
+
+[menu]
+"bool.exclude" = "Jätä pois"
+"bool.flatten" = "Yhdistä vektorimuodoksi"
+"bool.intersect" = "Leikkaus"
+"bool.subtract" = "Vähennä"
+"bool.union" = "Yhdiste"
+"file.duplicate" = "Monista"
+"file.import" = "Tuo tiedostosta…"
+"file.rename" = "Nimeä uudelleen"
+"libraries.open" = "Avaa kirjastot"
+"select.sameEffect" = "Tehoste"
+"select.sameFill" = "Täyttö"
+"select.sameFont" = "Fontti"
+"select.sameInstance" = "Ilmentymä"
+"select.sameProperties" = "Ominaisuudet"
+"select.sameStroke" = "Reunaviiva"
+"select.sameText" = "Tekstiominaisuudet"
+"text.alignCenter" = "Keskitä teksti"
+"text.alignJustify" = "Tasaa tekstin molemmat reunat"
+"text.alignLeft" = "Tasaa teksti vasemmalle"
+"text.alignRight" = "Tasaa teksti oikealle"
+"view.assets" = "Resurssit"
+"view.design" = "Suunnittelu"
+"view.layers" = "Tasot"
+"view.outlines" = "Näytä ääriviivat"
+"view.outlinesHiddenLayers" = "Sisällytä kätketyt tasot"
+"view.outlinesObjectBounds" = "Sisällytä objektien rajat"
+"view.outlinesSelection" = "Näytä valinnan ääriviivat"
+"view.prototype" = "Prototyyppi"
+"view.themeDark" = "Tumma"
+"view.themeLight" = "Vaalea"
+"view.themeSystem" = "Seuraa järjestelmää"
diff --git a/crates/ui-egui/locales/fr.toml b/crates/ui-egui/locales/fr.toml
index 7fafd3c91..e58239839 100644
--- a/crates/ui-egui/locales/fr.toml
+++ b/crates/ui-egui/locales/fr.toml
@@ -17,8 +17,12 @@ status = "draft — needs native review"
 "1…9, 0" = "1…9, 0"
 "@{login}: {prs} PRs, {commits} commits, +{added} / −{deleted} lines (Δ {delta}), +{bin_added} / −{bin_deleted} binary assets, {first} – {last}" = "@{login} : {prs} PR, {commits} commits, +{added} / −{deleted} lignes (Δ {delta}), +{bin_added} / −{bin_deleted} ressources binaires, {first} – {last}"
 "A collection of this file with these modes and variables: override their values per mode and add variables of its own" = "Une collection de ce fichier avec ces modes et ces variables : remplacez leurs valeurs par mode et ajoutez vos propres variables"
+"A .figcraft file with this name already exists. Choose its full name to confirm replacement." = "Un fichier .figcraft portant ce nom existe déjà. Choisissez son nom complet pour confirmer le remplacement."
 "A layer on its own aligns to its frame: select more layers, or one in a frame" = "Un calque seul s’aligne sur son cadre : sélectionnez d’autres calques, ou un calque dans un cadre"
+"A responsive product page: hero, features, figures, a quote and a footer" = "Une page produit responsive : héros, fonctionnalités, chiffres, une citation et un pied de page"
 "A spring plays until it settles: its mass, stiffness and damping set how long" = "Un ressort joue jusqu’à ce qu’il se stabilise : sa masse, sa rigidité et son amortissement en fixent la durée"
+"A title, an agenda, a big figure, a chart and a closing slide" = "Un titre, un sommaire, un grand chiffre, un graphique et une diapositive de clôture"
+"A to Z" = "A à Z"
 "About" = "À propos"
 "About FigCraft" = "À propos de FigCraft"
 "About this server" = "À propos de ce serveur"
@@ -64,6 +68,7 @@ status = "draft — needs native review"
 "Add variant with a new value" = "Ajouter une variante avec une nouvelle valeur"
 "Added" = "Ajouté"
 "Added the library \"{name}\"" = "Bibliothèque « {name} » ajoutée"
+"Adding to {name}" = "Ajout dans {name}"
 "Adjust" = "Réglages"
 "Adjustment presets" = "Préréglages"
 "Advanced" = "Avancé"
@@ -89,7 +94,9 @@ status = "draft — needs native review"
 "All supported properties" = "Toutes les propriétés prises en charge"
 "All variables" = "Toutes les variables"
 "Alpha" = "Alpha"
+"Alphabetical" = "Alphabétique"
 "Alt+drag" = "Alt+glisser"
+"An analytics screen on a grid: figures, charts drawn from vectors and a table" = "Un écran d’analyse sur une grille : chiffres, graphiques tracés en vectoriel et un tableau"
 "An invite link that opens FigCraft and joins" = "Un lien d’invitation qui ouvre FigCraft et rejoint la session"
 "Anchor" = "Ancre"
 "Android" = "Android"
@@ -108,6 +115,8 @@ status = "draft — needs native review"
 "Apply variable" = "Appliquer une variable"
 "Apply variable to text" = "Appliquer une variable au texte"
 "Apply variable to visibility" = "Appliquer une variable à la visibilité"
+"Apps" = "Applications"
+"Apr" = "avr."
 "Arc" = "Arc"
 "Arc ratio" = "Rapport de l’arc"
 "Arc start" = "Début de l’arc"
@@ -116,9 +125,11 @@ status = "draft — needs native review"
 "Archived" = "Archivée"
 "Arrange" = "Disposer"
 "Arrow" = "Flèche"
+"Arrow at the end" = "Flèche à la fin"
 "As typed" = "Tel que saisi"
 "Asking the server…" = "Interrogation du serveur…"
 "Assets" = "Ressources"
+"Aug" = "août"
 "Auto" = "Auto"
 "Auto (space around)" = "Auto (espace autour)"
 "Auto (space between)" = "Auto (espace entre)"
@@ -163,6 +174,7 @@ status = "draft — needs native review"
 "Bottom" = "Bas"
 "Bottom left radius" = "Rayon inférieur gauche"
 "Bottom right radius" = "Rayon inférieur droit"
+"Bound to {name}. Click to detach the variable." = "Lié à {name}. Cliquez pour détacher la variable."
 "Branch" = "Branche"
 "Branch archived" = "Branche archivée"
 "Branch merged" = "Branche fusionnée"
@@ -187,7 +199,9 @@ status = "draft — needs native review"
 "C or ⇧C" = "C ou ⇧C"
 "CMYK colour" = "Couleur CMJN"
 "Can view" = "Peut consulter"
+"Check" = "Coche"
 "Checking the server…" = "Vérification auprès du serveur…"
+"Chevron" = "Chevron"
 "Clear from this list" = "Effacer de cette liste"
 "Code or invite link" = "Code ou lien d’invitation"
 "Color profile: {name}" = "Profil colorimétrique : {name}"
@@ -233,7 +247,6 @@ status = "draft — needs native review"
 "Close tab" = "Fermer l’onglet"
 "Close version history" = "Fermer l’historique des versions"
 "Close when clicking outside" = "Fermer en cliquant à l’extérieur"
-"Close without saving" = "Fermer sans enregistrer"
 "Code" = "Code"
 "Code syntax" = "Syntaxe du code"
 "Collapse" = "Réduire"
@@ -249,6 +262,7 @@ status = "draft — needs native review"
 "Color values in this file are in this color space." = "Les valeurs de couleur de ce fichier sont dans cet espace colorimétrique."
 "Color variables" = "Variables de couleur"
 "Colour" = "Couleur"
+"Colour and text styles, Light and Dark variables, buttons, inputs and cards" = "Styles de couleur et de texte, variables Clair et Sombre, boutons, champs et cartes"
 "Column" = "Colonne"
 "Column gap" = "Espacement des colonnes"
 "Column sizes" = "Tailles des colonnes"
@@ -260,6 +274,8 @@ status = "draft — needs native review"
 "Commits" = "Commits"
 "Company" = "Entreprise"
 "Compare changes" = "Comparer les modifications"
+"Compare with" = "Comparer avec"
+"Compatibility notes" = "Notes de compatibilité"
 "Completed" = "Terminé"
 "Component" = "Composant"
 "Component name" = "Nom du composant"
@@ -274,6 +290,7 @@ status = "draft — needs native review"
 "Connected" = "Connecté"
 "Connected to code: {from}" = "Relié au code : {from}"
 "Connection lost, reconnecting (attempt {attempt})…" = "Connexion perdue, reconnexion (tentative {attempt})…"
+"Connector" = "Connecteur"
 "Constrain proportions" = "Conserver les proportions"
 "Constraints" = "Contraintes"
 "Content" = "Contenu"
@@ -284,6 +301,8 @@ status = "draft — needs native review"
 "Contributors" = "Contributeurs"
 "Contributors: {people} · Commits: {commits}" = "Contributeurs : {people} · Commits : {commits}"
 "Controller" = "Manette"
+"Convert to frame" = "Convertir en cadre"
+"Convert to section" = "Convertir en section"
 "Cool" = "Froid"
 "Copied as CSS" = "Copié en CSS"
 "Copied as PNG" = "Copié en PNG"
@@ -303,6 +322,7 @@ status = "draft — needs native review"
 "Corner smoothing" = "Lissage des angles"
 "Couldn't download the variables" = "Impossible de télécharger les variables"
 "Couldn't reach {server}: showing what this computer remembers." = "Impossible de joindre {server} : affichage de ce dont cet ordinateur se souvient."
+"Couldn't read {name}." = "Impossible de lire {name}."
 "Couldn't save automatically: {error}" = "Impossible d’enregistrer automatiquement : {error}"
 "Count" = "Nombre"
 "Create" = "Créer"
@@ -317,6 +337,7 @@ status = "draft — needs native review"
 "Create property…" = "Créer une propriété…"
 "Create style" = "Créer un style"
 "Create style from the selected text" = "Créer un style à partir du texte sélectionné"
+"Created" = "Création"
 "Crop" = "Recadrer"
 "Crop marks" = "Traits de coupe"
 "Ctrl+arrows" = "Ctrl+flèches"
@@ -326,10 +347,14 @@ status = "draft — needs native review"
 "Current version" = "Version actuelle"
 "Cursor chat" = "Chat au curseur"
 "Custom" = "Personnalisé"
+"Custom size" = "Taille personnalisée"
 "Cut" = "Couper"
 "Dark" = "Sombre"
 "Darken" = "Assombrir"
 "Dash" = "Tirets"
+"Dashboard" = "Tableau de bord"
+"Date created" = "Date de création"
+"Dec" = "déc."
 "Decoration style" = "Style de décoration"
 "Decoration" = "Décoration"
 "Deep select" = "Sélection en profondeur"
@@ -356,6 +381,8 @@ status = "draft — needs native review"
 "Description" = "Description"
 "Description (optional)" = "Description (facultative)"
 "Design" = "Design"
+"Design panel" = "Panneau Design"
+"Design system starter" = "Base de système de design"
 "Desktop" = "Ordinateur"
 "Destination" = "Destination"
 "Detach alias" = "Détacher l’alias"
@@ -366,6 +393,7 @@ status = "draft — needs native review"
 "Detach variable" = "Détacher la variable"
 "Details" = "Détails"
 "Dev Mode" = "Mode Dev"
+"Dev Mode only inspects: switch to Design (Shift+D) to edit" = "Le mode Dev sert seulement à inspecter : passez en Design (Shift+D) pour modifier"
 "Dev resources" = "Ressources de développement"
 "Development" = "Développement"
 "Device" = "Appareil"
@@ -382,6 +410,7 @@ status = "draft — needs native review"
 "Distribute horizontal spacing" = "Répartir l’espacement horizontal"
 "Distribute vertical spacing" = "Répartir l’espacement vertical"
 "Divider" = "Séparateur"
+"Don't Save" = "Ne pas enregistrer"
 "Don't truncate" = "Ne pas tronquer"
 "Done" = "Terminé"
 "Done editing" = "Terminer la modification"
@@ -391,8 +420,12 @@ status = "draft — needs native review"
 "Drafts" = "Brouillons"
 "Drag the stroke to add a width point" = "Faites glisser le contour pour ajouter un point de largeur"
 "Draw" = "Dessin"
+"Draw a frame" = "Tracer un cadre"
 "Drawing tools" = "Outils de dessin"
+"Drop a .figcraft, .fig, .json, .svg or image file." = "Déposez un fichier .figcraft, .fig, .json, .svg ou une image."
 "Drop shadow" = "Ombre portée"
+"Drop to import" = "Déposer pour importer"
+"Drop to open" = "Déposer pour ouvrir"
 "Dual-licensed MIT OR Apache-2.0. Made by the ArtCraft team and community." = "Double licence MIT OR Apache-2.0. Réalisé par l’équipe et la communauté ArtCraft."
 "Duo" = "Duo"
 "Duplicate" = "Dupliquer"
@@ -409,9 +442,11 @@ status = "draft — needs native review"
 "Edit style" = "Modifier le style"
 "Edit variable" = "Modifier la variable"
 "Edit with the builder" = "Modifier avec l’assistant"
+"Edited {when}" = "Modifié {when}"
 "Effect settings" = "Réglages de l’effet"
 "Effect styles" = "Styles d’effet"
 "Effects" = "Effets"
+"Elbow" = "Coudé"
 "Ellipse" = "Ellipse"
 "Ellipses" = "Ellipses"
 "Else" = "Sinon"
@@ -439,6 +474,7 @@ status = "draft — needs native review"
 "Expand" = "Développer"
 "Export" = "Exporter"
 "Export all" = "Tout exporter"
+"Export frames and layers as PNG, JPG, SVG or PDF" = "Exporter les cadres et les calques en PNG, JPG, SVG ou PDF"
 "Export page as PNG" = "Exporter la page en PNG"
 "Export settings" = "Réglages d’exportation"
 "Export variables" = "Exporter les variables"
@@ -458,10 +494,13 @@ status = "draft — needs native review"
 "F" = "F"
 "Fade" = "Fondu"
 "False" = "Faux"
+"Feb" = "févr."
 "Fetching from the server…" = "Récupération depuis le serveur…"
 "FigCraft couldn't open its window: {error}" = "FigCraft n’a pas pu ouvrir sa fenêtre : {error}"
+"FigCraft doesn't support every feature of these files yet. The notes list what was left out or changed in the imported copy; the original file is unchanged." = "FigCraft ne prend pas encore en charge toutes les fonctionnalités de ces fichiers. Les notes indiquent ce qui a été omis ou modifié dans la copie importée ; le fichier d’origine reste inchangé."
 "File" = "Fichier"
 "File name" = "Nom du fichier"
+"File not found" = "Fichier introuvable"
 "File published" = "Fichier publié"
 "Files aren't end-to-end encrypted: the server's operator can read them." = "Les fichiers ne sont pas chiffrés de bout en bout : l’opérateur du serveur peut les lire."
 "Files nobody opens for {n} days are deleted." = { one = "Les fichiers que personne n’ouvre pendant {n} jour sont supprimés.", other = "Les fichiers que personne n’ouvre pendant {n} jours sont supprimés." }
@@ -508,6 +547,7 @@ status = "draft — needs native review"
 "Font size" = "Taille de police"
 "Font style" = "Style de police"
 "Forget on this computer" = "Oublier sur cet ordinateur"
+"Four screens of a trail app with components and a prototype flow" = "Quatre écrans d’une application de randonnée avec des composants et un flux de prototype"
 "Fractions" = "Fractions"
 "Frame" = "Cadre"
 "Frame selection" = "Encadrer la sélection"
@@ -521,6 +561,7 @@ status = "draft — needs native review"
 "Gap between columns" = "Espacement entre les colonnes"
 "Gap between items" = "Espacement entre les éléments"
 "Gap between rows" = "Espacement entre les lignes"
+"Getting started" = "Premiers pas"
 "Give the address of a server open to the public, or a server's address with its key (`figcraft-server key` prints it)." = "Indiquez l’adresse d’un serveur ouvert au public, ou l’adresse d’un serveur avec sa clé (`figcraft-server key` l’affiche)."
 "Glass" = "Verre"
 "Go to main component" = "Aller au composant principal"
@@ -529,6 +570,7 @@ status = "draft — needs native review"
 "Gradient" = "Dégradé"
 "Gray" = "Gris"
 "Green" = "Vert"
+"Greyscale components and two example screens to sketch a flow with" = "Composants en niveaux de gris et deux écrans d’exemple pour esquisser un flux"
 "Grid" = "Grille"
 "Grid ({size})" = "Grille ({size})"
 "Grid styles" = "Styles de grille"
@@ -541,6 +583,7 @@ status = "draft — needs native review"
 "Hanging list" = "Liste en retrait"
 "Hanging punctuation" = "Ponctuation en débord"
 "Hard light" = "Lumière dure"
+"Heart" = "Cœur"
 "Height" = "Hauteur"
 "Help" = "Aide"
 "Help and resources" = "Aide et ressources"
@@ -550,7 +593,10 @@ status = "draft — needs native review"
 "Hide contents" = "Masquer le contenu"
 "Hide from publishing" = "Exclure de la publication"
 "Hide section contents" = "Masquer le contenu de la section"
+"Hide these tips (Getting started in the Help menu shows them again)" = "Masquer ces astuces (Premiers pas dans le menu Aide les affiche de nouveau)"
+"Hide when publishing" = "Masquer à la publication"
 "Highlight layers on hover" = "Mettre en évidence les calques au survol"
+"Highlighter" = "Surligneur"
 "Highlights" = "Hautes lumières"
 "Hold Alt" = "Maintenir Alt"
 "Hold Alt+Z" = "Maintenir Alt+Z"
@@ -571,16 +617,21 @@ status = "draft — needs native review"
 "Hue" = "Teinte"
 "Hug" = "Ajuster"
 "Hug contents" = "Ajuster au contenu"
+"Icon components on a 24 px grid with keylines and a size preview" = "Composants d’icônes sur une grille de 24 px avec repères et aperçu de la taille"
+"Icon set starter" = "Base de jeu d’icônes"
 "If it keeps happening, please report it at {link} with this message." = "Si cela se reproduit, signalez-le sur {link} avec ce message."
 "If" = "Si"
 "If {condition}" = "Si {condition}"
 "Ignore auto layout (absolute position)" = "Ignorer la mise en page auto (position absolue)"
 "Image" = "Image"
+"Images" = "Images"
 "Import" = "Importer"
 "Import path" = "Chemin d’importation"
 "Import plugin from manifest" = "Importer un plugin depuis un manifeste"
 "Import plugin from manifest…" = "Importer un plugin depuis un manifeste…"
+"Import report" = "Rapport d’importation"
 "Import variables" = "Importer des variables"
+"Imported document" = "Document importé"
 "Imported {name}" = "{name} importé"
 "Imported {n} new variables, updated {updated}" = { one = "{n} nouvelle variable importée, {updated} mises à jour", other = "{n} nouvelles variables importées, {updated} mises à jour" }
 "Import…" = "Importer…"
@@ -608,14 +659,18 @@ status = "draft — needs native review"
 "Instance swap (no other component)" = "Permutation d’instance (aucun autre composant)"
 "Instances" = "Instances"
 "Instant" = "Instantané"
+"Intensity" = "Intensité"
 "Interaction" = "Interaction"
 "Interactions" = "Interactions"
 "Interface design and prototyping. A free, open-source, clean-room design tool written from scratch in Rust, part of the ArtCraft Crafting Apps." = "Design d’interfaces et prototypage. Un outil de design libre et gratuit, développé en salle blanche (clean-room) et écrit de zéro en Rust, membre des Crafting Apps d’ArtCraft."
+"Interface size" = "Taille de l’interface"
 "Intersect" = "Intersection"
 "Intersects" = "Intersections"
+"Invalid color" = "Couleur non valide"
 "Invite link" = "Lien d’invitation"
 "Invite link copied" = "Lien d’invitation copié"
 "It asks permission to:" = "Il demande l’autorisation de :"
+"Jan" = "janv."
 "Join" = "Rejoindre"
 "Join code copied" = "Code d’accès copié"
 "Join code or invite link" = "Code d’accès ou lien d’invitation"
@@ -626,6 +681,8 @@ status = "draft — needs native review"
 "Joined {file}" = "Connecté à {file}"
 "Joining…" = "Connexion…"
 "Join|stroke" = "Jointure"
+"Jul" = "juil."
+"Jun" = "juin"
 "Just now" = "À l’instant"
 "Justify" = "Justifier"
 "Keep appearance" = "Conserver l’apparence"
@@ -635,11 +692,14 @@ status = "draft — needs native review"
 "Key/Gamepad" = "Touche/manette"
 "Key/Gamepad {key}" = "Touche/manette {key}"
 "Keyboard shortcuts" = "Raccourcis clavier"
+"Kits" = "Kits"
+"Landing page" = "Page de destination"
 "Language" = "Langue"
 "Lasso" = "Lasso"
 "Last" = "Dernier"
 "Last change: {note}" = "Dernière modification : {note}"
 "Last commit" = "Dernier commit"
+"Last modified" = "Dernière modification"
 "Last on top" = "Dernier au-dessus"
 "Layer blur" = "Flou de calque"
 "Layer name" = "Nom du calque"
@@ -678,6 +738,7 @@ status = "draft — needs native review"
 "Link" = "Lien"
 "Link copied" = "Lien copié"
 "Link docs, code or tickets for developers." = "Liez de la documentation, du code ou des tickets pour les développeurs."
+"Link frames on the Prototype tab, then present the flow" = "Reliez les cadres dans l’onglet Prototype, puis présentez le flux"
 "Link this component to its code component: instances then show your real snippet with their values." = "Reliez ce composant à son composant de code : les instances affichent alors votre véritable extrait avec leurs valeurs."
 "List spacing" = "Espacement de liste"
 "List style" = "Style de liste"
@@ -695,12 +756,15 @@ status = "draft — needs native review"
 "Main" = "Principal"
 "Main component deleted" = "Composant principal supprimé"
 "Main menu" = "Menu principal"
+"Make a component" = "Créer un composant"
 "Make slot" = "Créer un emplacement"
+"Mar" = "mars"
 "Margin" = "Marge"
 "Mark all as read" = "Tout marquer comme lu"
 "Mark as resolved" = "Marquer comme résolu"
 "Mark as unread" = "Marquer comme non lu"
 "Mark as unresolved" = "Marquer comme non résolu"
+"Marker" = "Marqueur"
 "Mask" = "Masque"
 "Mass · Stiffness · Damping" = "Masse · Rigidité · Amortissement"
 "Match (empty: the whole name)" = "Correspondance (vide : le nom entier)"
@@ -708,6 +772,7 @@ status = "draft — needs native review"
 "Max W" = "L max."
 "Max lines" = "Lignes max."
 "Maximize" = "Agrandir"
+"May" = "mai"
 "Measure to the selection" = "Mesurer jusqu’à la sélection"
 "Merge into main" = "Fusionner dans le principal"
 "Merge regions" = "Fusionner les régions"
@@ -729,6 +794,7 @@ status = "draft — needs native review"
 "Mixed" = "Mixte"
 "Mixed fonts" = "Polices mixtes"
 "Mixed interactions: click + to replace them" = "Interactions mixtes : cliquez sur + pour les remplacer"
+"Mobile app" = "Application mobile"
 "Mode" = "Mode"
 "Model" = "Modèle"
 "Models" = "Modèles"
@@ -757,7 +823,10 @@ status = "draft — needs native review"
 "Named instance" = "Instance nommée"
 "Navigate to" = "Naviguer vers"
 "Nested instance" = "Instance imbriquée"
+"New board" = "Nouveau tableau blanc"
 "New design file" = "Nouveau fichier de design"
+"Newest first" = "Plus récent d’abord"
+"Next frame" = "Cadre suivant"
 "Next or previous control in the focused region" = "Contrôle suivant ou précédent dans la région active"
 "Next ready for dev" = "Prêt pour le dev suivant"
 "Next size option" = "Option de taille suivante"
@@ -767,12 +836,15 @@ status = "draft — needs native review"
 "No branches. A branch is a copy of the file to try changes in, then review and merge." = "Aucune branche. Une branche est une copie du fichier pour essayer des modifications, puis les relire et les fusionner."
 "No category" = "Sans catégorie"
 "No changes" = "Aucune modification"
+"No color styles" = "Aucun style de couleur"
 "No colour variables fit here." = "Aucune variable de couleur ne convient ici."
 "No colour variables yet. Create them in Local variables." = "Aucune variable de couleur pour l’instant. Créez-en dans Variables locales."
 "No comments yet" = "Aucun commentaire pour l’instant"
+"No compatibility warnings reported" = "Aucun avertissement de compatibilité signalé"
 "No components yet. Select layers and press {keys}." = "Aucun composant pour l’instant. Sélectionnez des calques et appuyez sur {keys}."
 "No conflicts." = "Aucun conflit."
 "No contributor data was built into this copy." = "Cette copie ne contient aucune donnée de contributeurs."
+"No device" = "Aucun appareil"
 "No fonts match" = "Aucune police ne correspond"
 "No join code here (the server is older than join codes, or this address can't be put in one): share the link instead." = "Pas de code d’accès ici (le serveur est antérieur aux codes d’accès, ou cette adresse ne tient pas dans un code) : partagez plutôt le lien."
 "No layer changes to show." = "Aucune modification de calque à afficher."
@@ -787,6 +859,7 @@ status = "draft — needs native review"
 "No model credits were built into this copy." = "Cette copie ne contient aucun crédit de modèle."
 "No number variables fit here." = "Aucune variable numérique ne convient ici."
 "No number variables yet. Create them in Local variables." = "Aucune variable numérique pour l’instant. Créez-en dans Variables locales."
+"No other pages" = "Aucune autre page"
 "No paints" = "Aucune peinture"
 "No plugins on {server}." = "Aucun plugin sur {server}."
 "No plugins yet. Import a development plugin from its figcraft-plugin.json." = "Aucun plugin pour l’instant. Importez un plugin en développement depuis son figcraft-plugin.json."
@@ -800,6 +873,7 @@ status = "draft — needs native review"
 "No string variables yet. Create them in Local variables." = "Aucune variable de chaîne pour l’instant. Créez-en dans Variables locales."
 "No styles yet." = "Aucun style pour l’instant."
 "No styles yet. Click + to create one from the selection." = "Aucun style pour l’instant. Cliquez sur + pour en créer un à partir de la sélection."
+"No templates match your search" = "Aucun modèle ne correspond à votre recherche"
 "No text styles yet. Click + to create one from the selected text." = "Aucun style de texte pour l’instant. Cliquez sur + pour en créer un à partir du texte sélectionné."
 "No variables fit here." = "Aucune variable ne convient ici."
 "No variables yet. Create them in Local variables." = "Aucune variable pour l’instant. Créez-en dans Variables locales."
@@ -815,10 +889,12 @@ status = "draft — needs native review"
 "Not read yet" = "Pas encore lu"
 "Not shared" = "Non partagé"
 "Note {n}" = "Note {n}"
+"Nothing changed since this version." = "Rien n’a changé depuis cette version."
 "Nothing changed since this was marked ready for dev." = "Rien n’a changé depuis que ceci a été marqué prêt pour le dev."
 "Nothing here yet. Set a frame's status to list it." = "Rien pour l’instant. Attribuez un statut à un cadre pour le lister ici."
 "Nothing online yet. Use Share on a file to put it online and it is listed here." = "Rien en ligne pour l’instant. Utilisez Partager sur un fichier pour le mettre en ligne et il apparaîtra ici."
 "Nothing to export" = "Rien à exporter"
+"Nov" = "nov."
 "Now" = "Maintenant"
 "Nudge (Shift: big nudge)" = "Décaler (Maj : grand décalage)"
 "Nudge amount" = "Pas de décalage"
@@ -827,13 +903,16 @@ status = "draft — needs native review"
 "Number ↓" = "Numéro ↓"
 "Numbered list" = "Liste numérotée"
 "Object" = "Objet"
+"Oct" = "oct."
 "Off" = "Non"
 "Offered first when filling the slot (any content is allowed)" = "Proposés en premier pour remplir l’emplacement (tout contenu est autorisé)"
 "Offered first when swapping the instance (any component is allowed)" = "Proposés en premier pour permuter l’instance (tout composant est autorisé)"
 "Offset" = "Décalage"
+"Oldest first" = "Plus ancien d’abord"
 "On click" = "Au clic"
 "On drag" = "Au glissement"
 "On this page" = "Sur cette page"
+"One announcement in five common sizes: square, portrait, story, link and banner" = "Une annonce en cinq formats courants : carré, portrait, story, lien et bannière"
 "Online" = "En ligne"
 "Online files" = "Fichiers en ligne"
 "Online sharing is off: files are shared on the local network only." = "Le partage en ligne est désactivé : les fichiers ne sont partagés que sur le réseau local."
@@ -848,6 +927,7 @@ status = "draft — needs native review"
 "Open branch" = "Ouvrir la branche"
 "Open file" = "Ouvrir un fichier"
 "Open files" = "Fichiers ouverts"
+"Open presentations" = "Présentations ouvertes"
 "Open in focus view" = "Ouvrir en vue ciblée"
 "Open in new window" = "Ouvrir dans une nouvelle fenêtre"
 "Open invite links in FigCraft" = "Ouvrir les liens d’invitation dans FigCraft"
@@ -856,10 +936,15 @@ status = "draft — needs native review"
 "Open overlay" = "Ouvrir une superposition"
 "Open prototype preview" = "Ouvrir l’aperçu du prototype"
 "Open variables ({count})" = "Ouvrir les variables ({count})"
+"Opened as a new document" = "Ouvert comme nouveau document"
 "Opened “{name}” in a new tab" = "« {name} » ouvert dans un nouvel onglet"
+"Opening the file…" = "Ouverture du fichier…"
+"Opening {n} files as new files" = { one = "Ouverture comme nouveau fichier", other = "Ouverture de {n} fichiers comme nouveaux fichiers" }
 "Open|comments" = "Ouverts"
 "Options" = "Options"
 "Orange" = "Orange"
+"Order" = "Ordre"
+"Other" = "Autre"
 "Other apps may not open every .fig file exported here." = "D’autres applications risquent de ne pas ouvrir tous les fichiers .fig exportés ici."
 "Others lose access and keep their copy; the file stays on the server for you" = "Les autres perdent l’accès et conservent leur copie ; le fichier reste sur le serveur pour vous"
 "Others type this under Share ▸ Join with a code" = "Les autres le saisissent dans Partager ▸ Rejoindre avec un code"
@@ -878,7 +963,12 @@ status = "draft — needs native review"
 "PDF print settings" = "Réglages d’impression PDF"
 "Padding" = "Marge intérieure"
 "Page" = "Page"
+"Page deleted" = "Page supprimée"
 "Pages" = "Pages"
+"Pages added to the document" = "Pages ajoutées au document"
+"Pick the Frame tool, then drag on the canvas or choose a device size" = "Choisissez l’outil Cadre, puis faites glisser sur le canevas ou choisissez une taille d’appareil"
+"Pink" = "Rose"
+"Placed on the current page" = "Placé sur la page actuelle"
 "Pages: {pages}" = "Pages : {pages}"
 "Paint bucket" = "Pot de peinture"
 "Pan the canvas" = "Faire défiler le canevas"
@@ -893,6 +983,7 @@ status = "draft — needs native review"
 "Paste a team library link (a view link)" = "Collez le lien d’une bibliothèque d’équipe (un lien de consultation)"
 "Paste here" = "Coller ici"
 "Paste to replace" = "Coller pour remplacer"
+"Pasted design layers; {n} kinds of content were left out" = { one = "Calques de design collés ; {n} type de contenu a été omis", other = "Calques de design collés ; {n} types de contenu ont été omis" }
 "Pattern" = "Motif"
 "Pattern alignment" = "Alignement du motif"
 "Pattern scale" = "Échelle du motif"
@@ -914,10 +1005,14 @@ status = "draft — needs native review"
 "Place a shape or frame (its tool chosen)" = "Placer une forme ou un cadre (outil choisi)"
 "Place automatically" = "Placer automatiquement"
 "Place image" = "Placer une image"
+"Playground" = "Bac à sable"
+"Plugin" = "Plugin"
 "Plugins" = "Plugins"
+"Plugins & widgets" = "Plugins et widgets"
 "Plugins run in FigCraft's sandbox, without files, network or clock. Install only plugins you trust." = "Les plugins s’exécutent dans le bac à sable de FigCraft, sans fichiers, réseau ni horloge. N’installez que des plugins de confiance."
 "Plus darker" = "Plus foncé"
 "Plus lighter" = "Plus clair"
+"Plus one" = "Plus un"
 "Point" = "Point"
 "Points" = "Points"
 "Polygon" = "Polygone"
@@ -931,6 +1026,7 @@ status = "draft — needs native review"
 "Present or preview" = "Présenter ou prévisualiser"
 "Present this flow" = "Présenter ce flux"
 "Presentation" = "Présentation"
+"Presentation slides" = "Diapositives de présentation"
 "Presenting: comments" = "Présentation : commentaires"
 "Presenting: cycle the size options" = "Présentation : parcourir les options de taille"
 "Presenting: full screen" = "Présentation : plein écran"
@@ -943,6 +1039,7 @@ status = "draft — needs native review"
 "Preview" = "Aperçu"
 "Preview this flow" = "Prévisualiser ce flux"
 "Preview this frame" = "Prévisualiser ce cadre"
+"Previous frame" = "Cadre précédent"
 "Previous ready for dev" = "Prêt pour le dev précédent"
 "Progressive" = "Progressif"
 "Properties" = "Propriétés"
@@ -963,6 +1060,7 @@ status = "draft — needs native review"
 "Push" = "Pousser"
 "Push changes to main component" = "Transmettre les modifications au composant principal"
 "Put text on path" = "Placer le texte sur un tracé"
+"Question" = "Question"
 "R" = "R"
 "Radial" = "Radial"
 "Radius" = "Rayon"
@@ -980,12 +1078,14 @@ status = "draft — needs native review"
 "Reduce motion" = "Réduire les animations"
 "Refraction" = "Réfraction"
 "Regular expression" = "Expression régulière"
+"Relative to your system's display scaling (100% is the system's own size). Document zoom is separate." = "Relative à la mise à l’échelle d’affichage de votre système (100 % est la taille du système). Le zoom du document est distinct."
 "Remove" = "Retirer"
 "Remove all" = "Tout retirer"
 "Remove annotation" = "Retirer l’annotation"
 "Remove auto layout" = "Retirer la mise en page auto"
 "Remove dev resource" = "Retirer la ressource de développement"
 "Remove export setting" = "Retirer le réglage d’exportation"
+"Remove from recents" = "Retirer des récents"
 "Remove from server" = "Retirer du serveur"
 "Remove from server…" = "Retirer du serveur…"
 "Remove guide" = "Retirer le repère"
@@ -1007,6 +1107,7 @@ status = "draft — needs native review"
 "Removed" = "Supprimé"
 "Removed from the server" = "Retiré du serveur"
 "Removed since it was marked" = "Supprimé depuis le marquage"
+"Removed since this version" = "Supprimé depuis cette version"
 "Rename" = "Renommer"
 "Rename duplicated layers" = "Renommer les calques dupliqués"
 "Rename folder" = "Renommer le dossier"
@@ -1036,6 +1137,7 @@ status = "draft — needs native review"
 "Resize by the nudge amount" = "Redimensionner du pas de décalage"
 "Resize frames to the device's screen (or the window without a device): their constraints and auto layout respond" = "Redimensionne les cadres à l’écran de l’appareil (ou à la fenêtre sans appareil) : leurs contraintes et leur mise en page auto s’adaptent"
 "Resize to fit" = "Redimensionner au contenu"
+"Resizing" = "Redimensionnement"
 "Resolve" = "Résoudre"
 "Resolve change" = "Résoudre la modification"
 "Resolved" = "Résolu"
@@ -1061,6 +1163,7 @@ status = "draft — needs native review"
 "Rotation jitter" = "Variation de rotation"
 "Round" = "Arrondi"
 "Rounded" = "Arrondi"
+"Rounded rectangle" = "Rectangle arrondi"
 "Row" = "Ligne"
 "Row gap" = "Espacement des lignes"
 "Row sizes" = "Tailles des lignes"
@@ -1097,25 +1200,31 @@ status = "draft — needs native review"
 "Search layers" = "Rechercher des calques"
 "Search plugins" = "Rechercher des plugins"
 "Search shortcuts" = "Rechercher des raccourcis"
+"Search templates" = "Rechercher des modèles"
 "Section" = "Section"
 "Section color" = "Couleur de la section"
 "Sections" = "Sections"
+"See all templates" = "Voir tous les modèles"
 "Select a frame and add a starting point to present it as a flow." = "Sélectionnez un cadre et ajoutez un point de départ pour le présenter comme un flux."
 "Select a frame to preview it" = "Sélectionnez un cadre pour le prévisualiser"
 "Select a layer to see its properties and code" = "Sélectionnez un calque pour voir ses propriétés et son code"
 "Select all" = "Tout sélectionner"
 "Select all with same" = "Sélectionner tout ce qui a le même"
 "Select layer" = "Sélectionner le calque"
+"Select layers and they space themselves as their content changes" = "Sélectionnez des calques et leur espacement s’ajuste quand leur contenu change"
 "Select layers to apply the style to" = "Sélectionnez les calques auxquels appliquer le style"
+"Select layers with this color" = "Sélectionner les calques de cette couleur"
 "Select overlapping shapes" = "Sélectionnez des formes qui se chevauchent"
 "Select points to edit their position, radius and mirroring" = "Sélectionnez des points pour modifier leur position, leur rayon et leur symétrie"
 "Select slot" = "Sélectionner l’emplacement"
 "Selection" = "Sélection"
 "Selection box, {w} by {h} at {x}, {y}: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "Zone de sélection, {w} sur {h} à {x}, {y} : les flèches la déplacent, Maj+flèches ou {cmd}+flèches la redimensionnent, Entrée sélectionne, Échap annule"
 "Selection box: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "Zone de sélection : les flèches la déplacent, Maj+flèches ou {cmd}+flèches la redimensionnent, Entrée sélectionne, Échap annule"
+"Selection colors" = "Couleurs de la sélection"
 "Send backward" = "Reculer"
 "Send report" = "Envoyer le signalement"
 "Send to back" = "Mettre à l’arrière-plan"
+"Sep" = "sept."
 "Server address" = "Adresse du serveur"
 "Server address (ws://host:47900/)" = "Adresse du serveur (ws://host:47900/)"
 "Server for online sharing" = "Serveur pour le partage en ligne"
@@ -1128,8 +1237,10 @@ status = "draft — needs native review"
 "Shape" = "Forme"
 "Shape builder" = "Générateur de formes"
 "Shape tools" = "Outils de forme"
+"Shapes" = "Formes"
 "Share" = "Partager"
 "Share this file" = "Partager ce fichier"
+"Share with a code" = "Partager avec un code"
 "Share: live session, export" = "Partager : session en direct, exportation"
 "Shared" = "Partagé"
 "Shared: copy its code from the file's menu" = "Partagé : copiez son code depuis le menu du fichier"
@@ -1139,6 +1250,7 @@ status = "draft — needs native review"
 "Sharing online · {people}" = "Partage en ligne · {people}"
 "Sharing stopped: the file stays on the server, open only to you" = "Partage arrêté : le fichier reste sur le serveur, accessible à vous seul"
 "Show" = "Afficher"
+"Show all templates" = "Afficher tous les modèles"
 "Show as grid" = "Afficher en grille"
 "Show as list" = "Afficher en liste"
 "Show autosaves" = "Afficher les sauvegardes auto"
@@ -1147,6 +1259,9 @@ status = "draft — needs native review"
 "Show device frame" = "Afficher le cadre de l’appareil"
 "Show dimensions on objects" = "Afficher les dimensions sur les objets"
 "Show hotspot hints" = "Afficher les zones interactives"
+"Show in Explorer" = "Afficher dans l’Explorateur"
+"Show in Finder" = "Afficher dans le Finder"
+"Show in folder" = "Afficher dans le dossier"
 "Show only this on the canvas" = "Afficher uniquement ceci sur le canevas"
 "Show open" = "Afficher les ouverts"
 "Show section contents" = "Afficher le contenu de la section"
@@ -1171,13 +1286,17 @@ status = "draft — needs native review"
 "Small caps" = "Petites capitales"
 "Smart animate" = "Animation intelligente"
 "Snap to pixel grid" = "Aimanter à la grille de pixels"
+"Social and slides" = "Réseaux sociaux et diapositives"
 "Social media" = "Réseaux sociaux"
+"Social post sizes" = "Formats de publications sociales"
 "Soft light" = "Lumière douce"
 "Solid" = "Continu"
 "Some variants have the same property values: give each one a unique combination" = "Certaines variantes ont les mêmes valeurs de propriété : donnez à chacune une combinaison unique"
 "Sort" = "Trier"
+"Sort by" = "Trier par"
 "Sort by date" = "Trier par date"
 "Sort by page" = "Trier par page"
+"Sort by {column}" = "Trier par {column}"
 "Space around" = "Espace autour"
 "Space between" = "Espace entre"
 "Space drag" = "Espace et glisser"
@@ -1185,10 +1304,13 @@ status = "draft — needs native review"
 "Space+drag" = "Espace+glisser"
 "Spacing" = "Espacement"
 "Spam, stolen work, abuse…" = "Spam, travail volé, abus…"
+"Speech bubble" = "Bulle"
 "Splay" = "Évasement"
 "Spotlight me" = "Me mettre sous les projecteurs"
 "Spread" = "Étendue"
 "Square" = "Carré"
+"Stamp" = "Tampon"
+"Stamps" = "Tampons"
 "Standard" = "Standard"
 "Standard ligatures" = "Ligatures standard"
 "Star" = "Étoile"
@@ -1196,18 +1318,25 @@ status = "draft — needs native review"
 "Start" = "Début"
 "Start ascending from / stop descending at" = "Compter vers le haut depuis / vers le bas jusqu’à"
 "Start from a blank canvas" = "Commencer avec un canevas vide"
+"Start from a template" = "Commencer avec un modèle"
 "Start on path" = "Début sur le tracé"
+"Start on the Home screen" = "Démarrer sur l’Accueil"
 "Start point" = "Point de départ"
 "Start sharing" = "Commencer le partage"
+"Start sharing with the Share button, then pass on the code it gives" = "Commencez à partager avec le bouton Partager, puis communiquez le code qu’il donne"
 "Starting to share…" = "Démarrage du partage…"
 "Status" = "Statut"
 "Sticky" = "Collant"
+"Sticky note" = "Note autocollante"
+"Sticky note colors" = "Couleurs des notes autocollantes"
+"Sticky notes, shapes and connectors" = "Notes autocollantes, formes et connecteurs"
 "Stop" = "Arrêter"
 "Stop following {name}" = "Ne plus suivre {name}"
 "Stop session" = "Arrêter la session"
 "Stop sharing" = "Arrêter le partage"
 "Stop spotlighting" = "Quitter les projecteurs"
 "Stop {n}  {hex}" = "Arrêt {n}  {hex}"
+"Straight" = "Droit"
 "Stretch" = "Étirer"
 "Strikethrough" = "Barré"
 "String" = "Chaîne"
@@ -1247,15 +1376,20 @@ status = "draft — needs native review"
 "Tell the server's operator what is wrong with it" = "Indiquez à l’opérateur du serveur ce qui ne va pas"
 "Temperature" = "Température"
 "Template" = "Modèle"
+"Templates" = "Modèles"
 "Terms" = "Conditions"
 "Text" = "Texte"
 "Text align" = "Alignement du texte"
 "Text content" = "Contenu du texte"
+"Text size" = "Taille du texte"
 "Text style" = "Style de texte"
 "Text styles" = "Styles de texte"
 "Texts" = "Textes"
 "Texture" = "Texture"
 "The canvas previews colors in sRGB; exported PNG, JPG and WebP files are tagged Display P3." = "Le canevas affiche les couleurs en sRGB ; les fichiers PNG, JPG et WebP exportés sont balisés Display P3."
+"The destination document is unavailable. Nothing was imported." = "Le document de destination est indisponible. Rien n’a été importé."
+"The destination document was closed. Nothing was imported." = "Le document de destination a été fermé. Rien n’a été importé."
+"The destination page was removed. Nothing was imported." = "La page de destination a été supprimée. Rien n’a été importé."
 "The file is deleted from the server: nobody can open or join it from there again, and this can't be undone. Copies that are open stay with whoever has them." = "Le fichier est supprimé du serveur : plus personne ne pourra l’ouvrir ni le rejoindre depuis celui-ci, et c’est irréversible. Les copies ouvertes restent à ceux qui les ont."
 "The file now holds another library" = "Le fichier contient désormais une autre bibliothèque"
 "The file now holds another library (\"{name}\")" = "Le fichier contient désormais une autre bibliothèque (« {name} »)"
@@ -1265,6 +1399,7 @@ status = "draft — needs native review"
 "The selection uses several text styles: click to apply one" = "La sélection utilise plusieurs styles de texte : cliquez pour en appliquer un"
 "The server deletes this file if nobody opens it before {date}." = "Le serveur supprime ce fichier si personne ne l’ouvre avant le {date}."
 "The whole file" = "Le fichier entier"
+"The window is too small for {size}%, so the interface is drawn at {drawn}%. Make the window larger to use {size}%." = "La fenêtre est trop petite pour {size} %, l’interface est donc affichée à {drawn} %. Agrandissez la fenêtre pour utiliser {size} %."
 "Theme" = "Thème"
 "There's no destination for that action" = "Cette action n’a pas de destination"
 "Thickness" = "Épaisseur"
@@ -1281,6 +1416,9 @@ status = "draft — needs native review"
 "This server is open to the public: no key needed." = "Ce serveur est ouvert au public : aucune clé nécessaire."
 "This server needs its key: add ?key=… to the address (`figcraft-server key` prints it on the server's machine)." = "Ce serveur exige sa clé : ajoutez ?key=… à l’adresse (`figcraft-server key` l’affiche sur la machine du serveur)."
 "This server takes files only with its key: see Advanced." = "Ce serveur n’accepte les fichiers qu’avec sa clé : voir Avancé."
+"Thumbs up" = "Pouce levé"
+"This version can't be read." = "Cette version est illisible."
+"This version doesn't have it: all of it is new." = "Cette version ne le contient pas : tout est nouveau."
 "Tidy up" = "Ranger"
 "Tile" = "Mosaïque"
 "Tile type" = "Type de mosaïque"
@@ -1297,6 +1435,7 @@ status = "draft — needs native review"
 "Top left radius" = "Rayon supérieur gauche"
 "Top right radius" = "Rayon supérieur droit"
 "Transform" = "Transformer"
+"Triangle" = "Triangle"
 "Triangle arrow" = "Flèche triangulaire"
 "Trigger" = "Déclencheur"
 "True" = "Vrai"
@@ -1304,6 +1443,8 @@ status = "draft — needs native review"
 "Truncate with an ellipsis" = "Tronquer avec des points de suspension"
 "Try again" = "Réessayer"
 "Try another search or filter." = "Essayez une autre recherche ou un autre filtre."
+"Try another word, or look at every kind." = "Essayez un autre mot, ou regardez chaque type."
+"Turn a layer into a component, reuse it, and change every copy at once" = "Transformez un calque en composant, réutilisez-le et modifiez toutes les copies d’un coup"
 "Two digits" = "Deux chiffres"
 "Type" = "Type"
 "Type settings" = "Réglages typographiques"
@@ -1319,7 +1460,7 @@ status = "draft — needs native review"
 "Unread" = "Non lus"
 "Unresolve" = "Rouvrir"
 "Unsaved changes" = "Modifications non enregistrées"
-"Unsaved changes in {names}. Close the window and lose them?" = "Modifications non enregistrées dans {names}. Fermer la fenêtre et les perdre ?"
+"Unsaved changes in {names}. Save them before closing?" = "Modifications non enregistrées dans {names}. Les enregistrer avant de fermer ?"
 "Unsaved changes: save first ({save}), or close the tab with {alt}-click to discard" = "Modifications non enregistrées : enregistrez d’abord ({save}) ou fermez l’onglet avec {alt}+clic pour les abandonner"
 "Unsaved changes: save first, or close again with {key} to discard" = "Modifications non enregistrées : enregistrez d’abord ou fermez à nouveau avec {key} pour les abandonner"
 "Up" = "Haut"
@@ -1338,9 +1479,12 @@ status = "draft — needs native review"
 "Use as mask" = "Utiliser comme masque"
 "Use auto layout" = "Utiliser la mise en page auto"
 "Use number keys for opacity" = "Utiliser les touches numériques pour l’opacité"
+"Use the .figcraft or .fig extension." = "Utilisez l’extension .figcraft ou .fig."
 "Use the layer's fill" = "Utiliser le remplissage du calque"
+"Use your browser's zoom to change the interface size." = "Utilisez le zoom de votre navigateur pour modifier la taille de l’interface."
 "Used in {files} · {instances}" = "Utilisé dans {files} · {instances}"
 "Username" = "Nom d’utilisateur"
+"Uses variables: each layer shows them in its own mode" = "Utilise des variables : chaque calque les affiche dans son propre mode"
 "Value" = "Valeur"
 "Variable" = "Variable"
 "Variable collections" = "Collections de variables"
@@ -1379,21 +1523,27 @@ status = "draft — needs native review"
 "Web" = "Web"
 "WebSocket URL" = "URL WebSocket"
 "WebSocket URL copied" = "URL WebSocket copiée"
+"Websites" = "Sites web"
 "Wedge" = "Coin"
 "Weight" = "Graisse"
+"What changed since a saved version" = "Ce qui a changé depuis une version enregistrée"
 "What changed since it was marked ready for dev" = "Ce qui a changé depuis le marquage prêt pour le dev"
 "What is wrong with this file? The server's operator gets your report." = "Qu’est-ce qui ne va pas avec ce fichier ? L’opérateur du serveur reçoit votre signalement."
 "What it's for" = "À quoi il sert"
 "What this changed from isn't known: it changed before FigCraft kept a copy of ready-for-dev frames. Resolve the change (or mark it ready again) to compare from now on." = "L’état d’origine de cette modification est inconnu : elle date d’avant que FigCraft ne conserve une copie des cadres prêts pour le dev. Résolvez la modification (ou marquez-la à nouveau comme prête) pour comparer à partir de maintenant."
+"When marked ready" = "Au marquage prêt"
+"What you try here changes this preview and the code below, not the file" = "Ce que vous essayez ici change cet aperçu et le code ci-dessous, pas le fichier"
 "While hovering" = "Pendant le survol"
 "While pressing" = "Pendant l’appui"
 "White" = "Blanc"
 "Who runs it, its terms and how long it keeps files" = "Qui le gère, ses conditions et combien de temps il conserve les fichiers"
 "Why it changed" = "Pourquoi cela a changé"
+"Widget" = "Widget"
 "Widgets" = "Widgets"
 "Width" = "Largeur"
 "Width point" = "Point de largeur"
 "Width profile" = "Profil de largeur"
+"Wireframe kit" = "Kit de wireframes"
 "With the layers' export settings" = "Avec les réglages d’exportation des calques"
 "Wrap" = "Renvoi à la ligne"
 "Wrap in new section" = "Envelopper dans une nouvelle section"
@@ -1408,6 +1558,7 @@ status = "draft — needs native review"
 "Your name in comments" = "Votre nom dans les commentaires"
 "Your system asks for reduced motion: animations stay off." = "Votre système demande de réduire les animations : elles restent désactivées."
 "Z" = "Z"
+"Z to A" = "Z à A"
 "Zoom" = "Zoom"
 "Zoom around the pointer" = "Zoomer autour du pointeur"
 "Zoom device to fill window" = "Zoomer l’appareil pour remplir la fenêtre"
@@ -1426,28 +1577,124 @@ status = "draft — needs native review"
 "call any command its access allows" = "appeler toute commande que son accès autorise"
 "call only: {commands}" = "appeler seulement : {commands}"
 "can edit the document" = "peut modifier le document"
+"conditional prototype actions nested too deeply were skipped" = "les actions de prototype conditionnelles trop profondément imbriquées ont été ignorées"
+"conditional prototype actions with conditions that can't be evaluated were skipped" = "les actions de prototype conditionnelles dont les conditions ne peuvent pas être évaluées ont été ignorées"
+"connector label background was skipped: style data is missing" = "l’arrière-plan du libellé du connecteur a été ignoré : les données de style sont manquantes"
+"connector label was skipped: background bounds are invalid" = "le libellé du connecteur a été ignoré : les limites de l’arrière-plan ne sont pas valides"
+"connector label was skipped: background transform is invalid" = "le libellé du connecteur a été ignoré : la transformation de l’arrière-plan n’est pas valide"
+"connector label was skipped: composed text transform is invalid" = "le libellé du connecteur a été ignoré : la transformation composée du texte n’est pas valide"
+"connector label was skipped: derived background bounds are missing" = "le libellé du connecteur a été ignoré : les limites dérivées de l’arrière-plan sont manquantes"
+"connector label was skipped: derived text bounds are missing" = "le libellé du connecteur a été ignoré : les limites dérivées du texte sont manquantes"
+"connector label was skipped: text bounds are invalid" = "le libellé du connecteur a été ignoré : les limites du texte ne sont pas valides"
+"connector label was skipped: text style data is missing" = "le libellé du connecteur a été ignoré : les données de style du texte sont manquantes"
+"connector label was skipped: text transform is invalid" = "le libellé du connecteur a été ignoré : la transformation du texte n’est pas valide"
+"connector labels were skipped" = "les libellés des connecteurs ont été ignorés"
+"connector layers import as static frame/vector snapshots with labels when present; live endpoint bindings are not retained" = "les calques de connecteur sont importés comme des instantanés statiques de cadre ou de vecteur, avec leurs libellés s’il y en a ; les liaisons dynamiques des extrémités ne sont pas conservées"
+"connector snapshot vector data is missing; connector was left empty" = "les données vectorielles de l’instantané du connecteur sont manquantes ; le connecteur reste vide"
+"connectors whose ends can't be placed are empty" = "les connecteurs dont les extrémités ne peuvent pas être placées sont vides"
 "crop marks" = "traits de coupe"
+"damaged vector geometry was skipped" = "la géométrie vectorielle endommagée a été ignorée"
+"damaged vector networks import as outlines" = "les réseaux vectoriels endommagés sont importés comme tracés"
 "development: {path}" = "développement : {path}"
+"document children other than pages were skipped" = "les enfants du document autres que des pages ont été ignorés"
+"duplicate grid track sizing entries use equal tracks" = "les entrées de dimensionnement de piste de grille en double utilisent des pistes égales"
 "e.g. count + 1" = "p. ex. count + 1"
 "e.g. count >= 3 and not done" = "p. ex. count >= 3 and not done"
+"elbowed and curved connectors without a saved path import as straight lines" = "les connecteurs coudés et courbes sans tracé enregistré sont importés comme des lignes droites"
+"entries without a node type were skipped" = "les entrées sans type de nœud ont été ignorées"
 "figcraft:// links from a browser, chat or email open this app and join the session." = "Les liens figcraft:// d’un navigateur, d’une messagerie ou d’un e-mail ouvrent cette application et rejoignent la session."
+"filled areas of a vector with their own fill use the layer's fill" = "les zones remplies d’un vecteur avec leur propre remplissage utilisent le remplissage du calque"
 "from {server}" = "depuis {server}"
+"gamepad triggers without exactly one known controller button were skipped" = "les déclencheurs de manette sans exactement un bouton de manette connu ont été ignorés"
+"grid track list exceeds 1000 entries; the tracks use the default equal sizing" = "la liste des pistes de grille dépasse 1 000 entrées ; les pistes utilisent le dimensionnement égal par défaut"
+"grid track sizing is unsupported or malformed; affected tracks use equal sizing" = "le dimensionnement des pistes de grille n’est pas pris en charge ou est mal formé ; les pistes concernées ont un dimensionnement égal"
+"grid track sizing list exceeds 1000 entries; the tracks use the default equal sizing" = "la liste de dimensionnement des pistes de grille dépasse 1 000 entrées ; les pistes utilisent le dimensionnement égal par défaut"
 "hidden" = "masqué"
 "iOS" = "iOS"
+"image filters are ambiguous because both filter containers are present; filter conversion was skipped" = "les filtres d’image sont ambigus, car les deux conteneurs de filtres sont présents ; la conversion des filtres a été ignorée"
+"image filters use FigCraft's approximate renderer" = "les filtres d’image utilisent le rendu approximatif de FigCraft"
+"instance swap properties whose default component isn't in the file were skipped" = "les propriétés de permutation d’instance dont le composant par défaut n’est pas dans le fichier ont été ignorées"
+"instances inside their own main component were imported as frames" = "les instances placées dans leur propre composant principal ont été importées comme cadres"
+"instances of components that aren't in the file show no layers" = "les instances de composants absents du fichier n’affichent aucun calque"
+"instances of components that aren't in the file were imported as frames" = "les instances de composants absents du fichier ont été importées comme cadres"
+"instances that would nest a component inside itself were imported as frames" = "les instances qui imbriqueraient un composant dans lui-même ont été importées comme cadres"
+"instances without a main component were imported as empty frames" = "les instances sans composant principal ont été importées comme cadres vides"
+"invalid internal .fig text path data was ignored" = "les données internes non valides de texte sur tracé du .fig ont été ignorées"
+"invalid or oversized vector networks import as outlines" = "les réseaux vectoriels non valides ou trop grands sont importés comme tracés"
+"invalid or oversized vector path data was skipped" = "les données de tracé vectoriel non valides ou trop grandes ont été ignorées"
+"just now" = "à l’instant"
+"key triggers without a supported key were skipped" = "les déclencheurs de touche sans touche prise en charge ont été ignorés"
+"key up triggers import as key presses" = "les déclencheurs au relâchement d’une touche sont importés comme des appuis sur la touche"
+"layers without a position were placed at their parent's origin" = "les calques sans position ont été placés à l’origine de leur parent"
+"layers without a type were skipped" = "les calques sans type ont été ignorés"
+"legacy image filter container is unsupported; filter conversion was skipped" = "l’ancien conteneur de filtres d’image n’est pas pris en charge ; la conversion des filtres a été ignorée"
 "locked" = "verrouillé"
+"malformed image filters container was skipped" = "le conteneur de filtres d’image mal formé a été ignoré"
+"malformed image paintFilter container was skipped" = "le conteneur paintFilter d’image mal formé a été ignoré"
+"malformed slot content assignment was skipped" = "une affectation de contenu d’emplacement mal formée a été ignorée"
 "no bleed" = "sans fond perdu"
 "nobody else here yet" = "personne d’autre pour l’instant"
+"non-default slot settings are not represented and were skipped" = "les réglages d’emplacement autres que ceux par défaut ne sont pas représentés et ont été ignorés"
 "now" = "maintenant"
 "or" = "ou"
+"point stroke joins were preserved; dashed or variable-width strokes render with the layer join" = "les jointures des points ont été conservées ; les contours en pointillés ou à largeur variable sont dessinés avec la jointure du calque"
+"preferred slot component keys cannot be resolved to file nodes and were skipped" = "les clés de composants préférés des emplacements ne correspondent à aucun calque du fichier et ont été ignorées"
+"prototype actions of unknown types were skipped" = "les actions de prototype de types inconnus ont été ignorées"
+"prototype actions without a destination in the file were skipped" = "les actions de prototype sans destination dans le fichier ont été ignorées"
+"prototype expressions on variables that aren't in the variables JSON were skipped" = "les expressions de prototype portant sur des variables absentes du JSON des variables ont été ignorées"
+"prototype expressions with unsupported functions were skipped" = "les expressions de prototype utilisant des fonctions non prises en charge ont été ignorées"
+"prototype interactions without supported actions were skipped" = "les interactions de prototype sans action prise en charge ont été ignorées"
+"prototype navigations of unknown types were skipped" = "les navigations de prototype de types inconnus ont été ignorées"
+"prototype transitions of unknown types play instantly" = "les transitions de prototype de types inconnus sont instantanées"
+"prototype triggers of unknown types were skipped" = "les déclencheurs de prototype de types inconnus ont été ignorés"
 "put a widget on the canvas" = "placer un widget sur le canevas"
 "read and edit the document" = "lire et modifier le document"
 "read the document" = "lire le document"
 "reads the document" = "lit le document"
+"set-variable actions on variables that aren't in the variables JSON were skipped" = "les actions de définition de variable portant sur des variables absentes du JSON des variables ont été ignorées"
+"set-variable actions with values that can't be evaluated were skipped" = "les actions de définition de variable dont les valeurs ne peuvent pas être évaluées ont été ignorées"
+"set-variable actions with values that don't fit the variable were skipped" = "les actions de définition de variable dont les valeurs ne correspondent pas à la variable ont été ignorées"
+"set-variable actions without a value were skipped" = "les actions de définition de variable sans valeur ont été ignorées"
+"set-variable-mode actions on collections or modes that aren't in the variables JSON were skipped" = "les actions de définition du mode de variable portant sur des collections ou des modes absents du JSON des variables ont été ignorées"
+"slot content assignment target is missing or is not slot content" = "la cible de l’affectation de contenu d’emplacement est absente ou n’est pas un contenu d’emplacement"
+"slot content assignment uses the empty GUID sentinel and was skipped" = "l’affectation de contenu d’emplacement utilise le GUID vide comme sentinelle et a été ignorée"
+"some vector points refer to point settings missing from the file; they use the layer's joins and plain corners" = "certains points vectoriels renvoient à des réglages de point absents du fichier ; ils utilisent les jointures du calque et des angles simples"
+"some vector segments refer to style settings missing from the file; they use the layer's stroke" = "certains segments vectoriels renvoient à des réglages de style absents du fichier ; ils utilisent le contour du calque"
+"stale or invalid grid track sizing entries were ignored" = "les entrées de dimensionnement de piste de grille obsolètes ou non valides ont été ignorées"
+"stars and polygons without point counts or geometry use the default point count" = "les étoiles et polygones sans nombre de pointes ni géométrie utilisent le nombre de pointes par défaut"
+"style settings of some vector segments aren't supported; those segments use the layer's stroke" = "les réglages de style de certains segments vectoriels ne sont pas pris en charge ; ces segments utilisent le contour du calque"
+"text path underline or strikethrough decoration is not rendered" = "le soulignement ou le barré du texte sur tracé n’est pas affiché"
+"text style overrides refer to missing table entries" = "les remplacements de style de texte renvoient à des entrées de table manquantes"
+"the file has no pages" = "le fichier n’a aucune page"
 "the plugin" = "le plugin"
+"the variables JSON has no `variableCollections` (expected the local variables response) and was ignored" = "le JSON des variables n’a pas de `variableCollections` (la réponse des variables locales était attendue) et a été ignoré"
 "this session only" = "cette session uniquement"
+"unknown component property types were skipped" = "les types de propriété de composant inconnus ont été ignorés"
+"variable aliases to variables that aren't in the variables JSON (or of another type) were skipped" = "les alias vers des variables absentes du JSON des variables (ou d’un autre type) ont été ignorés"
+"variable bindings to properties the layer doesn't have were skipped" = "les liaisons de variables à des propriétés que le calque n’a pas ont été ignorées"
+"variable bindings to variables that aren't in the variables JSON (library variables) were skipped" = "les liaisons à des variables absentes du JSON des variables (variables de bibliothèque) ont été ignorées"
+"variable bindings were skipped: the file JSON has no variable definitions (pass the local variables JSON as `variables`, or embed its `meta` next to the file JSON)" = "les liaisons de variables ont été ignorées : le JSON du fichier n’a aucune définition de variable (transmettez le JSON des variables locales comme `variables`, ou intégrez son `meta` à côté du JSON du fichier)"
+"variable bindings whose variable type doesn't fit the property were skipped" = "les liaisons de variables dont le type de variable ne convient pas à la propriété ont été ignorées"
+"variable collections without modes were skipped" = "les collections de variables sans mode ont été ignorées"
+"variable mode lookups in prototype expressions that aren't a variable and one of its modes were skipped" = "les recherches de mode de variable dans les expressions de prototype qui ne sont pas une variable et l’un de ses modes ont été ignorées"
+"variable modes of collections that aren't in the file were skipped" = "les modes de variables de collections absentes du fichier ont été ignorés"
+"variable modes of collections that aren't in the variables JSON were skipped" = "les modes de variables de collections absentes du JSON des variables ont été ignorés"
+"variable values that don't match their type (or composed colours) were skipped" = "les valeurs de variables qui ne correspondent pas à leur type (ou les couleurs composées) ont été ignorées"
+"variables of unknown types were skipped" = "les variables de types inconnus ont été ignorées"
+"variables whose collection isn't in the variables JSON were skipped" = "les variables dont la collection est absente du JSON des variables ont été ignorées"
+"variables without readable values were skipped" = "les variables sans valeurs lisibles ont été ignorées"
+"vector points with unknown stroke joins use the layer join" = "les points vectoriels aux jointures inconnues utilisent la jointure du calque"
+"vectors without geometry are empty" = "les vecteurs sans géométrie sont vides"
+"vectors without geometry are empty (export the file JSON with geometry=paths)" = "les vecteurs sans géométrie sont vides (exportez le JSON du fichier avec geometry=paths)"
+"very long text was cut to 1,048,576 characters" = "le texte très long a été coupé à 1 048 576 caractères"
+"very long vector paths were skipped" = "les tracés vectoriels très longs ont été ignorés"
+"video actions are not supported and were skipped" = "les actions vidéo ne sont pas prises en charge et ont été ignorées"
+"video triggers are not supported and were skipped" = "les déclencheurs vidéo ne sont pas pris en charge et ont été ignorés"
+"yesterday" = "hier"
 "{instances} in {files}" = "{instances} dans {files}"
 "{language}: draft translation, waiting for a native speaker's review." = "{language} : traduction provisoire, en attente de relecture par un locuteur natif."
 "{length} bleed" = "fond perdu de {length}"
+"{month} {day}, {year}" = "{day} {month} {year}"
 "{name}\nClick to apply to the selection" = "{name}\nCliquez pour l’appliquer à la sélection"
 "{name}\nDrag onto the canvas, or click to place in the middle of the view.\nHold Alt (Option) while dropping onto an instance to swap it." = "{name}\nFaites glisser sur le canevas, ou cliquez pour le placer au centre de la vue.\nMaintenez Alt (Option) en le déposant sur une instance pour la permuter."
 "{name} (from {library})" = "{name} (de {library})"
@@ -1459,6 +1706,7 @@ status = "draft — needs native review"
 "{name} is forgotten on this computer; the file stays on {server}" = "{name} est oublié sur cet ordinateur ; le fichier reste sur {server}"
 "{name} is on the server." = "{name} est sur le serveur."
 "{name} is spotlighting" = "{name} est sous les projecteurs"
+"{name} is too large to open in the browser (over 512 MB)." = "{name} est trop volumineux pour être ouvert dans le navigateur (plus de 512 Mo)."
 "{name} was removed from the server" = "{name} a été retiré du serveur"
 "{name} · deleted on main" = "{name} · supprimé dans le principal"
 "{name} · deleted on the branch" = "{name} · supprimé dans la branche"
@@ -1487,6 +1735,7 @@ status = "draft — needs native review"
 "{n} matches" = { one = "{n} résultat", other = "{n} résultats" }
 "{n} minutes ago" = { one = "il y a {n} minute", other = "il y a {n} minutes" }
 "{n} months ago" = { one = "il y a {n} mois", other = "il y a {n} mois" }
+"{n} more notes omitted from this report" = { one = "{n} autre note omise de ce rapport", other = "{n} autres notes omises de ce rapport" }
 "{n} of {total}" = "{n} sur {total}"
 "{n} people joined" = { one = "{n} personne a rejoint la session", other = "{n} personnes ont rejoint la session" }
 "{n} preferred components" = { one = "{n} composant préféré", other = "{n} composants préférés" }
@@ -1503,6 +1752,7 @@ status = "draft — needs native review"
 "{n}m" = "{n} min"
 "{n}w" = "{n} sem."
 "{page}, nothing selected" = "{page}, aucune sélection"
+"{percent}%" = "{percent} %"
 "{profile} (current)" = "{profile} (actuel)"
 "{property} is its value; {property ? \"a\" : \"b\"} picks a string. Other {…} stays as written." = "{property} donne sa valeur ; {property ? \"a\" : \"b\"} choisit un texte. Tout autre {…} reste tel quel."
 "{server} can't say what became of your files (it is older than this app)." = "{server} ne peut pas dire ce que sont devenus vos fichiers (il est plus ancien que cette application)."
@@ -1546,7 +1796,17 @@ status = "draft — needs native review"
 "arrange.packH" = "Tasser horizontalement"
 "arrange.packV" = "Tasser verticalement"
 "arrange.roundToPixels" = "Arrondir aux pixels"
+"arrange.spacing" = "Espacement"
 "arrange.tidy" = "Ranger"
+"board.connector" = "Connecteur"
+"board.ink" = "Trait de marqueur"
+"board.label" = "Libellé du connecteur"
+"board.nextSticky" = "Note autocollante suivante"
+"board.setColor" = "Couleur du tableau"
+"board.setStyle" = "Style du tableau"
+"board.shape" = "Forme avec texte"
+"board.stamp" = "Tampon"
+"board.sticky" = "Note autocollante"
 "bool.exclude" = "Exclure la sélection"
 "bool.flatten" = "Aplatir le booléen"
 "bool.intersect" = "Intersection de la sélection"
@@ -1610,8 +1870,10 @@ status = "draft — needs native review"
 "component.editProperty" = "Modifier la propriété de composant"
 "component.exposeInstance" = "Exposer l’instance imbriquée"
 "component.goToMain" = "Aller au composant principal"
+"component.hideWhenPublishing" = "Masquer à la publication"
 "component.list" = "Lister les composants"
 "component.makeSlot" = "Créer un emplacement"
+"component.playground" = "Bac à sable de composant"
 "component.properties" = "Propriétés du composant"
 "component.pushChanges" = "Transmettre les modifications au composant principal"
 "component.removeSlot" = "Retirer l’emplacement"
@@ -1645,6 +1907,7 @@ status = "draft — needs native review"
 "edit.duplicate" = "Dupliquer"
 "edit.findReplace" = "Rechercher et remplacer"
 "edit.paste" = "Coller"
+"edit.pasteDesignLayers" = "Coller des calques de design"
 "edit.pasteOver" = "Coller par-dessus la sélection"
 "edit.pasteProperties" = "Coller les propriétés"
 "edit.pasteReplace" = "Coller pour remplacer"
@@ -1668,7 +1931,10 @@ status = "draft — needs native review"
 "file.exportLayers" = "Exporter les calques"
 "file.exportSvg" = "Exporter la sélection en SVG"
 "file.import" = "Importer"
+"file.moveTab" = "Déplacer l’onglet"
 "file.new" = "Nouveau fichier de design"
+"file.newBoard" = "Nouveau tableau blanc"
+"file.newFromTemplate" = "Nouveau à partir d’un modèle"
 "file.open" = "Ouvrir"
 "file.openRecent" = "Ouvrir un fichier récent"
 "file.placeImage" = "Placer une image"
@@ -1696,6 +1962,7 @@ status = "draft — needs native review"
 "guide.remove" = "Retirer le repère"
 "guide.select" = "Sélectionner le repère"
 "help.about" = "À propos de FigCraft"
+"help.gettingStarted" = "Premiers pas"
 "help.page" = "Page d’aide"
 "help.shortcuts" = "Raccourcis clavier"
 "image.adjust" = "Régler l’image"
@@ -1749,6 +2016,9 @@ status = "draft — needs native review"
 "node.reparent" = "Déplacer le calque dans"
 "node.set" = "Définir les propriétés"
 "object.batchRename" = "Renommer par lot"
+"object.convertToFrame" = "Convertir en cadre"
+"object.convertToGroup" = "Convertir en groupe"
+"object.convertToSection" = "Convertir en section"
 "object.flipH" = "Retourner horizontalement"
 "object.flipV" = "Retourner verticalement"
 "object.frameSelection" = "Encadrer la sélection"
@@ -1805,6 +2075,8 @@ status = "draft — needs native review"
 "pref.reduceMotion" = "Réduire les animations"
 "pref.renameDuplicates" = "Renommer les calques dupliqués"
 "pref.showDimensions" = "Afficher les dimensions sur les objets"
+"pref.startOnHome" = "Démarrer sur l’Accueil"
+"pref.uiScale" = "Taille de l’interface"
 "pref.userName" = "Votre nom dans les commentaires"
 "proto.action.add" = "Ajouter une action de prototype"
 "proto.action.move" = "Réordonner l’action de prototype"
@@ -1848,6 +2120,10 @@ status = "draft — needs native review"
 "select.sameStroke" = "Sélectionner le même contour"
 "select.sameText" = "Sélectionner les mêmes propriétés de texte"
 "select.set" = "Sélectionner"
+"selection.applyColorStyle" = "Appliquer un style de couleur à la sélection"
+"selection.colors" = "Couleurs de la sélection"
+"selection.selectColor" = "Sélectionner les calques de cette couleur"
+"selection.setPaint" = "Changer la couleur de la sélection"
 "shape.arrow" = "Flèche"
 "shape.ellipse" = "Ellipse"
 "shape.line" = "Ligne"
@@ -1865,6 +2141,7 @@ status = "draft — needs native review"
 "stroke.set" = "Définir le contour"
 "stroke.widthProfile" = "Profil de largeur"
 "style.apply" = "Appliquer le style"
+"style.bind" = "Lier une variable dans un style"
 "style.create" = "Créer un style"
 "style.delete" = "Supprimer le style"
 "style.detach" = "Détacher le style"
@@ -1873,6 +2150,7 @@ status = "draft — needs native review"
 "style.move" = "Déplacer les styles"
 "style.renameFolder" = "Renommer le dossier de styles"
 "style.update" = "Modifier le style"
+"template.list" = "Lister les modèles"
 "text.alignCenter" = "Centrer"
 "text.alignJustify" = "Justifier"
 "text.alignLeft" = "Aligner à gauche"
@@ -1927,10 +2205,14 @@ status = "draft — needs native review"
 "text.weightUp" = "Augmenter la graisse"
 "tool.arrow" = "Flèche"
 "tool.comment" = "Commentaire"
+"tool.connector" = "Connecteur"
 "tool.ellipse" = "Ellipse"
+"tool.eraser" = "Gomme"
 "tool.frame" = "Cadre"
 "tool.hand" = "Main"
+"tool.highlighter" = "Surligneur"
 "tool.line" = "Ligne"
+"tool.marker" = "Marqueur"
 "tool.move" = "Déplacer"
 "tool.pen" = "Plume"
 "tool.pencil" = "Crayon"
@@ -1942,9 +2224,12 @@ status = "draft — needs native review"
 "tool.scaleAnchor" = "Ancre de mise à l’échelle"
 "tool.section" = "Section"
 "tool.set" = "Choisir un outil"
+"tool.shape" = "Formes"
 "tool.shapeBuilder" = "Générateur de formes"
 "tool.slice" = "Tranche"
+"tool.stamp" = "Tampon"
 "tool.star" = "Étoile"
+"tool.sticky" = "Note autocollante"
 "tool.text" = "Texte"
 "transform.move" = "Déplacer"
 "transform.moveTo" = "Déplacer vers"
@@ -2006,11 +2291,13 @@ status = "draft — needs native review"
 "vector.edit.tool" = "Outil de modification vectorielle"
 "vector.edit.transform" = "Transformer les points"
 "vector.edit.widthPoint" = "Point de largeur"
+"vector.fillRule" = "Définir la règle de remplissage"
 "vector.flatten" = "Aplatir"
 "vector.join" = "Joindre la sélection"
 "vector.offset" = "Décaler le tracé"
 "vector.outlineStroke" = "Convertir le contour en tracé"
 "vector.reverse" = "Inverser le sens du tracé"
+"vector.reverseLoop" = "Inverser la boucle"
 "vector.simplify" = "Simplifier le vecteur"
 "vector.smoothJoin" = "Joindre la sélection en lissant"
 "version.autosave" = "Enregistrer automatiquement une version"
@@ -2038,8 +2325,11 @@ status = "draft — needs native review"
 "view.nextPage" = "Page suivante"
 "view.nextRegion" = "Activer la région suivante"
 "view.outlines" = "Contours"
+"view.outlinesHiddenLayers" = "Inclure les calques masqués dans les contours"
+"view.outlinesObjectBounds" = "Inclure les limites des objets dans les contours"
 "view.outlinesSelection" = "Contours de la sélection"
 "view.pan" = "Faire défiler la vue"
+"view.panelWidths" = "Réinitialiser la largeur des panneaux"
 "view.pixelGrid" = "Grille de pixels"
 "view.pixelPreview" = "Aperçu des pixels"
 "view.prevFrame" = "Zoomer sur le cadre précédent"
@@ -2097,6 +2387,8 @@ status = "draft — needs native review"
 "view.design" = "Design"
 "view.layers" = "Calques"
 "view.outlines" = "Afficher les contours"
+"view.outlinesHiddenLayers" = "Inclure les calques masqués"
+"view.outlinesObjectBounds" = "Inclure les limites des objets"
 "view.outlinesSelection" = "Afficher les contours de la sélection"
 "view.prototype" = "Prototype"
 "view.themeDark" = "Sombre"
diff --git a/crates/ui-egui/locales/id.toml b/crates/ui-egui/locales/id.toml
index 5de7634d4..c06f2dfff 100644
--- a/crates/ui-egui/locales/id.toml
+++ b/crates/ui-egui/locales/id.toml
@@ -17,6 +17,7 @@ status = "draft — needs native review"
 "1…9, 0" = "1…9, 0"
 "@{login}: {prs} PRs, {commits} commits, +{added} / −{deleted} lines (Δ {delta}), +{bin_added} / −{bin_deleted} binary assets, {first} – {last}" = "@{login}: {prs} PR, {commits} commit, +{added} / −{deleted} baris (Δ {delta}), +{bin_added} / −{bin_deleted} aset biner, {first} – {last}"
 "A collection of this file with these modes and variables: override their values per mode and add variables of its own" = "Koleksi file ini dengan mode dan variabel tersebut: timpa nilainya per mode dan tambahkan variabel sendiri"
+"A .figcraft file with this name already exists. Choose its full name to confirm replacement." = "File .figcraft dengan nama ini sudah ada. Pilih nama lengkapnya untuk mengonfirmasi penggantian."
 "A layer on its own aligns to its frame: select more layers, or one in a frame" = "Satu layer saja diratakan ke frame-nya: pilih lebih banyak layer, atau satu layer di dalam frame"
 "A responsive product page: hero, features, figures, a quote and a footer" = "Halaman produk responsif: hero, fitur, angka, kutipan, dan footer"
 "A spring plays until it settles: its mass, stiffness and damping set how long" = "Spring berjalan hingga stabil: massa, kekakuan, dan redamannya menentukan durasinya"
@@ -123,6 +124,7 @@ status = "draft — needs native review"
 "Archived" = "Diarsipkan"
 "Arrange" = "Susun"
 "Arrow" = "Panah"
+"Arrow at the end" = "Panah di ujung"
 "As typed" = "Sesuai ketikan"
 "Asking the server…" = "Menghubungi server…"
 "Assets" = "Aset"
@@ -196,7 +198,9 @@ status = "draft — needs native review"
 "C or ⇧C" = "C atau ⇧C"
 "CMYK colour" = "Warna CMYK"
 "Can view" = "Dapat melihat"
+"Check" = "Centang"
 "Checking the server…" = "Memeriksa server…"
+"Chevron" = "Chevron"
 "Clear from this list" = "Hapus dari daftar ini"
 "Code or invite link" = "Kode atau link undangan"
 "Color profile: {name}" = "Profil warna: {name}"
@@ -243,7 +247,6 @@ status = "draft — needs native review"
 "Close tab" = "Tutup tab"
 "Close version history" = "Tutup riwayat versi"
 "Close when clicking outside" = "Tutup saat klik di luar"
-"Close without saving" = "Tutup tanpa menyimpan"
 "Code" = "Kode"
 "Code syntax" = "Sintaks kode"
 "Collapse" = "Ciutkan"
@@ -270,6 +273,7 @@ status = "draft — needs native review"
 "Commits" = "Commit"
 "Company" = "Perusahaan"
 "Compare changes" = "Bandingkan perubahan"
+"Compatibility notes" = "Catatan kompatibilitas"
 "Completed" = "Selesai"
 "Component" = "Component"
 "Component name" = "Nama component"
@@ -284,6 +288,7 @@ status = "draft — needs native review"
 "Connected" = "Terhubung"
 "Connected to code: {from}" = "Terhubung ke kode: {from}"
 "Connection lost, reconnecting (attempt {attempt})…" = "Koneksi terputus, menghubungkan ulang (percobaan {attempt})…"
+"Connector" = "Konektor"
 "Constrain proportions" = "Kunci proporsi"
 "Constraints" = "Batasan"
 "Content" = "Konten"
@@ -312,6 +317,7 @@ status = "draft — needs native review"
 "Corner radius" = "Radius sudut"
 "Corner smoothing" = "Penghalusan sudut"
 "Couldn't reach {server}: showing what this computer remembers." = "Tidak dapat terhubung ke {server}: menampilkan data yang diingat komputer ini."
+"Couldn't read {name}." = "Tidak dapat membaca {name}."
 "Count" = "Jumlah"
 "Create" = "Buat"
 "Create a variable collection first" = "Buat koleksi variabel terlebih dahulu"
@@ -335,6 +341,7 @@ status = "draft — needs native review"
 "Current version" = "Versi saat ini"
 "Cursor chat" = "Chat kursor"
 "Custom" = "Kustom"
+"Custom size" = "Ukuran kustom"
 "Cut" = "Potong"
 "Dark" = "Gelap"
 "Darken" = "Gelapkan"
@@ -368,6 +375,7 @@ status = "draft — needs native review"
 "Description" = "Deskripsi"
 "Description (optional)" = "Deskripsi (opsional)"
 "Design" = "Desain"
+"Design panel" = "Panel desain"
 "Design system starter" = "Dasar sistem desain"
 "Desktop" = "Desktop"
 "Destination" = "Tujuan"
@@ -395,6 +403,7 @@ status = "draft — needs native review"
 "Distribute horizontal spacing" = "Sebarkan jarak horizontal"
 "Distribute vertical spacing" = "Sebarkan jarak vertikal"
 "Divider" = "Pembatas"
+"Don't Save" = "Jangan simpan"
 "Don't truncate" = "Jangan potong"
 "Done" = "Selesai"
 "Done editing" = "Selesai mengedit"
@@ -427,6 +436,7 @@ status = "draft — needs native review"
 "Effect settings" = "Pengaturan efek"
 "Effect styles" = "Gaya efek"
 "Effects" = "Efek"
+"Elbow" = "Siku"
 "Ellipse" = "Elips"
 "Ellipses" = "Elips"
 "Else" = "Jika tidak"
@@ -476,6 +486,7 @@ status = "draft — needs native review"
 "False" = "Salah"
 "Feb" = "Feb"
 "Fetching from the server…" = "Mengambil dari server…"
+"FigCraft doesn't support every feature of these files yet. The notes list what was left out or changed in the imported copy; the original file is unchanged." = "FigCraft belum mendukung semua fitur file ini. Catatan berisi apa yang dihilangkan atau diubah pada salinan yang diimpor; file aslinya tidak berubah."
 "File" = "File"
 "File name" = "Nama file"
 "File not found" = "File tidak ditemukan"
@@ -561,6 +572,7 @@ status = "draft — needs native review"
 "Hanging list" = "Daftar menggantung"
 "Hanging punctuation" = "Tanda baca menggantung"
 "Hard light" = "Hard light"
+"Heart" = "Hati"
 "Height" = "Tinggi"
 "Help" = "Bantuan"
 "Help and resources" = "Bantuan dan sumber daya"
@@ -573,6 +585,7 @@ status = "draft — needs native review"
 "Hide these tips (Getting started in the Help menu shows them again)" = "Sembunyikan tips ini (tampilkan lagi lewat Memulai di menu Bantuan)"
 "Hide when publishing" = "Sembunyikan saat dipublikasikan"
 "Highlight layers on hover" = "Sorot layer saat hover"
+"Highlighter" = "Stabilo"
 "Highlights" = "Sorotan"
 "Hold Alt" = "Tahan Alt"
 "Hold Alt+Z" = "Tahan Alt+Z"
@@ -599,11 +612,14 @@ status = "draft — needs native review"
 "If {condition}" = "Jika {condition}"
 "Ignore auto layout (absolute position)" = "Abaikan auto layout (posisi absolut)"
 "Image" = "Gambar"
+"Images" = "Gambar"
 "Import" = "Impor"
 "Import path" = "Jalur impor"
 "Import plugin from manifest" = "Impor plugin dari manifest"
 "Import plugin from manifest…" = "Impor plugin dari manifest…"
+"Import report" = "Laporan impor"
 "Import variables" = "Impor variabel"
+"Imported document" = "Dokumen yang diimpor"
 "Imported {name}" = "{name} diimpor"
 "Imported {n} new variables, updated {updated}" = { other = "{n} variabel baru diimpor, {updated} diperbarui" }
 "Import…" = "Impor…"
@@ -631,11 +647,13 @@ status = "draft — needs native review"
 "Instance swap (no other component)" = "Tukar instance (tidak ada component lain)"
 "Instances" = "Instance"
 "Instant" = "Instan"
+"Intensity" = "Intensitas"
 "Interaction" = "Interaksi"
 "Interactions" = "Interaksi"
 "Interface design and prototyping. A free, open-source, clean-room design tool written from scratch in Rust, part of the ArtCraft Crafting Apps." = "Desain antarmuka dan prototyping. Alat desain clean-room gratis dan open-source yang ditulis dari nol dengan Rust, bagian dari ArtCraft Crafting Apps."
 "Intersect" = "Irisan"
 "Intersects" = "Beririsan"
+"Invalid color" = "Warna tidak valid"
 "Invite link" = "Link undangan"
 "Invite link copied" = "Link undangan disalin"
 "It asks permission to:" = "Plugin ini meminta izin untuk:"
@@ -733,6 +751,7 @@ status = "draft — needs native review"
 "Mark as resolved" = "Tandai selesai"
 "Mark as unread" = "Tandai belum dibaca"
 "Mark as unresolved" = "Tandai belum selesai"
+"Marker" = "Spidol"
 "Mask" = "Mask"
 "Mass · Stiffness · Damping" = "Massa · Kekakuan · Redaman"
 "Match (empty: the whole name)" = "Cocokkan (kosong: seluruh nama)"
@@ -791,8 +810,10 @@ status = "draft — needs native review"
 "Named instance" = "Instance bernama"
 "Navigate to" = "Navigasi ke"
 "Nested instance" = "Instance bersarang"
+"New board" = "Papan baru"
 "New design file" = "File desain baru"
 "Newest first" = "Terbaru dulu"
+"Next frame" = "Frame berikutnya"
 "Next or previous control in the focused region" = "Kontrol berikutnya atau sebelumnya di wilayah yang difokuskan"
 "Next ready for dev" = "Siap dev berikutnya"
 "Next size option" = "Opsi ukuran berikutnya"
@@ -802,12 +823,15 @@ status = "draft — needs native review"
 "No branches. A branch is a copy of the file to try changes in, then review and merge." = "Tidak ada branch. Branch adalah salinan file untuk mencoba perubahan, lalu ditinjau dan di-merge."
 "No category" = "Tanpa kategori"
 "No changes" = "Tidak ada perubahan"
+"No color styles" = "Tidak ada gaya warna"
 "No colour variables fit here." = "Tidak ada variabel warna yang cocok di sini."
 "No colour variables yet. Create them in Local variables." = "Belum ada variabel warna. Buat di Variabel lokal."
 "No comments yet" = "Belum ada komentar"
+"No compatibility warnings reported" = "Tidak ada peringatan kompatibilitas"
 "No components yet. Select layers and press {keys}." = "Belum ada component. Pilih layer lalu tekan {keys}."
 "No conflicts." = "Tidak ada konflik."
 "No contributor data was built into this copy." = "Tidak ada data kontributor yang disertakan dalam salinan ini."
+"No device" = "Tanpa perangkat"
 "No fonts match" = "Tidak ada font yang cocok"
 "No join code here (the server is older than join codes, or this address can't be put in one): share the link instead." = "Tidak ada kode gabung di sini (versi server lebih lama dari fitur kode gabung, atau alamat ini tidak dapat dimasukkan ke kode): bagikan link-nya saja."
 "No layer changes to show." = "Tidak ada perubahan layer untuk ditampilkan."
@@ -888,6 +912,7 @@ status = "draft — needs native review"
 "Open branch" = "Buka branch"
 "Open file" = "Buka file"
 "Open files" = "Buka file"
+"Open presentations" = "Presentasi yang terbuka"
 "Open in focus view" = "Buka di tampilan fokus"
 "Open in new window" = "Buka di jendela baru"
 "Open invite links in FigCraft" = "Buka link undangan di FigCraft"
@@ -896,6 +921,7 @@ status = "draft — needs native review"
 "Open overlay" = "Buka overlay"
 "Open prototype preview" = "Buka pratinjau prototype"
 "Open variables ({count})" = "Buka variabel ({count})"
+"Opened as a new document" = "Dibuka sebagai dokumen baru"
 "Opened “{name}” in a new tab" = "“{name}” dibuka di tab baru"
 "Open|comments" = "Terbuka"
 "Options" = "Opsi"
@@ -919,7 +945,11 @@ status = "draft — needs native review"
 "PDF print settings" = "Pengaturan cetak PDF"
 "Padding" = "Padding"
 "Page" = "Halaman"
+"Page deleted" = "Halaman dihapus"
 "Pages" = "Halaman"
+"Pages added to the document" = "Halaman ditambahkan ke dokumen"
+"Pink" = "Merah muda"
+"Placed on the current page" = "Ditempatkan di halaman saat ini"
 "Pages: {pages}" = "Halaman: {pages}"
 "Paint bucket" = "Ember cat"
 "Pan the canvas" = "Geser kanvas"
@@ -934,6 +964,7 @@ status = "draft — needs native review"
 "Paste a team library link (a view link)" = "Tempel link pustaka tim (link akses lihat)"
 "Paste here" = "Tempel di sini"
 "Paste to replace" = "Tempel dan ganti"
+"Pasted design layers; {n} kinds of content were left out" = { other = "Layer desain ditempel; {n} jenis konten tidak disertakan" }
 "Pattern" = "Pola"
 "Pattern alignment" = "Perataan pola"
 "Pattern scale" = "Skala pola"
@@ -960,6 +991,7 @@ status = "draft — needs native review"
 "Plugins" = "Plugin"
 "Plus darker" = "Plus darker"
 "Plus lighter" = "Plus lighter"
+"Plus one" = "Plus satu"
 "Point" = "Titik"
 "Points" = "Titik"
 "Polygon" = "Poligon"
@@ -987,6 +1019,7 @@ status = "draft — needs native review"
 "Preview" = "Pratinjau"
 "Preview this flow" = "Pratinjau alur ini"
 "Preview this frame" = "Pratinjau frame ini"
+"Previous frame" = "Frame sebelumnya"
 "Previous ready for dev" = "Versi siap dev sebelumnya"
 "Progressive" = "Progresif"
 "Properties" = "Properti"
@@ -1007,6 +1040,7 @@ status = "draft — needs native review"
 "Push" = "Dorong"
 "Push changes to main component" = "Terapkan perubahan ke main component"
 "Put text on path" = "Tempatkan teks di path"
+"Question" = "Pertanyaan"
 "R" = "R"
 "Radial" = "Radial"
 "Radius" = "Radius"
@@ -1080,6 +1114,7 @@ status = "draft — needs native review"
 "Resize by the nudge amount" = "Ubah ukuran sebesar jarak geser"
 "Resize frames to the device's screen (or the window without a device): their constraints and auto layout respond" = "Ubah ukuran frame ke layar perangkat (atau jendela tanpa perangkat): batasan dan auto layout-nya menyesuaikan"
 "Resize to fit" = "Ubah ukuran agar pas"
+"Resizing" = "Pengubahan ukuran"
 "Resolve" = "Selesaikan"
 "Resolve change" = "Selesaikan perubahan"
 "Resolved" = "Terselesaikan"
@@ -1105,6 +1140,7 @@ status = "draft — needs native review"
 "Rotation jitter" = "Variasi rotasi"
 "Round" = "Bulat"
 "Rounded" = "Membulat"
+"Rounded rectangle" = "Persegi panjang membulat"
 "Row" = "Baris"
 "Row gap" = "Jarak baris"
 "Row sizes" = "Ukuran baris"
@@ -1153,12 +1189,14 @@ status = "draft — needs native review"
 "Select all with same" = "Pilih semua yang sama"
 "Select layer" = "Pilih layer"
 "Select layers to apply the style to" = "Pilih layer untuk menerapkan gaya"
+"Select layers with this color" = "Pilih layer dengan warna ini"
 "Select overlapping shapes" = "Pilih bentuk yang tumpang tindih"
 "Select points to edit their position, radius and mirroring" = "Pilih titik untuk mengedit posisi, radius, dan pencerminannya"
 "Select slot" = "Pilih slot"
 "Selection" = "Pilihan"
 "Selection box, {w} by {h} at {x}, {y}: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "Kotak pilihan, {w} x {h} di {x}, {y}: panah untuk memindahkan, Shift+panah atau {cmd}+panah untuk mengubah ukuran, Enter untuk memilih, Escape untuk membatalkan"
 "Selection box: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "Kotak pilihan: panah untuk memindahkan, Shift+panah atau {cmd}+panah untuk mengubah ukuran, Enter untuk memilih, Escape untuk membatalkan"
+"Selection colors" = "Warna pilihan"
 "Send backward" = "Bawa mundur"
 "Send report" = "Kirim laporan"
 "Send to back" = "Bawa ke paling belakang"
@@ -1175,6 +1213,7 @@ status = "draft — needs native review"
 "Shape" = "Bentuk"
 "Shape builder" = "Shape builder"
 "Shape tools" = "Alat bentuk"
+"Shapes" = "Bentuk"
 "Share" = "Bagikan"
 "Share this file" = "Bagikan file ini"
 "Share with a code" = "Bagikan dengan kode"
@@ -1241,10 +1280,13 @@ status = "draft — needs native review"
 "Space+drag" = "Space+seret"
 "Spacing" = "Spasi"
 "Spam, stolen work, abuse…" = "Spam, karya curian, penyalahgunaan…"
+"Speech bubble" = "Balon kata"
 "Splay" = "Bukaan"
 "Spotlight me" = "Sorot saya"
 "Spread" = "Sebaran"
 "Square" = "Persegi"
+"Stamp" = "Stempel"
+"Stamps" = "Stempel"
 "Standard" = "Standar"
 "Standard ligatures" = "Ligatur standar"
 "Star" = "Bintang"
@@ -1260,12 +1302,16 @@ status = "draft — needs native review"
 "Starting to share…" = "Memulai berbagi…"
 "Status" = "Status"
 "Sticky" = "Menempel"
+"Sticky note" = "Catatan tempel"
+"Sticky note colors" = "Warna catatan tempel"
+"Sticky notes, shapes and connectors" = "Catatan tempel, bentuk, dan konektor"
 "Stop" = "Hentikan"
 "Stop following {name}" = "Berhenti mengikuti {name}"
 "Stop session" = "Hentikan sesi"
 "Stop sharing" = "Berhenti berbagi"
 "Stop spotlighting" = "Hentikan sorotan"
 "Stop {n}  {hex}" = "Titik {n}  {hex}"
+"Straight" = "Lurus"
 "Stretch" = "Regangkan"
 "Strikethrough" = "Coret"
 "String" = "String"
@@ -1310,6 +1356,7 @@ status = "draft — needs native review"
 "Text" = "Teks"
 "Text align" = "Perataan teks"
 "Text content" = "Konten teks"
+"Text size" = "Ukuran teks"
 "Text style" = "Gaya teks"
 "Text styles" = "Gaya teks"
 "Texts" = "Teks"
@@ -1340,6 +1387,7 @@ status = "draft — needs native review"
 "This server is open to the public: no key needed." = "Server ini terbuka untuk publik: tidak perlu kunci."
 "This server needs its key: add ?key=… to the address (`figcraft-server key` prints it on the server's machine)." = "Server ini memerlukan kuncinya: tambahkan ?key=… ke alamat (`figcraft-server key` menampilkannya di mesin server)."
 "This server takes files only with its key: see Advanced." = "Server ini hanya menerima file dengan kuncinya: lihat Lanjutan."
+"Thumbs up" = "Jempol"
 "Tidy up" = "Rapikan"
 "Tile" = "Ubin"
 "Tile type" = "Jenis ubin"
@@ -1356,6 +1404,7 @@ status = "draft — needs native review"
 "Top left radius" = "Radius kiri atas"
 "Top right radius" = "Radius kanan atas"
 "Transform" = "Transformasi"
+"Triangle" = "Segitiga"
 "Triangle arrow" = "Panah segitiga"
 "Trigger" = "Pemicu"
 "True" = "Benar"
@@ -1380,7 +1429,7 @@ status = "draft — needs native review"
 "Unread" = "Belum dibaca"
 "Unresolve" = "Buka kembali"
 "Unsaved changes" = "Perubahan belum disimpan"
-"Unsaved changes in {names}. Close the window and lose them?" = "Perubahan belum disimpan di {names}. Tutup jendela dan buang perubahan?"
+"Unsaved changes in {names}. Save them before closing?" = "Perubahan belum disimpan di {names}. Simpan sebelum menutup?"
 "Unsaved changes: save first ({save}), or close the tab with {alt}-click to discard" = "Perubahan belum disimpan: simpan dulu ({save}), atau tutup tab dengan {alt}-klik untuk membuangnya"
 "Unsaved changes: save first, or close again with {key} to discard" = "Perubahan belum disimpan: simpan dulu, atau tutup lagi dengan {key} untuk membuangnya"
 "Up" = "Atas"
@@ -1397,6 +1446,7 @@ status = "draft — needs native review"
 "Use as mask" = "Gunakan sebagai mask"
 "Use auto layout" = "Gunakan auto layout"
 "Use number keys for opacity" = "Gunakan tombol angka untuk opasitas"
+"Use the .figcraft or .fig extension." = "Gunakan ekstensi .figcraft atau .fig."
 "Use the layer's fill" = "Gunakan fill layer"
 "Used in {files} · {instances}" = "Digunakan di {files} · {instances}"
 "Username" = "Nama pengguna"
@@ -1489,26 +1539,119 @@ status = "draft — needs native review"
 "call any command its access allows" = "memanggil perintah apa pun yang diizinkan aksesnya"
 "call only: {commands}" = "hanya memanggil: {commands}"
 "can edit the document" = "dapat mengedit dokumen"
+"conditional prototype actions nested too deeply were skipped" = "tindakan prototype kondisional yang bersarang terlalu dalam dilewati"
+"conditional prototype actions with conditions that can't be evaluated were skipped" = "tindakan prototype kondisional dengan kondisi yang tidak dapat dievaluasi dilewati"
+"connector label background was skipped: style data is missing" = "latar belakang label konektor dilewati: data gaya tidak ada"
+"connector label was skipped: background bounds are invalid" = "label konektor dilewati: batas latar belakang tidak valid"
+"connector label was skipped: background transform is invalid" = "label konektor dilewati: transformasi latar belakang tidak valid"
+"connector label was skipped: composed text transform is invalid" = "label konektor dilewati: transformasi gabungan teks tidak valid"
+"connector label was skipped: derived background bounds are missing" = "label konektor dilewati: batas turunan latar belakang tidak ada"
+"connector label was skipped: derived text bounds are missing" = "label konektor dilewati: batas turunan teks tidak ada"
+"connector label was skipped: text bounds are invalid" = "label konektor dilewati: batas teks tidak valid"
+"connector label was skipped: text style data is missing" = "label konektor dilewati: data gaya teks tidak ada"
+"connector label was skipped: text transform is invalid" = "label konektor dilewati: transformasi teks tidak valid"
+"connector labels were skipped" = "label konektor dilewati"
+"connector layers import as static frame/vector snapshots with labels when present; live endpoint bindings are not retained" = "layer konektor diimpor sebagai snapshot frame/vector statis beserta labelnya jika ada; binding dinamis titik ujung tidak dipertahankan"
+"connector snapshot vector data is missing; connector was left empty" = "data vector snapshot konektor tidak ada; konektor dibiarkan kosong"
+"connectors whose ends can't be placed are empty" = "konektor yang ujungnya tidak dapat ditempatkan kosong"
 "crop marks" = "tanda potong"
+"damaged vector geometry was skipped" = "geometri vector yang rusak dilewati"
+"damaged vector networks import as outlines" = "jaringan vector yang rusak diimpor sebagai outline"
 "development: {path}" = "pengembangan: {path}"
+"document children other than pages were skipped" = "anak dokumen selain halaman dilewati"
+"duplicate grid track sizing entries use equal tracks" = "entri ukuran track grid yang duplikat memakai track yang sama besar"
 "e.g. count + 1" = "mis. count + 1"
 "e.g. count >= 3 and not done" = "mis. count >= 3 and not done"
+"elbowed and curved connectors without a saved path import as straight lines" = "konektor siku dan lengkung tanpa jalur tersimpan diimpor sebagai garis lurus"
+"entries without a node type were skipped" = "entri tanpa tipe node dilewati"
 "figcraft:// links from a browser, chat or email open this app and join the session." = "Link figcraft:// dari browser, chat, atau email membuka aplikasi ini dan bergabung ke sesi."
+"filled areas of a vector with their own fill use the layer's fill" = "area terisi pada vector dengan isian sendiri memakai isian layer"
 "from {server}" = "dari {server}"
+"gamepad triggers without exactly one known controller button were skipped" = "pemicu gamepad yang tidak memiliki tepat satu tombol kontroler yang dikenal dilewati"
+"grid track list exceeds 1000 entries; the tracks use the default equal sizing" = "daftar track grid melebihi 1000 entri; track memakai ukuran sama besar bawaan"
+"grid track sizing is unsupported or malformed; affected tracks use equal sizing" = "ukuran track grid tidak didukung atau rusak; track yang terdampak memakai ukuran sama besar"
+"grid track sizing list exceeds 1000 entries; the tracks use the default equal sizing" = "daftar ukuran track grid melebihi 1000 entri; track memakai ukuran sama besar bawaan"
 "hidden" = "tersembunyi"
 "iOS" = "iOS"
+"image filters are ambiguous because both filter containers are present; filter conversion was skipped" = "filter gambar ambigu karena kedua kontainer filter ada; konversi filter dilewati"
+"image filters use FigCraft's approximate renderer" = "filter gambar memakai perenderan perkiraan FigCraft"
+"instance swap properties whose default component isn't in the file were skipped" = "properti tukar instance yang component bawaannya tidak ada di file dilewati"
+"instances inside their own main component were imported as frames" = "instance di dalam main component-nya sendiri diimpor sebagai frame"
+"instances of components that aren't in the file show no layers" = "instance dari component yang tidak ada di file tidak menampilkan layer"
+"instances of components that aren't in the file were imported as frames" = "instance dari component yang tidak ada di file diimpor sebagai frame"
+"instances that would nest a component inside itself were imported as frames" = "instance yang akan menyarangkan component di dalam dirinya sendiri diimpor sebagai frame"
+"instances without a main component were imported as empty frames" = "instance tanpa main component diimpor sebagai frame kosong"
+"invalid internal .fig text path data was ignored" = "data teks di path internal .fig yang tidak valid diabaikan"
+"invalid or oversized vector networks import as outlines" = "jaringan vector yang tidak valid atau terlalu besar diimpor sebagai outline"
+"invalid or oversized vector path data was skipped" = "data jalur vector yang tidak valid atau terlalu besar dilewati"
 "just now" = "baru saja"
+"key triggers without a supported key were skipped" = "pemicu tombol tanpa tombol yang didukung dilewati"
+"key up triggers import as key presses" = "pemicu saat tombol dilepas diimpor sebagai penekanan tombol"
+"layers without a position were placed at their parent's origin" = "layer tanpa posisi ditempatkan di titik asal induknya"
+"layers without a type were skipped" = "layer tanpa tipe dilewati"
+"legacy image filter container is unsupported; filter conversion was skipped" = "kontainer filter gambar versi lama tidak didukung; konversi filter dilewati"
 "locked" = "terkunci"
+"malformed image filters container was skipped" = "kontainer filter gambar yang rusak dilewati"
+"malformed image paintFilter container was skipped" = "kontainer paintFilter gambar yang rusak dilewati"
+"malformed slot content assignment was skipped" = "penetapan konten slot yang rusak dilewati"
 "no bleed" = "tanpa bleed"
 "nobody else here yet" = "belum ada orang lain di sini"
+"non-default slot settings are not represented and were skipped" = "pengaturan slot non-default tidak dapat direpresentasikan dan dilewati"
 "now" = "sekarang"
 "or" = "atau"
+"point stroke joins were preserved; dashed or variable-width strokes render with the layer join" = "sambungan stroke per titik dipertahankan; stroke putus-putus atau berlebar variabel digambar dengan sambungan layer"
+"preferred slot component keys cannot be resolved to file nodes and were skipped" = "kunci component pilihan slot tidak dapat dicocokkan dengan layer di file dan dilewati"
+"prototype actions of unknown types were skipped" = "tindakan prototype dengan tipe yang tidak dikenal dilewati"
+"prototype actions without a destination in the file were skipped" = "tindakan prototype tanpa tujuan di file dilewati"
+"prototype expressions on variables that aren't in the variables JSON were skipped" = "ekspresi prototype pada variabel yang tidak ada di JSON variabel dilewati"
+"prototype expressions with unsupported functions were skipped" = "ekspresi prototype dengan fungsi yang tidak didukung dilewati"
+"prototype interactions without supported actions were skipped" = "interaksi prototype tanpa tindakan yang didukung dilewati"
+"prototype navigations of unknown types were skipped" = "navigasi prototype dengan tipe yang tidak dikenal dilewati"
+"prototype transitions of unknown types play instantly" = "transisi prototype dengan tipe yang tidak dikenal berjalan instan"
+"prototype triggers of unknown types were skipped" = "pemicu prototype dengan tipe yang tidak dikenal dilewati"
 "put a widget on the canvas" = "menaruh widget di kanvas"
 "read and edit the document" = "membaca dan mengedit dokumen"
 "read the document" = "membaca dokumen"
 "reads the document" = "membaca dokumen"
+"set-variable actions on variables that aren't in the variables JSON were skipped" = "tindakan atur variabel pada variabel yang tidak ada di JSON variabel dilewati"
+"set-variable actions with values that can't be evaluated were skipped" = "tindakan atur variabel dengan nilai yang tidak dapat dievaluasi dilewati"
+"set-variable actions with values that don't fit the variable were skipped" = "tindakan atur variabel dengan nilai yang tidak cocok dengan variabelnya dilewati"
+"set-variable actions without a value were skipped" = "tindakan atur variabel tanpa nilai dilewati"
+"set-variable-mode actions on collections or modes that aren't in the variables JSON were skipped" = "tindakan atur mode variabel pada koleksi atau mode yang tidak ada di JSON variabel dilewati"
+"slot content assignment target is missing or is not slot content" = "target penetapan konten slot tidak ada atau bukan konten slot"
+"slot content assignment uses the empty GUID sentinel and was skipped" = "penetapan konten slot memakai GUID kosong sebagai penanda dan dilewati"
+"some vector points refer to point settings missing from the file; they use the layer's joins and plain corners" = "beberapa titik vector merujuk ke pengaturan titik yang tidak ada di file; titik tersebut memakai sambungan layer dan sudut biasa"
+"some vector segments refer to style settings missing from the file; they use the layer's stroke" = "beberapa segmen vector merujuk ke pengaturan gaya yang tidak ada di file; segmen tersebut memakai stroke layer"
+"stale or invalid grid track sizing entries were ignored" = "entri ukuran track grid yang usang atau tidak valid diabaikan"
+"stars and polygons without point counts or geometry use the default point count" = "bintang dan poligon tanpa jumlah titik atau geometri memakai jumlah titik bawaan"
+"style settings of some vector segments aren't supported; those segments use the layer's stroke" = "pengaturan gaya beberapa segmen vector tidak didukung; segmen tersebut memakai stroke layer"
+"text path underline or strikethrough decoration is not rendered" = "garis bawah atau coretan pada teks di path tidak digambar"
+"text style overrides refer to missing table entries" = "penimpaan gaya teks merujuk ke entri tabel yang tidak ada"
+"the file has no pages" = "file tidak memiliki halaman"
 "the plugin" = "plugin"
+"the variables JSON has no `variableCollections` (expected the local variables response) and was ignored" = "JSON variabel tidak memiliki `variableCollections` (yang diharapkan adalah respons variabel lokal) dan diabaikan"
 "this session only" = "hanya sesi ini"
+"unknown component property types were skipped" = "tipe properti component yang tidak dikenal dilewati"
+"variable aliases to variables that aren't in the variables JSON (or of another type) were skipped" = "alias ke variabel yang tidak ada di JSON variabel (atau bertipe lain) dilewati"
+"variable bindings to properties the layer doesn't have were skipped" = "binding variabel ke properti yang tidak dimiliki layer dilewati"
+"variable bindings to variables that aren't in the variables JSON (library variables) were skipped" = "binding ke variabel yang tidak ada di JSON variabel (variabel pustaka) dilewati"
+"variable bindings were skipped: the file JSON has no variable definitions (pass the local variables JSON as `variables`, or embed its `meta` next to the file JSON)" = "binding variabel dilewati: JSON file tidak memiliki definisi variabel (berikan JSON variabel lokal sebagai `variables`, atau sematkan `meta`-nya di samping JSON file)"
+"variable bindings whose variable type doesn't fit the property were skipped" = "binding variabel yang tipe variabelnya tidak cocok dengan properti dilewati"
+"variable collections without modes were skipped" = "koleksi variabel tanpa mode dilewati"
+"variable mode lookups in prototype expressions that aren't a variable and one of its modes were skipped" = "pencarian mode variabel dalam ekspresi prototype yang bukan berupa variabel dan salah satu modenya dilewati"
+"variable modes of collections that aren't in the file were skipped" = "mode variabel dari koleksi yang tidak ada di file dilewati"
+"variable modes of collections that aren't in the variables JSON were skipped" = "mode variabel dari koleksi yang tidak ada di JSON variabel dilewati"
+"variable values that don't match their type (or composed colours) were skipped" = "nilai variabel yang tidak sesuai dengan tipenya (atau warna gabungan) dilewati"
+"variables of unknown types were skipped" = "variabel dengan tipe yang tidak dikenal dilewati"
+"variables whose collection isn't in the variables JSON were skipped" = "variabel yang koleksinya tidak ada di JSON variabel dilewati"
+"variables without readable values were skipped" = "variabel tanpa nilai yang dapat dibaca dilewati"
+"vector points with unknown stroke joins use the layer join" = "titik vector dengan sambungan stroke yang tidak dikenal memakai sambungan layer"
+"vectors without geometry are empty" = "vector tanpa geometri kosong"
+"vectors without geometry are empty (export the file JSON with geometry=paths)" = "vector tanpa geometri kosong (ekspor JSON file dengan geometry=paths)"
+"very long text was cut to 1,048,576 characters" = "teks yang sangat panjang dipotong menjadi 1.048.576 karakter"
+"very long vector paths were skipped" = "jalur vector yang sangat panjang dilewati"
+"video actions are not supported and were skipped" = "tindakan video tidak didukung dan dilewati"
+"video triggers are not supported and were skipped" = "pemicu video tidak didukung dan dilewati"
 "yesterday" = "kemarin"
 "{instances} in {files}" = "{instances} di {files}"
 "{language}: draft translation, waiting for a native speaker's review." = "{language}: terjemahan draf, menunggu tinjauan penutur asli."
@@ -1518,6 +1661,7 @@ status = "draft — needs native review"
 "{name} is forgotten on this computer; the file stays on {server}" = "{name} dilupakan di komputer ini; file tetap ada di {server}"
 "{name} is on the server." = "{name} ada di server."
 "{name} is spotlighting" = "{name} sedang spotlight"
+"{name} is too large to open in the browser (over 512 MB)." = "{name} terlalu besar untuk dibuka di browser (lebih dari 512 MB)."
 "{name}\nClick to apply to the selection" = "{name}\nKlik untuk menerapkan ke pilihan"
 "{name}\nDrag onto the canvas, or click to place in the middle of the view.\nHold Alt (Option) while dropping onto an instance to swap it." = "{name}\nSeret ke kanvas, atau klik untuk menaruh di tengah tampilan.\nTahan Alt (Option) saat melepas di atas instance untuk menukarnya."
 "{name} (from {library})" = "{name} (dari {library})"
@@ -1553,6 +1697,7 @@ status = "draft — needs native review"
 "{n} matches" = { other = "{n} kecocokan" }
 "{n} minutes ago" = { other = "{n} menit lalu" }
 "{n} months ago" = { other = "{n} bulan lalu" }
+"{n} more notes omitted from this report" = { other = "{n} catatan lainnya tidak dicantumkan dalam laporan ini" }
 "{n} of {total}" = "{n} dari {total}"
 "{n} people joined" = { other = "{n} orang bergabung" }
 "{n} preferred components" = { other = "{n} component pilihan" }
@@ -1612,7 +1757,17 @@ status = "draft — needs native review"
 "arrange.packH" = "Rapatkan horizontal"
 "arrange.packV" = "Rapatkan vertikal"
 "arrange.roundToPixels" = "Bulatkan ke piksel"
+"arrange.spacing" = "Spasi"
 "arrange.tidy" = "Rapikan"
+"board.connector" = "Konektor"
+"board.ink" = "Goresan spidol"
+"board.label" = "Label konektor"
+"board.nextSticky" = "Catatan tempel berikutnya"
+"board.setColor" = "Warna papan"
+"board.setStyle" = "Gaya papan"
+"board.shape" = "Bentuk dengan teks"
+"board.stamp" = "Stempel"
+"board.sticky" = "Catatan tempel"
 "bool.exclude" = "Kecualikan pilihan"
 "bool.flatten" = "Satukan boolean"
 "bool.intersect" = "Iriskan pilihan"
@@ -1712,6 +1867,7 @@ status = "draft — needs native review"
 "edit.duplicate" = "Duplikat"
 "edit.findReplace" = "Cari dan ganti"
 "edit.paste" = "Tempel"
+"edit.pasteDesignLayers" = "Tempel layer desain"
 "edit.pasteOver" = "Tempel di atas pilihan"
 "edit.pasteProperties" = "Tempel properti"
 "edit.pasteReplace" = "Tempel dan ganti"
@@ -1735,7 +1891,9 @@ status = "draft — needs native review"
 "file.exportLayers" = "Ekspor layer"
 "file.exportSvg" = "Ekspor pilihan sebagai SVG"
 "file.import" = "Impor"
+"file.moveTab" = "Pindahkan tab"
 "file.new" = "File desain baru"
+"file.newBoard" = "Papan baru"
 "file.newFromTemplate" = "Baru dari templat"
 "file.open" = "Buka"
 "file.openRecent" = "Buka terbaru"
@@ -1918,6 +2076,10 @@ status = "draft — needs native review"
 "select.sameStroke" = "Pilih stroke yang sama"
 "select.sameText" = "Pilih properti teks yang sama"
 "select.set" = "Pilih"
+"selection.applyColorStyle" = "Terapkan gaya warna ke pilihan"
+"selection.colors" = "Warna pilihan"
+"selection.selectColor" = "Pilih layer dengan warna ini"
+"selection.setPaint" = "Ubah warna pilihan"
 "shape.arrow" = "Panah"
 "shape.ellipse" = "Elips"
 "shape.line" = "Garis"
@@ -1998,10 +2160,14 @@ status = "draft — needs native review"
 "text.weightUp" = "Tambah ketebalan font"
 "tool.arrow" = "Panah"
 "tool.comment" = "Komentar"
+"tool.connector" = "Konektor"
 "tool.ellipse" = "Elips"
+"tool.eraser" = "Penghapus"
 "tool.frame" = "Frame"
 "tool.hand" = "Tangan"
+"tool.highlighter" = "Stabilo"
 "tool.line" = "Garis"
+"tool.marker" = "Spidol"
 "tool.move" = "Pindahkan"
 "tool.pen" = "Pena"
 "tool.pencil" = "Pensil"
@@ -2013,9 +2179,12 @@ status = "draft — needs native review"
 "tool.scaleAnchor" = "Titik acuan skala"
 "tool.section" = "Section"
 "tool.set" = "Pilih alat"
+"tool.shape" = "Bentuk"
 "tool.shapeBuilder" = "Shape builder"
 "tool.slice" = "Slice"
+"tool.stamp" = "Stempel"
 "tool.star" = "Bintang"
+"tool.sticky" = "Catatan tempel"
 "tool.text" = "Teks"
 "transform.move" = "Pindahkan"
 "transform.moveTo" = "Pindahkan ke"
@@ -2077,11 +2246,13 @@ status = "draft — needs native review"
 "vector.edit.tool" = "Alat edit vector"
 "vector.edit.transform" = "Transformasi titik"
 "vector.edit.widthPoint" = "Titik lebar"
+"vector.fillRule" = "Atur aturan isian"
 "vector.flatten" = "Satukan"
 "vector.join" = "Gabungkan pilihan"
 "vector.offset" = "Offset path"
 "vector.outlineStroke" = "Outline stroke"
 "vector.reverse" = "Balik arah path"
+"vector.reverseLoop" = "Balik loop"
 "vector.simplify" = "Sederhanakan vector"
 "vector.smoothJoin" = "Gabungkan pilihan dengan halus"
 "version.autosave" = "Simpan versi otomatis"
diff --git a/crates/ui-egui/locales/ja.toml b/crates/ui-egui/locales/ja.toml
index 4d4d6d340..d7ee7287f 100644
--- a/crates/ui-egui/locales/ja.toml
+++ b/crates/ui-egui/locales/ja.toml
@@ -19,6 +19,7 @@ status = "draft — needs native review"
 "1…9, 0" = "1…9, 0"
 "@{login}: {prs} PRs, {commits} commits, +{added} / −{deleted} lines (Δ {delta}), +{bin_added} / −{bin_deleted} binary assets, {first} – {last}" = "@{login}：PR {prs} 件、コミット {commits} 件、+{added} / −{deleted} 行（Δ {delta}）、バイナリアセット +{bin_added} / −{bin_deleted}、{first} – {last}"
 "A collection of this file with these modes and variables: override their values per mode and add variables of its own" = "このファイルのコレクションとそのモード・変数：モードごとに値を上書きし、独自の変数を追加できる"
+"A .figcraft file with this name already exists. Choose its full name to confirm replacement." = "この名前の .figcraft ファイルは既に存在します。置き換えるには、拡張子まで含む名前を選択。"
 "A layer on its own aligns to its frame: select more layers, or one in a frame" = "単独のレイヤーはフレームに整列します：レイヤーを追加で選択するか、フレーム内のレイヤーを選択"
 "A responsive product page: hero, features, figures, a quote and a footer" = "レスポンシブな製品ページ：ヒーロー、機能、数値、引用、フッター"
 "A spring plays until it settles: its mass, stiffness and damping set how long" = "スプリングは静止するまで再生。長さは質量・剛性・減衰で決まる"
@@ -125,6 +126,7 @@ status = "draft — needs native review"
 "Archived" = "アーカイブ済み"
 "Arrange" = "配置"
 "Arrow" = "矢印"
+"Arrow at the end" = "末端に矢印"
 "As typed" = "入力どおり"
 "Asking the server…" = "サーバーに問い合わせ中…"
 "Assets" = "アセット"
@@ -198,7 +200,9 @@ status = "draft — needs native review"
 "C or ⇧C" = "C または ⇧C"
 "CMYK colour" = "CMYK カラー"
 "Can view" = "閲覧可"
+"Check" = "チェック"
 "Checking the server…" = "サーバーを確認中…"
+"Chevron" = "シェブロン"
 "Clear from this list" = "このリストから消去"
 "Code or invite link" = "コードまたは招待リンク"
 "Color profile: {name}" = "カラープロファイル：{name}"
@@ -244,7 +248,6 @@ status = "draft — needs native review"
 "Close tab" = "タブを閉じる"
 "Close version history" = "バージョン履歴を閉じる"
 "Close when clicking outside" = "外側をクリックしたら閉じる"
-"Close without saving" = "保存せずに閉じる"
 "Code" = "コード"
 "Code syntax" = "コード構文"
 "Collapse" = "折りたたむ"
@@ -272,6 +275,8 @@ status = "draft — needs native review"
 "Commits" = "コミット"
 "Company" = "会社"
 "Compare changes" = "変更を比較"
+"Compare with" = "比較対象"
+"Compatibility notes" = "互換性に関する注記"
 "Completed" = "完了"
 "Component" = "コンポーネント"
 "Component name" = "コンポーネント名"
@@ -286,6 +291,7 @@ status = "draft — needs native review"
 "Connected" = "接続済み"
 "Connected to code: {from}" = "コードに接続済み：{from}"
 "Connection lost, reconnecting (attempt {attempt})…" = "接続が切断。再接続中（{attempt} 回目）…"
+"Connector" = "コネクタ"
 "Constrain proportions" = "縦横比を固定"
 "Constraints" = "制約"
 "Content" = "コンテンツ"
@@ -314,6 +320,7 @@ status = "draft — needs native review"
 "Corner radius" = "角の半径"
 "Corner smoothing" = "角のスムージング"
 "Couldn't reach {server}: showing what this computer remembers." = "{server} に接続できない：このコンピューターが覚えている内容を表示中。"
+"Couldn't read {name}." = "{name} を読み込めませんでした。"
 "Couldn't save automatically: {error}" = "自動保存できませんでした：{error}"
 "Count" = "数"
 "Create" = "作成"
@@ -338,6 +345,7 @@ status = "draft — needs native review"
 "Current version" = "現在のバージョン"
 "Cursor chat" = "カーソルチャット"
 "Custom" = "カスタム"
+"Custom size" = "カスタムサイズ"
 "Cut" = "カット"
 "Dark" = "ダーク"
 "Darken" = "比較（暗）"
@@ -371,6 +379,7 @@ status = "draft — needs native review"
 "Description" = "説明"
 "Description (optional)" = "説明（任意）"
 "Design" = "デザイン"
+"Design panel" = "デザインパネル"
 "Design system starter" = "デザインシステムの雛形"
 "Desktop" = "デスクトップ"
 "Destination" = "遷移先"
@@ -382,6 +391,7 @@ status = "draft — needs native review"
 "Detach variable" = "変数を切り離す"
 "Details" = "詳細"
 "Dev Mode" = "開発モード"
+"Dev Mode only inspects: switch to Design (Shift+D) to edit" = "開発モードは検査専用です。編集するにはデザイン (Shift+D) に切り替えてください"
 "Dev resources" = "開発リソース"
 "Development" = "開発"
 "Device" = "デバイス"
@@ -398,6 +408,7 @@ status = "draft — needs native review"
 "Distribute horizontal spacing" = "水平方向に等間隔に分布"
 "Distribute vertical spacing" = "垂直方向に等間隔に分布"
 "Divider" = "区切り線"
+"Don't Save" = "保存しない"
 "Don't truncate" = "切り詰めない"
 "Done" = "完了"
 "Done editing" = "編集を完了"
@@ -430,6 +441,7 @@ status = "draft — needs native review"
 "Effect settings" = "エフェクトの設定"
 "Effect styles" = "エフェクトスタイル"
 "Effects" = "エフェクト"
+"Elbow" = "直角"
 "Ellipse" = "楕円"
 "Ellipses" = "楕円"
 "Else" = "それ以外"
@@ -480,6 +492,7 @@ status = "draft — needs native review"
 "Feb" = "2月"
 "Fetching from the server…" = "サーバーから取得中…"
 "FigCraft couldn't open its window: {error}" = "FigCraft のウィンドウを開けなかった：{error}"
+"FigCraft doesn't support every feature of these files yet. The notes list what was left out or changed in the imported copy; the original file is unchanged." = "FigCraft はこれらのファイルの機能をまだすべてサポートしていない。注記には、インポートしたコピーで省略または変更された内容を示す。元のファイルは変更されない。"
 "File" = "ファイル"
 "File name" = "ファイル名"
 "File not found" = "ファイルが見つからない"
@@ -565,6 +578,7 @@ status = "draft — needs native review"
 "Hanging list" = "ぶら下げリスト"
 "Hanging punctuation" = "ぶら下げ句読点"
 "Hard light" = "ハードライト"
+"Heart" = "ハート"
 "Height" = "高さ"
 "Help" = "ヘルプ"
 "Help and resources" = "ヘルプとリソース"
@@ -577,6 +591,7 @@ status = "draft — needs native review"
 "Hide these tips (Getting started in the Help menu shows them again)" = "ヒントを非表示（ヘルプメニューの「使い始めるには」で再表示）"
 "Hide when publishing" = "公開時に非表示"
 "Highlight layers on hover" = "ホバー時にレイヤーをハイライト"
+"Highlighter" = "蛍光ペン"
 "Highlights" = "ハイライト"
 "Hold Alt" = "Alt を押したまま"
 "Hold Alt+Z" = "Alt+Z を押したまま"
@@ -604,11 +619,14 @@ status = "draft — needs native review"
 "If {condition}" = "条件：{condition}"
 "Ignore auto layout (absolute position)" = "オートレイアウトを無視（絶対位置）"
 "Image" = "画像"
+"Images" = "画像"
 "Import" = "インポート"
 "Import path" = "インポートパス"
 "Import plugin from manifest" = "マニフェストからプラグインをインポート"
 "Import plugin from manifest…" = "マニフェストからプラグインをインポート…"
+"Import report" = "インポートレポート"
 "Import variables" = "変数をインポート"
+"Imported document" = "インポートしたドキュメント"
 "Imported {name}" = "{name} をインポート済み"
 "Imported {n} new variables, updated {updated}" = { other = "新しい変数を {n} 個インポートし、{updated} 個を更新" }
 "Import…" = "インポート…"
@@ -636,11 +654,13 @@ status = "draft — needs native review"
 "Instance swap (no other component)" = "インスタンスの入れ替え（他のコンポーネントなし）"
 "Instances" = "インスタンス"
 "Instant" = "即時"
+"Intensity" = "強さ"
 "Interaction" = "インタラクション"
 "Interactions" = "インタラクション"
 "Interface design and prototyping. A free, open-source, clean-room design tool written from scratch in Rust, part of the ArtCraft Crafting Apps." = "インターフェースデザインとプロトタイピング。Rust でゼロから書かれた、無料でオープンソースのクリーンルーム設計のデザインツール。ArtCraft Crafting Apps の一つ。"
 "Intersect" = "交差"
 "Intersects" = "交差"
+"Invalid color" = "無効なカラー"
 "Invite link" = "招待リンク"
 "Invite link copied" = "招待リンクをコピー済み"
 "It asks permission to:" = "次の権限を求めている："
@@ -738,6 +758,7 @@ status = "draft — needs native review"
 "Mark as resolved" = "解決済みにする"
 "Mark as unread" = "未読にする"
 "Mark as unresolved" = "未解決にする"
+"Marker" = "マーカー"
 "Mask" = "マスク"
 "Mass · Stiffness · Damping" = "質量 · 剛性 · 減衰"
 "Match (empty: the whole name)" = "一致（空欄：名前全体）"
@@ -796,8 +817,10 @@ status = "draft — needs native review"
 "Named instance" = "名前付きインスタンス"
 "Navigate to" = "移動先"
 "Nested instance" = "ネストされたインスタンス"
+"New board" = "新規ボード"
 "New design file" = "新規デザインファイル"
 "Newest first" = "新しい順"
+"Next frame" = "次のフレーム"
 "Next or previous control in the focused region" = "フォーカス中の領域で次または前のコントロール"
 "Next ready for dev" = "次の開発準備完了"
 "Next size option" = "次のサイズオプション"
@@ -807,12 +830,15 @@ status = "draft — needs native review"
 "No branches. A branch is a copy of the file to try changes in, then review and merge." = "ブランチはない。ブランチはファイルのコピーで、変更を試してからレビューしてマージできる。"
 "No category" = "カテゴリなし"
 "No changes" = "変更なし"
+"No color styles" = "カラースタイルがありません"
 "No colour variables fit here." = "ここに使えるカラー変数はない。"
 "No colour variables yet. Create them in Local variables." = "カラー変数はまだない。ローカル変数で作成。"
 "No comments yet" = "コメントはまだない"
+"No compatibility warnings reported" = "互換性の警告はない"
 "No components yet. Select layers and press {keys}." = "コンポーネントはまだない。レイヤーを選択して {keys} を押す。"
 "No conflicts." = "競合なし。"
 "No contributor data was built into this copy." = "このコピーには貢献者データが含まれていない。"
+"No device" = "デバイスなし"
 "No fonts match" = "一致するフォントなし"
 "No join code here (the server is older than join codes, or this address can't be put in one): share the link instead." = "参加コードなし（サーバーが参加コードより古いか、このアドレスはコードにできない）：代わりにリンクを共有すること。"
 "No layer changes to show." = "表示するレイヤーの変更なし。"
@@ -856,6 +882,7 @@ status = "draft — needs native review"
 "Not read yet" = "未読"
 "Not shared" = "共有していない"
 "Note {n}" = "メモ {n}"
+"Nothing changed since this version." = "このバージョンから変更なし。"
 "Nothing changed since this was marked ready for dev." = "開発準備完了にしてから変更なし。"
 "Nothing here yet. Set a frame's status to list it." = "まだ何もない。フレームのステータスを設定すると一覧に表示される。"
 "Nothing online yet. Use Share on a file to put it online and it is listed here." = "オンラインのファイルはまだない。ファイルの「共有」からオンラインにすると、ここに表示される。"
@@ -893,6 +920,7 @@ status = "draft — needs native review"
 "Open branch" = "ブランチを開く"
 "Open file" = "ファイルを開く"
 "Open files" = "開いているファイル"
+"Open presentations" = "開いているプレゼンテーション"
 "Open in focus view" = "フォーカスビューで開く"
 "Open in new window" = "新しいウィンドウで開く"
 "Open invite links in FigCraft" = "招待リンクを FigCraft で開く"
@@ -901,6 +929,7 @@ status = "draft — needs native review"
 "Open overlay" = "オーバーレイを開く"
 "Open prototype preview" = "プロトタイプのプレビューを開く"
 "Open variables ({count})" = "変数を開く（{count}）"
+"Opened as a new document" = "新しいドキュメントとして開いた"
 "Opened “{name}” in a new tab" = "「{name}」を新しいタブで開いた"
 "Open|comments" = "未解決"
 "Options" = "オプション"
@@ -924,7 +953,11 @@ status = "draft — needs native review"
 "PDF print settings" = "PDF 印刷設定"
 "Padding" = "パディング"
 "Page" = "ページ"
+"Page deleted" = "ページは削除済み"
 "Pages" = "ページ"
+"Pages added to the document" = "ページをドキュメントに追加した"
+"Pink" = "ピンク"
+"Placed on the current page" = "現在のページに配置した"
 "Pages: {pages}" = "ページ：{pages}"
 "Paint bucket" = "塗りつぶし"
 "Pan the canvas" = "キャンバスをパン"
@@ -939,6 +972,7 @@ status = "draft — needs native review"
 "Paste a team library link (a view link)" = "チームライブラリのリンク（閲覧リンク）を貼り付け"
 "Paste here" = "ここに貼り付け"
 "Paste to replace" = "貼り付けて置換"
+"Pasted design layers; {n} kinds of content were left out" = { other = "デザインレイヤーを貼り付け済み。{n} 種類のコンテンツは含まれていない" }
 "Pattern" = "パターン"
 "Pattern alignment" = "パターンの配置"
 "Pattern scale" = "パターンの拡大縮小"
@@ -966,6 +1000,7 @@ status = "draft — needs native review"
 "Plugins run in FigCraft's sandbox, without files, network or clock. Install only plugins you trust." = "プラグインは FigCraft のサンドボックス内で、ファイル、ネットワーク、時計なしで実行される。信頼できるプラグインのみをインストールすること。"
 "Plus darker" = "プラス（暗）"
 "Plus lighter" = "プラス（明）"
+"Plus one" = "プラスワン"
 "Point" = "ポイント"
 "Points" = "ポイント"
 "Polygon" = "多角形"
@@ -992,6 +1027,7 @@ status = "draft — needs native review"
 "Preview" = "プレビュー"
 "Preview this flow" = "このフローをプレビュー"
 "Preview this frame" = "このフレームをプレビュー"
+"Previous frame" = "前のフレーム"
 "Previous ready for dev" = "前の開発準備完了"
 "Progressive" = "プログレッシブ"
 "Properties" = "プロパティ"
@@ -1012,6 +1048,7 @@ status = "draft — needs native review"
 "Push" = "プッシュ"
 "Push changes to main component" = "変更をメインコンポーネントにプッシュ"
 "Put text on path" = "テキストをパスに沿わせる"
+"Question" = "質問"
 "R" = "R"
 "Radial" = "放射状"
 "Radius" = "半径"
@@ -1057,6 +1094,7 @@ status = "draft — needs native review"
 "Removed" = "削除"
 "Removed from the server" = "サーバーから削除済み"
 "Removed since it was marked" = "マーク後に削除"
+"Removed since this version" = "このバージョン以降に削除"
 "Rename" = "名前を変更"
 "Rename duplicated layers" = "複製したレイヤーの名前を変更"
 "Rename folder" = "フォルダー名を変更"
@@ -1086,6 +1124,7 @@ status = "draft — needs native review"
 "Resize by the nudge amount" = "微調整の量でサイズ変更"
 "Resize frames to the device's screen (or the window without a device): their constraints and auto layout respond" = "フレームをデバイスの画面（デバイスなしの場合はウィンドウ）に合わせてサイズ変更：制約とオートレイアウトが反応"
 "Resize to fit" = "サイズを合わせる"
+"Resizing" = "サイズ変更"
 "Resolve" = "解決"
 "Resolve change" = "変更を解決"
 "Resolved" = "解決済み"
@@ -1111,6 +1150,7 @@ status = "draft — needs native review"
 "Rotation jitter" = "回転のばらつき"
 "Round" = "丸型"
 "Rounded" = "丸型"
+"Rounded rectangle" = "角丸長方形"
 "Row" = "行"
 "Row gap" = "行の間隔"
 "Row sizes" = "行のサイズ"
@@ -1160,12 +1200,14 @@ status = "draft — needs native review"
 "Select layer" = "レイヤーを選択"
 "Select layers and they space themselves as their content changes" = "レイヤーを選択すると、内容の変化に合わせて間隔を自動調整"
 "Select layers to apply the style to" = "スタイルを適用するレイヤーを選択"
+"Select layers with this color" = "このカラーのレイヤーを選択"
 "Select overlapping shapes" = "重なったシェイプを選択"
 "Select points to edit their position, radius and mirroring" = "ポイントを選択すると位置、半径、対称を編集できる"
 "Select slot" = "スロットを選択"
 "Selection" = "選択範囲"
 "Selection box, {w} by {h} at {x}, {y}: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "選択ボックス、{w} × {h}、位置 {x}, {y}：矢印キーで移動、Shift+矢印キーまたは {cmd}+矢印キーでサイズ変更、Enter で選択、Escape でキャンセル"
 "Selection box: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "選択ボックス：矢印キーで移動、Shift+矢印キーまたは {cmd}+矢印キーでサイズ変更、Enter で選択、Escape でキャンセル"
+"Selection colors" = "選択範囲のカラー"
 "Send backward" = "背面へ"
 "Send report" = "報告を送信"
 "Send to back" = "最背面へ"
@@ -1182,6 +1224,7 @@ status = "draft — needs native review"
 "Shape" = "シェイプ"
 "Shape builder" = "シェイプビルダー"
 "Shape tools" = "シェイプツール"
+"Shapes" = "シェイプ"
 "Share" = "共有"
 "Share this file" = "このファイルを共有"
 "Share with a code" = "コードで共有"
@@ -1248,10 +1291,13 @@ status = "draft — needs native review"
 "Space+drag" = "Space+ドラッグ"
 "Spacing" = "間隔"
 "Spam, stolen work, abuse…" = "スパム、盗用、迷惑行為…"
+"Speech bubble" = "吹き出し"
 "Splay" = "広がり"
 "Spotlight me" = "自分をスポットライト"
 "Spread" = "スプレッド"
 "Square" = "正方形"
+"Stamp" = "スタンプ"
+"Stamps" = "スタンプ"
 "Standard" = "標準"
 "Standard ligatures" = "標準合字"
 "Star" = "星"
@@ -1261,18 +1307,23 @@ status = "draft — needs native review"
 "Start from a blank canvas" = "空白のキャンバスから始める"
 "Start from a template" = "テンプレートから始める"
 "Start on path" = "パス上の開始位置"
+"Start on the Home screen" = "起動時にホームを表示"
 "Start point" = "始点"
 "Start sharing" = "共有を開始"
 "Start sharing with the Share button, then pass on the code it gives" = "共有ボタンで共有を開始し、表示されたコードを相手に伝える"
 "Starting to share…" = "共有を開始中…"
 "Status" = "ステータス"
 "Sticky" = "固定"
+"Sticky note" = "付箋"
+"Sticky note colors" = "付箋の色"
+"Sticky notes, shapes and connectors" = "付箋、シェイプ、コネクタ"
 "Stop" = "停止"
 "Stop following {name}" = "{name} のフォローを停止"
 "Stop session" = "セッションを停止"
 "Stop sharing" = "共有を停止"
 "Stop spotlighting" = "スポットライトを停止"
 "Stop {n}  {hex}" = "分岐点 {n}  {hex}"
+"Straight" = "直線"
 "Stretch" = "伸縮"
 "Strikethrough" = "取り消し線"
 "String" = "文字列"
@@ -1317,6 +1368,7 @@ status = "draft — needs native review"
 "Text" = "テキスト"
 "Text align" = "テキストの配置"
 "Text content" = "テキストの内容"
+"Text size" = "テキストサイズ"
 "Text style" = "テキストスタイル"
 "Text styles" = "テキストスタイル"
 "Texts" = "テキスト"
@@ -1347,6 +1399,9 @@ status = "draft — needs native review"
 "This server is open to the public: no key needed." = "このサーバーは一般公開されている：キーは不要。"
 "This server needs its key: add ?key=… to the address (`figcraft-server key` prints it on the server's machine)." = "このサーバーにはキーが必要：アドレスに ?key=… を追加（サーバーのマシンで `figcraft-server key` を実行すると表示）。"
 "This server takes files only with its key: see Advanced." = "このサーバーはキーがないとファイルを受け付けない：「詳細設定」を参照。"
+"Thumbs up" = "いいね"
+"This version can't be read." = "このバージョンを読み込めません。"
+"This version doesn't have it: all of it is new." = "このバージョンにはありません。すべて新規です。"
 "Tidy up" = "整列"
 "Tile" = "タイル"
 "Tile type" = "タイルの種類"
@@ -1363,6 +1418,7 @@ status = "draft — needs native review"
 "Top left radius" = "左上の半径"
 "Top right radius" = "右上の半径"
 "Transform" = "変形"
+"Triangle" = "三角形"
 "Triangle arrow" = "三角矢印"
 "Trigger" = "トリガー"
 "True" = "true"
@@ -1387,7 +1443,7 @@ status = "draft — needs native review"
 "Unread" = "未読"
 "Unresolve" = "未解決に戻す"
 "Unsaved changes" = "未保存の変更"
-"Unsaved changes in {names}. Close the window and lose them?" = "{names} に未保存の変更がある。ウィンドウを閉じて変更を破棄する？"
+"Unsaved changes in {names}. Save them before closing?" = "{names} に未保存の変更がある。閉じる前に保存する？"
 "Unsaved changes: save first ({save}), or close the tab with {alt}-click to discard" = "未保存の変更：先に保存する（{save}）か、{alt}-クリックでタブを閉じて破棄"
 "Unsaved changes: save first, or close again with {key} to discard" = "未保存の変更：先に保存するか、もう一度 {key} で閉じて破棄"
 "Up" = "上"
@@ -1406,6 +1462,7 @@ status = "draft — needs native review"
 "Use as mask" = "マスクとして使用"
 "Use auto layout" = "オートレイアウトを使用"
 "Use number keys for opacity" = "数字キーで不透明度を変更"
+"Use the .figcraft or .fig extension." = "拡張子は .figcraft または .fig を使用。"
 "Use the layer's fill" = "レイヤーの塗りを使用"
 "Used in {files} · {instances}" = "{files}で使用 · {instances}"
 "Username" = "ユーザー名"
@@ -1451,11 +1508,13 @@ status = "draft — needs native review"
 "Websites" = "Webサイト"
 "Wedge" = "くさび"
 "Weight" = "太さ"
+"What changed since a saved version" = "保存したバージョンからの変更"
 "What changed since it was marked ready for dev" = "開発準備完了にしてからの変更内容"
 "What is wrong with this file? The server's operator gets your report." = "このファイルの何が問題ですか？ 報告はサーバーの運営者に届く。"
 "What it's for" = "用途"
 "What this changed from isn't known: it changed before FigCraft kept a copy of ready-for-dev frames. Resolve the change (or mark it ready again) to compare from now on." = "変更前の状態は不明：FigCraft が開発準備完了フレームのコピーを保存するようになる前に変更された。変更を解決する（または再度準備完了にする）と、今後はそこから比較する。"
 "What you try here changes this preview and the code below, not the file" = "ここでの操作はプレビューと下のコードに反映。ファイルは変更されない"
+"When marked ready" = "準備完了にした時点"
 "While hovering" = "ホバー中"
 "While pressing" = "押している間"
 "White" = "白"
@@ -1499,26 +1558,119 @@ status = "draft — needs native review"
 "call any command its access allows" = "アクセス権で許可された任意のコマンドの呼び出し"
 "call only: {commands}" = "次のコマンドのみの呼び出し：{commands}"
 "can edit the document" = "ドキュメントを編集できる"
+"conditional prototype actions nested too deeply were skipped" = "入れ子が深すぎる条件付きプロトタイプアクションをスキップ"
+"conditional prototype actions with conditions that can't be evaluated were skipped" = "評価できない条件を持つ条件付きプロトタイプアクションをスキップ"
+"connector label background was skipped: style data is missing" = "コネクタラベルの背景をスキップ：スタイルデータがない"
+"connector label was skipped: background bounds are invalid" = "コネクタラベルをスキップ：背景の境界が無効"
+"connector label was skipped: background transform is invalid" = "コネクタラベルをスキップ：背景の変形が無効"
+"connector label was skipped: composed text transform is invalid" = "コネクタラベルをスキップ：合成したテキストの変形が無効"
+"connector label was skipped: derived background bounds are missing" = "コネクタラベルをスキップ：算出した背景の境界がない"
+"connector label was skipped: derived text bounds are missing" = "コネクタラベルをスキップ：算出したテキストの境界がない"
+"connector label was skipped: text bounds are invalid" = "コネクタラベルをスキップ：テキストの境界が無効"
+"connector label was skipped: text style data is missing" = "コネクタラベルをスキップ：テキストスタイルのデータがない"
+"connector label was skipped: text transform is invalid" = "コネクタラベルをスキップ：テキストの変形が無効"
+"connector labels were skipped" = "コネクタのラベルをスキップ"
+"connector layers import as static frame/vector snapshots with labels when present; live endpoint bindings are not retained" = "コネクタレイヤーは静的なフレーム／ベクターのスナップショットとして（ラベルがあればラベルも）インポート。端点の動的なバインドは保持しない"
+"connector snapshot vector data is missing; connector was left empty" = "コネクタのスナップショットのベクターデータがないため、コネクタは空のまま"
+"connectors whose ends can't be placed are empty" = "端点を配置できないコネクタは空"
 "crop marks" = "トンボ"
+"damaged vector geometry was skipped" = "破損したベクタージオメトリをスキップ"
+"damaged vector networks import as outlines" = "破損したベクターネットワークはアウトラインとしてインポート"
 "development: {path}" = "開発：{path}"
+"document children other than pages were skipped" = "ページ以外のドキュメントの子をスキップ"
+"duplicate grid track sizing entries use equal tracks" = "重複したグリッドトラックのサイズ指定は均等なトラックを使用"
 "e.g. count + 1" = "例：count + 1"
 "e.g. count >= 3 and not done" = "例：count >= 3 and not done"
+"elbowed and curved connectors without a saved path import as straight lines" = "保存されたパスのない折れ線・曲線コネクタは直線としてインポート"
+"entries without a node type were skipped" = "ノードタイプのない項目をスキップ"
 "figcraft:// links from a browser, chat or email open this app and join the session." = "ブラウザー、チャット、メールからの figcraft:// リンクでこのアプリが開き、セッションに参加する。"
+"filled areas of a vector with their own fill use the layer's fill" = "独自の塗りを持つベクターの塗りつぶし領域にはレイヤーの塗りを使用"
 "from {server}" = "{server} から"
+"gamepad triggers without exactly one known controller button were skipped" = "既知のコントローラーボタンがちょうど 1 つではないゲームパッドトリガーをスキップ"
+"grid track list exceeds 1000 entries; the tracks use the default equal sizing" = "グリッドトラックのリストが 1000 項目を超えるため、トラックはデフォルトの均等サイズを使用"
+"grid track sizing is unsupported or malformed; affected tracks use equal sizing" = "グリッドトラックのサイズ指定が未対応または不正なため、該当するトラックは均等サイズを使用"
+"grid track sizing list exceeds 1000 entries; the tracks use the default equal sizing" = "グリッドトラックのサイズ指定リストが 1000 項目を超えるため、トラックはデフォルトの均等サイズを使用"
 "hidden" = "非表示"
 "iOS" = "iOS"
+"image filters are ambiguous because both filter containers are present; filter conversion was skipped" = "両方のフィルターコンテナがあり画像フィルターが曖昧なため、フィルターの変換をスキップ"
+"image filters use FigCraft's approximate renderer" = "画像フィルターは FigCraft の近似レンダリングで描画"
+"instance swap properties whose default component isn't in the file were skipped" = "デフォルトのコンポーネントがファイルにないインスタンスの入れ替えプロパティをスキップ"
+"instances inside their own main component were imported as frames" = "自身のメインコンポーネント内にあるインスタンスはフレームとしてインポート"
+"instances of components that aren't in the file show no layers" = "ファイルにないコンポーネントのインスタンスにはレイヤーが表示されない"
+"instances of components that aren't in the file were imported as frames" = "ファイルにないコンポーネントのインスタンスはフレームとしてインポート"
+"instances that would nest a component inside itself were imported as frames" = "コンポーネントを自身の中に入れ子にしてしまうインスタンスはフレームとしてインポート"
+"instances without a main component were imported as empty frames" = "メインコンポーネントのないインスタンスは空のフレームとしてインポート"
+"invalid internal .fig text path data was ignored" = "無効な .fig 内部のパス上テキストのデータを無視した"
+"invalid or oversized vector networks import as outlines" = "無効または大きすぎるベクターネットワークはアウトラインとしてインポート"
+"invalid or oversized vector path data was skipped" = "無効または大きすぎるベクターパスデータをスキップ"
 "just now" = "たった今"
+"key triggers without a supported key were skipped" = "サポートされているキーのないキートリガーをスキップ"
+"key up triggers import as key presses" = "キーを離すトリガーはキー押下としてインポート"
+"layers without a position were placed at their parent's origin" = "位置のないレイヤーは親の原点に配置"
+"layers without a type were skipped" = "タイプのないレイヤーをスキップ"
+"legacy image filter container is unsupported; filter conversion was skipped" = "旧形式の画像フィルターコンテナは未対応のため、フィルターの変換をスキップ"
 "locked" = "ロック中"
+"malformed image filters container was skipped" = "不正な画像フィルターコンテナをスキップ"
+"malformed image paintFilter container was skipped" = "不正な画像の paintFilter コンテナをスキップ"
+"malformed slot content assignment was skipped" = "不正なスロットコンテンツの割り当てをスキップ"
 "no bleed" = "裁ち落としなし"
 "nobody else here yet" = "まだ他に誰もいない"
+"non-default slot settings are not represented and were skipped" = "デフォルト以外のスロット設定は再現できないためスキップ"
 "now" = "たった今"
 "or" = "または"
+"point stroke joins were preserved; dashed or variable-width strokes render with the layer join" = "ポイントごとの角の形状は保持した。破線や可変幅の線はレイヤーの角の形状で描画"
+"preferred slot component keys cannot be resolved to file nodes and were skipped" = "スロットの優先コンポーネントキーをファイル内のレイヤーに解決できないためスキップ"
+"prototype actions of unknown types were skipped" = "不明なタイプのプロトタイプアクションをスキップ"
+"prototype actions without a destination in the file were skipped" = "ファイル内に移動先のないプロトタイプアクションをスキップ"
+"prototype expressions on variables that aren't in the variables JSON were skipped" = "変数 JSON にない変数を使うプロトタイプの式をスキップ"
+"prototype expressions with unsupported functions were skipped" = "サポートされていない関数を使うプロトタイプの式をスキップ"
+"prototype interactions without supported actions were skipped" = "サポートされているアクションのないプロトタイプインタラクションをスキップ"
+"prototype navigations of unknown types were skipped" = "不明なタイプのプロトタイプナビゲーションをスキップ"
+"prototype transitions of unknown types play instantly" = "不明なタイプのプロトタイプトランジションは即時に再生"
+"prototype triggers of unknown types were skipped" = "不明なタイプのプロトタイプトリガーをスキップ"
 "put a widget on the canvas" = "キャンバスへのウィジェットの配置"
 "read and edit the document" = "ドキュメントの読み取りと編集"
 "read the document" = "ドキュメントの読み取り"
 "reads the document" = "ドキュメントを読み取る"
+"set-variable actions on variables that aren't in the variables JSON were skipped" = "変数 JSON にない変数に対する変数設定アクションをスキップ"
+"set-variable actions with values that can't be evaluated were skipped" = "評価できない値を持つ変数設定アクションをスキップ"
+"set-variable actions with values that don't fit the variable were skipped" = "変数に合わない値を持つ変数設定アクションをスキップ"
+"set-variable actions without a value were skipped" = "値のない変数設定アクションをスキップ"
+"set-variable-mode actions on collections or modes that aren't in the variables JSON were skipped" = "変数 JSON にないコレクションまたはモードに対する変数モード設定アクションをスキップ"
+"slot content assignment target is missing or is not slot content" = "スロットコンテンツの割り当て先がないか、スロットコンテンツではない"
+"slot content assignment uses the empty GUID sentinel and was skipped" = "スロットコンテンツの割り当てが空の GUID を番兵値として使用しているためスキップ"
+"some vector points refer to point settings missing from the file; they use the layer's joins and plain corners" = "一部のベクターポイントがファイルにないポイント設定を参照している。それらのポイントはレイヤーの角の形状と丸めのない角を使用"
+"some vector segments refer to style settings missing from the file; they use the layer's stroke" = "一部のベクターセグメントがファイルにないスタイル設定を参照している。それらのセグメントはレイヤーの線を使用"
+"stale or invalid grid track sizing entries were ignored" = "古いまたは無効なグリッドトラックのサイズ指定を無視した"
+"stars and polygons without point counts or geometry use the default point count" = "ポイント数もジオメトリもない星と多角形はデフォルトのポイント数を使用"
+"style settings of some vector segments aren't supported; those segments use the layer's stroke" = "一部のベクターセグメントのスタイル設定は未対応。それらのセグメントはレイヤーの線を使用"
+"text path underline or strikethrough decoration is not rendered" = "パス上テキストの下線や取り消し線は描画しない"
+"text style overrides refer to missing table entries" = "テキストスタイルのオーバーライドが存在しないテーブル項目を参照している"
+"the file has no pages" = "ファイルにページがない"
 "the plugin" = "このプラグイン"
+"the variables JSON has no `variableCollections` (expected the local variables response) and was ignored" = "変数 JSON に `variableCollections` がない（ローカル変数のレスポンスを想定）ため無視した"
 "this session only" = "このセッションのみ"
+"unknown component property types were skipped" = "不明なタイプのコンポーネントプロパティをスキップ"
+"variable aliases to variables that aren't in the variables JSON (or of another type) were skipped" = "変数 JSON にない（または型が異なる）変数へのエイリアスをスキップ"
+"variable bindings to properties the layer doesn't have were skipped" = "レイヤーにないプロパティへの変数バインディングをスキップ"
+"variable bindings to variables that aren't in the variables JSON (library variables) were skipped" = "変数 JSON にない変数（ライブラリ変数）へのバインディングをスキップ"
+"variable bindings were skipped: the file JSON has no variable definitions (pass the local variables JSON as `variables`, or embed its `meta` next to the file JSON)" = "変数バインディングをスキップ：ファイル JSON に変数の定義がない（ローカル変数 JSON を `variables` として渡すか、その `meta` をファイル JSON の隣に埋め込む）"
+"variable bindings whose variable type doesn't fit the property were skipped" = "変数の型がプロパティに合わない変数バインディングをスキップ"
+"variable collections without modes were skipped" = "モードのない変数コレクションをスキップ"
+"variable mode lookups in prototype expressions that aren't a variable and one of its modes were skipped" = "変数とそのモードの 1 つになっていない、プロトタイプの式内の変数モード参照をスキップ"
+"variable modes of collections that aren't in the file were skipped" = "ファイルにないコレクションの変数モードをスキップ"
+"variable modes of collections that aren't in the variables JSON were skipped" = "変数 JSON にないコレクションの変数モードをスキップ"
+"variable values that don't match their type (or composed colours) were skipped" = "型に合わない変数値（または合成カラー）をスキップ"
+"variables of unknown types were skipped" = "不明なタイプの変数をスキップ"
+"variables whose collection isn't in the variables JSON were skipped" = "コレクションが変数 JSON にない変数をスキップ"
+"variables without readable values were skipped" = "読み取れる値のない変数をスキップ"
+"vector points with unknown stroke joins use the layer join" = "不明な角の形状を持つベクターポイントはレイヤーの角の形状を使用"
+"vectors without geometry are empty" = "ジオメトリのないベクターは空"
+"vectors without geometry are empty (export the file JSON with geometry=paths)" = "ジオメトリのないベクターは空（geometry=paths を指定してファイル JSON を書き出す）"
+"very long text was cut to 1,048,576 characters" = "非常に長いテキストを 1,048,576 文字に切り詰めた"
+"very long vector paths were skipped" = "非常に長いベクターパスをスキップ"
+"video actions are not supported and were skipped" = "ビデオアクションはサポートされていないためスキップ"
+"video triggers are not supported and were skipped" = "ビデオトリガーはサポートされていないためスキップ"
 "yesterday" = "昨日"
 "{instances} in {files}" = "{files}内の{instances}"
 "{language}: draft translation, waiting for a native speaker's review." = "{language}：下書きの翻訳。ネイティブスピーカーによるレビュー待ち。"
@@ -1535,6 +1687,7 @@ status = "draft — needs native review"
 "{name} is forgotten on this computer; the file stays on {server}" = "{name} の記録をこのコンピューターから消去済み。ファイルは {server} に残る"
 "{name} is on the server." = "{name} はサーバーにある。"
 "{name} is spotlighting" = "{name} がスポットライト中"
+"{name} is too large to open in the browser (over 512 MB)." = "{name} は大きすぎるため、ブラウザーで開けません（512 MB 超）。"
 "{name} was removed from the server" = "{name} をサーバーから削除済み"
 "{name} · deleted on main" = "{name} · メインで削除"
 "{name} · deleted on the branch" = "{name} · ブランチで削除"
@@ -1563,6 +1716,7 @@ status = "draft — needs native review"
 "{n} matches" = { other = "{n} 件一致" }
 "{n} minutes ago" = { other = "{n} 分前" }
 "{n} months ago" = { other = "{n} か月前" }
+"{n} more notes omitted from this report" = { other = "このレポートで省略した注記がさらに {n} 件" }
 "{n} of {total}" = "{n} / {total}"
 "{n} people joined" = { other = "{n} 人が参加済み" }
 "{n} preferred components" = { other = "優先コンポーネント {n} 個" }
@@ -1622,7 +1776,17 @@ status = "draft — needs native review"
 "arrange.packH" = "水平方向に詰める"
 "arrange.packV" = "垂直方向に詰める"
 "arrange.roundToPixels" = "ピクセルに丸める"
+"arrange.spacing" = "間隔"
 "arrange.tidy" = "整列"
+"board.connector" = "コネクタ"
+"board.ink" = "マーカーの線"
+"board.label" = "コネクタのラベル"
+"board.nextSticky" = "次の付箋"
+"board.setColor" = "ボードの色"
+"board.setStyle" = "ボードのスタイル"
+"board.shape" = "テキスト付きシェイプ"
+"board.stamp" = "スタンプ"
+"board.sticky" = "付箋"
 "bool.exclude" = "選択範囲を除外"
 "bool.flatten" = "ブーリアンを平坦化"
 "bool.intersect" = "選択範囲を交差"
@@ -1723,6 +1887,7 @@ status = "draft — needs native review"
 "edit.duplicate" = "複製"
 "edit.findReplace" = "検索と置換"
 "edit.paste" = "貼り付け"
+"edit.pasteDesignLayers" = "デザインレイヤーを貼り付け"
 "edit.pasteOver" = "選択範囲の上に貼り付け"
 "edit.pasteProperties" = "プロパティを貼り付け"
 "edit.pasteReplace" = "貼り付けて置換"
@@ -1746,7 +1911,9 @@ status = "draft — needs native review"
 "file.exportLayers" = "レイヤーを書き出し"
 "file.exportSvg" = "選択範囲を SVG で書き出し"
 "file.import" = "インポート"
+"file.moveTab" = "タブを移動"
 "file.new" = "新規デザインファイル"
+"file.newBoard" = "新規ボード"
 "file.newFromTemplate" = "テンプレートから新規作成"
 "file.open" = "開く"
 "file.openRecent" = "最近使ったファイルを開く"
@@ -1887,6 +2054,7 @@ status = "draft — needs native review"
 "pref.reduceMotion" = "動きを減らす"
 "pref.renameDuplicates" = "複製したレイヤーの名前を変更"
 "pref.showDimensions" = "オブジェクトに寸法を表示"
+"pref.startOnHome" = "起動時にホームを表示"
 "pref.userName" = "コメントに表示する名前"
 "proto.action.add" = "プロトタイプのアクションを追加"
 "proto.action.move" = "プロトタイプのアクションの順序を変更"
@@ -1930,6 +2098,10 @@ status = "draft — needs native review"
 "select.sameStroke" = "同じ線を選択"
 "select.sameText" = "同じテキストプロパティを選択"
 "select.set" = "選択"
+"selection.applyColorStyle" = "選択範囲にカラースタイルを適用"
+"selection.colors" = "選択範囲のカラー"
+"selection.selectColor" = "このカラーのレイヤーを選択"
+"selection.setPaint" = "選択範囲のカラーを変更"
 "shape.arrow" = "矢印"
 "shape.ellipse" = "楕円"
 "shape.line" = "線"
@@ -2011,10 +2183,14 @@ status = "draft — needs native review"
 "text.weightUp" = "フォントの太さを太く"
 "tool.arrow" = "矢印"
 "tool.comment" = "コメント"
+"tool.connector" = "コネクタ"
 "tool.ellipse" = "楕円"
+"tool.eraser" = "消しゴム"
 "tool.frame" = "フレーム"
 "tool.hand" = "手のひら"
+"tool.highlighter" = "蛍光ペン"
 "tool.line" = "線"
+"tool.marker" = "マーカー"
 "tool.move" = "移動"
 "tool.pen" = "ペン"
 "tool.pencil" = "鉛筆"
@@ -2026,9 +2202,12 @@ status = "draft — needs native review"
 "tool.scaleAnchor" = "拡大縮小の基準点"
 "tool.section" = "セクション"
 "tool.set" = "ツールを選択"
+"tool.shape" = "シェイプ"
 "tool.shapeBuilder" = "シェイプビルダー"
 "tool.slice" = "スライス"
+"tool.stamp" = "スタンプ"
 "tool.star" = "星"
+"tool.sticky" = "付箋"
 "tool.text" = "テキスト"
 "transform.move" = "移動"
 "transform.moveTo" = "指定位置へ移動"
@@ -2090,11 +2269,13 @@ status = "draft — needs native review"
 "vector.edit.tool" = "ベクター編集ツール"
 "vector.edit.transform" = "ポイントを変形"
 "vector.edit.widthPoint" = "幅のポイント"
+"vector.fillRule" = "塗りつぶし規則を設定"
 "vector.flatten" = "平坦化"
 "vector.join" = "選択範囲を連結"
 "vector.offset" = "パスのオフセット"
 "vector.outlineStroke" = "線のアウトライン化"
 "vector.reverse" = "パスの方向を反転"
+"vector.reverseLoop" = "ループを反転"
 "vector.simplify" = "ベクターを単純化"
 "vector.smoothJoin" = "選択範囲を滑らかに連結"
 "version.autosave" = "自動保存バージョン"
diff --git a/crates/ui-egui/locales/ka.toml b/crates/ui-egui/locales/ka.toml
new file mode 100644
index 000000000..42f78be6d
--- /dev/null
+++ b/crates/ui-egui/locales/ka.toml
@@ -0,0 +1,2387 @@
+# FigCraft interface strings: Georgian.
+#
+# Written with AI assistance (Claude) from the meaning of each English string, following the glossary
+# the Craft apps share, and reviewed by a native Georgian speaker; kept as a draft until a maintainer
+# changes its status. Brand names and keyboard glyphs stay as they are. Georgian has no letter case,
+# and a noun after a numeral stays singular, so counts read "შრე: {n}" and plural entries give the
+# same text for one and other. See docs/translating.md.
+
+[meta]
+name = "ქართული"
+status = "draft — reviewed by a native speaker, awaiting a maintainer's approval"
+
+[ui]
+"% of all commits" = "ყველა კომიტის %"
+"(no longer published)" = "(აღარ არის გამოქვეყნებული)"
+"({n} warnings: some entries were skipped)" = { one = "(გაფრთხილება: {n}; ზოგი ჩანაწერი გამოტოვებულია)", other = "(გაფრთხილება: {n}; ზოგი ჩანაწერი გამოტოვებულია)" }
+"+ Create variable" = "+ ცვლადის შექმნა"
+".fig (experimental)" = ".fig (ექსპერიმენტული)"
+"1…9, 0" = "1…9, 0"
+"@{login}: {prs} PRs, {commits} commits, +{added} / −{deleted} lines (Δ {delta}), +{bin_added} / −{bin_deleted} binary assets, {first} – {last}" = "@{login}: PR: {prs}, კომიტი: {commits}, +{added} / −{deleted} სტრიქონი (Δ {delta}), +{bin_added} / −{bin_deleted} ბინარული რესურსი, {first} – {last}"
+"A collection of this file with these modes and variables: override their values per mode and add variables of its own" = "ამ ფაილის კოლექცია ამ რეჟიმებითა და ცვლადებით: შეცვალეთ მათი მნიშვნელობები თითოეული რეჟიმისთვის და დაამატეთ საკუთარი ცვლადები"
+"A .figcraft file with this name already exists. Choose its full name to confirm replacement." = "ამ სახელით .figcraft ფაილი უკვე არსებობს. ჩანაცვლების დასადასტურებლად აირჩიეთ მისი სრული სახელი."
+"A layer on its own aligns to its frame: select more layers, or one in a frame" = "ცალკე შრე თავის ჩარჩოსთან სწორდება: მონიშნეთ მეტი შრე ან ჩარჩოში მყოფი შრე"
+"A responsive product page: hero, features, figures, a quote and a footer" = "პროდუქტის ადაპტური გვერდი: მთავარი ბლოკი, შესაძლებლობები, ციფრები, ციტატა და ქვედა ზოლი"
+"A spring plays until it settles: its mass, stiffness and damping set how long" = "ზამბარა მოძრაობს, სანამ არ დამშვიდდება: მისი მასა, სიხისტე და მილევა განსაზღვრავს ხანგრძლივობას"
+"A title, an agenda, a big figure, a chart and a closing slide" = "სათაური, დღის წესრიგი, დიდი ციფრი, დიაგრამა და დასკვნითი სლაიდი"
+"A to Z" = "ა-დან ჰ-მდე"
+"About" = "პროგრამის შესახებ"
+"About FigCraft" = "FigCraft-ის შესახებ"
+"About this server" = "ამ სერვერის შესახებ"
+"Action" = "მოქმედება"
+"Actions" = "მოქმედებები"
+"Actions for {name}" = "მოქმედებები: {name}"
+"Actions…" = "მოქმედებები…"
+"Active" = "აქტიური"
+"Actual size (100%)" = "რეალური ზომა (100%)"
+"Add a category" = "კატეგორიის დამატება"
+"Add a comment" = "კომენტარის დამატება"
+"Add a description" = "აღწერის დამატება"
+"Add a frame (F) or a shape (R) to get started" = "დასაწყებად დაამატეთ ჩარჩო (F) ან ფიგურა (R)"
+"Add a layer or component to tile first" = "ჯერ დაამატეთ შრე ან კომპონენტი ფილებად დასაწყობად"
+"Add a note for developers" = "შენიშვნის დამატება დეველოპერებისთვის"
+"Add action" = "მოქმედების დამატება"
+"Add actions for when no condition holds" = "მოქმედებების დამატება იმ შემთხვევისთვის, როცა არცერთი პირობა არ სრულდება"
+"Add an annotation for developers" = "ანოტაციის დამატება დეველოპერებისთვის"
+"Add another condition" = "კიდევ ერთი პირობის დამატება"
+"Add auto layout" = "ავტოგანლაგების დამატება"
+"Add background behind overlay" = "ფონის დამატება გადაფარვის უკან"
+"Add content to this slot" = "შიგთავსის დამატება ამ სლოტში"
+"Add dev resource" = "დეველოპერის რესურსის დამატება"
+"Add effect" = "ეფექტის დამატება"
+"Add export setting" = "ექსპორტის პარამეტრის დამატება"
+"Add fill" = "შევსების დამატება"
+"Add interaction" = "ურთიერთქმედების დამატება"
+"Add layout grid" = "განლაგების ბადის დამატება"
+"Add library" = "ბიბლიოთეკის დამატება"
+"Add library file…" = "ბიბლიოთეკის ფაილის დამატება…"
+"Add max height" = "მაქსიმალური სიმაღლის დამატება"
+"Add max width" = "მაქსიმალური სიგანის დამატება"
+"Add min height" = "მინიმალური სიმაღლის დამატება"
+"Add min width" = "მინიმალური სიგანის დამატება"
+"Add mode" = "რეჟიმის დამატება"
+"Add new page" = "ახალი გვერდის დამატება"
+"Add or update collections from a variables JSON" = "კოლექციების დამატება ან განახლება ცვლადების JSON-იდან"
+"Add properties to make instances configurable" = "დაამატეთ თვისებები, რომ ინსტანსები კონფიგურირებადი გახდეს"
+"Add reaction" = "რეაქციის დამატება"
+"Add starting point" = "საწყისი წერტილის დამატება"
+"Add stroke" = "კონტურის დამატება"
+"Add variant" = "ვარიანტის დამატება"
+"Add variant with a new value" = "ვარიანტის დამატება ახალი მნიშვნელობით"
+"Added" = "დამატებულია"
+"Added the library \"{name}\"" = "ბიბლიოთეკა „{name}“ დამატებულია"
+"Adding to {name}" = "დამატება: {name}"
+"Adjust" = "კორექცია"
+"Adjustment presets" = "კორექციის პრესეტები"
+"Advanced" = "დამატებითი"
+"Advanced stroke" = "კონტურის დამატებითი პარამეტრები"
+"After delay" = "დაყოვნების შემდეგ"
+"After delay {ms}ms" = "დაყოვნების შემდეგ: {ms} მწმ"
+"Align" = "სწორება"
+"Align bottom" = "ქვემოთ სწორება"
+"Align center" = "ცენტრში სწორება"
+"Align horizontal centers" = "ჰორიზონტალური ცენტრების სწორება"
+"Align left" = "მარცხნივ სწორება"
+"Align middle" = "შუაში სწორება"
+"Align right" = "მარჯვნივ სწორება"
+"Align text baselines" = "ტექსტის საბაზისო ხაზების სწორება"
+"Align top" = "ზემოთ სწორება"
+"Align vertical centers" = "ვერტიკალური ცენტრების სწორება"
+"Alignment" = "სწორება"
+"All" = "ყველა"
+"All categories" = "ყველა კატეგორია"
+"All comments" = "ყველა კომენტარი"
+"All components" = "ყველა კომპონენტი"
+"All fonts" = "ყველა შრიფტი"
+"All supported properties" = "ყველა მხარდაჭერილი თვისება"
+"All the fonts this file uses are installed" = "ამ ფაილის ყველა შრიფტი დაინსტალირებულია"
+"All variables" = "ყველა ცვლადი"
+"Alpha" = "ალფა"
+"Alphabetical" = "ანბანის მიხედვით"
+"Alt+drag" = "Alt+გადათრევა"
+"An analytics screen on a grid: figures, charts drawn from vectors and a table" = "ანალიტიკის ეკრანი ბადეზე: ციფრები, ვექტორებით დახატული დიაგრამები და ცხრილი"
+"An invite link that opens FigCraft and joins" = "მოსაწვევი ბმული, რომელიც ხსნის FigCraft-ს და უერთდება სესიას"
+"Anchor" = "საყრდენი"
+"Android" = "Android"
+"Angular" = "კუთხური"
+"Animation" = "ანიმაცია"
+"Annotations" = "ანოტაციები"
+"Annotations shown on the canvas" = "ტილოზე ნაჩვენები ანოტაციები"
+"Another server, or one that needs its key. The usual server is set in Preferences." = "სხვა სერვერი ან სერვერი, რომელსაც გასაღები სჭირდება. ჩვეულებრივი სერვერი პარამეტრებში ირჩევა."
+"Any status" = "ნებისმიერი სტატუსი"
+"Anyone on your network with this code can edit the file, while this app stays open." = "თქვენს ქსელში ნებისმიერს, ვისაც ეს კოდი აქვს, შეუძლია ფაილის რედაქტირება, სანამ ეს აპი ღიაა."
+"Anyone with the edit link can change the file; the view link only lets people look. The links carry their secrets: share them like passwords. `figcraft-server links` makes more and revokes them." = "რედაქტირების ბმულის მქონე ნებისმიერს შეუძლია ფაილის შეცვლა; ნახვის ბმული მხოლოდ დათვალიერების საშუალებას იძლევა. ბმულები საიდუმლო გასაღებებს შეიცავს: გააზიარეთ ისინი პაროლების მსგავსად. `figcraft-server links` ქმნის ახალ ბმულებს და აუქმებს მათ."
+"Anyone with this code can edit the file." = "ნებისმიერს, ვისაც ეს კოდი აქვს, შეუძლია ფაილის რედაქტირება."
+"Anyone with this code can look at the file, not change it." = "ნებისმიერს, ვისაც ეს კოდი აქვს, შეუძლია ფაილის ნახვა, მაგრამ არა შეცვლა."
+"Appearance" = "იერსახე"
+"Apply a component property" = "კომპონენტის თვისების გამოყენება"
+"Apply variable" = "ცვლადის გამოყენება"
+"Apply variable to text" = "ცვლადის გამოყენება ტექსტზე"
+"Apply variable to visibility" = "ცვლადის გამოყენება ხილვადობაზე"
+"Apps" = "აპები"
+"Apr" = "აპრ"
+"Arc" = "რკალი"
+"Arc ratio" = "რკალის თანაფარდობა"
+"Arc start" = "რკალის დასაწყისი"
+"Arc sweep" = "რკალის სიგრძე"
+"Archive" = "დაარქივება"
+"Archived" = "დაარქივებულია"
+"Arrange" = "დალაგება"
+"Arrow" = "ისარი"
+"Arrow at the end" = "ისარი ბოლოში"
+"As typed" = "როგორც აიკრიფა"
+"Asking the server…" = "სერვერთან მოთხოვნა…"
+"Assets" = "რესურსები"
+"Aug" = "აგვ"
+"Auto" = "ავტომატური"
+"Auto (space around)" = "ავტო (დაშორება გარშემო)"
+"Auto (space between)" = "ავტო (დაშორება შორის)"
+"Auto (space evenly)" = "ავტო (თანაბარი დაშორება)"
+"Auto ({mode})" = "ავტო ({mode})"
+"Auto columns" = "ავტომატური სვეტები"
+"Auto gap" = "ავტომატური შუალედი"
+"Auto height" = "ავტომატური სიმაღლე"
+"Auto layout" = "ავტოგანლაგება"
+"Auto rows" = "ავტომატური სტრიქონები"
+"Auto width" = "ავტომატური სიგანე"
+"Back to the FigCraft server" = "FigCraft-ის სერვერზე დაბრუნება"
+"Back to the font's value" = "შრიფტის მნიშვნელობაზე დაბრუნება"
+"Back" = "უკან"
+"Back to Ready for dev" = "„მზადაა დეველოპერისთვის“ სტატუსზე დაბრუნება"
+"Back to Ready for dev: the next change compares with how it is now" = "„მზადაა დეველოპერისთვის“ სტატუსზე დაბრუნება: შემდეგი ცვლილება შედარდება ამჟამინდელ მდგომარეობას"
+"Back to assets" = "რესურსებზე დაბრუნება"
+"Back to current" = "მიმდინარეზე დაბრუნება"
+"Back to styles" = "სტილებზე დაბრუნება"
+"Back to the canvas from a focused region" = "ფოკუსირებული არიდან ტილოზე დაბრუნება"
+"Back to the current version" = "მიმდინარე ვერსიაზე დაბრუნება"
+"Back to the values the font style implies" = "შრიფტის სტილით განსაზღვრულ მნიშვნელობებზე დაბრუნება"
+"Background" = "ფონი"
+"Background blur" = "ფონის გაბუნდოვნება"
+"Basics" = "საფუძვლები"
+"Before" = "მანამდე"
+"Bend" = "მოხრა"
+"Bevel" = "წაკვეთილი"
+"Binary assets added" = "დამატებული ბინარული ფაილები"
+"Binary assets removed" = "წაშლილი ბინარული ფაილები"
+"Black & white" = "შავ-თეთრი"
+"Bleed" = "ჭრისპირა არე"
+"Bleed marks" = "ჭრისპირა არის ნიშნები"
+"Bleed marks need a bleed" = "ჭრისპირა არის ნიშნებს ჭრისპირა არე სჭირდება"
+"Blend" = "შერევა"
+"Blend mode" = "შერევის რეჟიმი"
+"Blue" = "ლურჯი"
+"Blur" = "გაბუნდოვნება"
+"Boolean" = "ლოგიკური"
+"Boolean groups" = "ლოგიკური ოპერაციების ჯგუფები"
+"Both directions" = "ორივე მიმართულება"
+"Bottom" = "ქვემოთ"
+"Bottom left radius" = "ქვედა მარცხენა რადიუსი"
+"Bottom right radius" = "ქვედა მარჯვენა რადიუსი"
+"Branch" = "განშტოება"
+"Branch archived" = "განშტოება დაარქივებულია"
+"Branch merged" = "განშტოება შერწყმულია"
+"Branch name" = "განშტოების სახელი"
+"Branch of {file}" = "{file}-ის განშტოება"
+"Branch of {file} · merged or archived" = "{file}-ის განშტოება · შერწყმული ან დაარქივებული"
+"Branch updated from main" = "განშტოება განახლდა მთავარიდან"
+"Branch {name}" = "განშტოება {name}"
+"Branches" = "განშტოებები"
+"Bound to {name}. Click to detach the variable." = "მიბმულია: {name}. დაწკაპეთ ცვლადის მოსაწყვეტად."
+"Bring forward" = "წინ გადმოტანა"
+"Bring the main file's changes into the branch" = "მთავარი ფაილის ცვლილებების განშტოებაში გადმოტანა"
+"Bring to front" = "წინა პლანზე გადმოტანა"
+"Bristle" = "ჯაგრისი"
+"Browse" = "დათვალიერება"
+"Brush" = "ფუნჯი"
+"Brush rotation jitter" = "ფუნჯის შემობრუნების ცვალებადობა"
+"Brush scatter" = "ფუნჯის გაბნევა"
+"Brush size jitter" = "ფუნჯის ზომის ცვალებადობა"
+"Brush spacing" = "ფუნჯის ბიჯი"
+"Bulleted list" = "ბურთულებიანი სია"
+"C or Shift+C" = "C ან Shift+C"
+"C or ⇧C" = "C ან ⇧C"
+"CMYK colour" = "CMYK ფერი"
+"Can view" = "შეუძლია ნახვა"
+"Check" = "ნიშნული"
+"Checking the fonts installed on this computer…" = "ამ კომპიუტერზე დაინსტალირებული შრიფტების შემოწმება…"
+"Checking the server…" = "სერვერის შემოწმება…"
+"Chevron" = "შევრონი"
+"Clear from this list" = "ამ სიიდან ამოღება"
+"Code or invite link" = "კოდი ან მოსაწვევი ბმული"
+"Color profile: {name}" = "ფერის პროფილი: {name}"
+"Colour and text styles, Light and Dark variables, buttons, inputs and cards" = "ფერისა და ტექსტის სტილები, ღია და მუქი ცვლადები, ღილაკები, შეყვანის ველები და ბარათები"
+"Connector" = "შემაერთებელი"
+"Convert to frame" = "ჩარჩოდ გარდაქმნა"
+"Convert to section" = "სექციად გარდაქმნა"
+"CSS custom properties…" = "CSS-ის მორგებული თვისებები…"
+"Can edit" = "შეუძლია რედაქტირება"
+"Can't read this library: {e}" = "ამ ბიბლიოთეკის წაკითხვა ვერ მოხერხდა: {e}"
+"Cancel" = "გაუქმება"
+"Canvas" = "ტილო"
+"Canvas stacking" = "ტილოზე დალაგების რიგი"
+"Cap height to baseline" = "მთავრული ასოს სიმაღლიდან საბაზისო ხაზამდე"
+"Case" = "რეგისტრი"
+"Case-sensitive forms" = "რეგისტრზე დამოკიდებული ფორმები"
+"Categories" = "კატეგორიები"
+"Center" = "ცენტრში"
+"Change alias" = "ალიასის შეცვლა"
+"Change resolved" = "ცვლილება გადაწყვეტილია"
+"Change style" = "სტილის შეცვლა"
+"Change to" = "შეცვლა:"
+"Change to needs a layer inside a variant" = "„ვარიანტის შეცვლას“ ვარიანტის შიგნით შრე სჭირდება"
+"Changed" = "შეცვლილია"
+"Changed on both sides: keep one" = "შეცვლილია ორივე მხარეს: დატოვეთ ერთი"
+"Changes on main" = "ცვლილებები მთავარში"
+"Changes on the branch" = "ცვლილებები განშტოებაში"
+"Changes unknown" = "ცვლილებები უცნობია"
+"Choose React, Leptos, SwiftUI or Compose above to connect this component to its code." = "ამ კომპონენტის კოდთან დასაკავშირებლად ზემოთ აირჩიეთ React, Leptos, SwiftUI ან Compose."
+"Choose another profile to change it." = "მის შესაცვლელად აირჩიეთ სხვა პროფილი."
+"Choose collection" = "კოლექციის არჩევა"
+"Choose image" = "გამოსახულების არჩევა"
+"Choose mode" = "რეჟიმის არჩევა"
+"Choose variable" = "ცვლადის არჩევა"
+"Circle" = "წრე"
+"Clear recent" = "ბოლოდროინდელის გასუფთავება"
+"Click + to replace mixed content" = "დაწკაპეთ +, რომ შერეული შიგთავსი ჩაანაცვლოთ"
+"Click anywhere on the canvas to leave one." = "მის დასატოვებლად დაწკაპეთ ტილოს ნებისმიერ ადგილას."
+"Click or drag to merge · {alt} removes" = "დაწკაპეთ ან გადაათრიეთ შესარწყმელად · {alt} შლის"
+"Click or drag to remove · {alt} merges" = "დაწკაპეთ ან გადაათრიეთ წასაშლელად · {alt} შერწყამს"
+"Click to record a key" = "დაწკაპეთ კლავიშის ჩასაწერად"
+"Clip content" = "შიგთავსის მოჭრა"
+"Clip to shape" = "ფიგურაზე მოჭრა"
+"Close" = "დახურვა"
+"Close overlay" = "გადაფარვის დახურვა"
+"Close preview" = "წინასწარი ნახვის დახურვა"
+"Close tab" = "ჩანართის დახურვა"
+"Close version history" = "ვერსიების ისტორიის დახურვა"
+"Close when clicking outside" = "დახურვა გარეთ დაწკაპუნებისას"
+"Code" = "კოდი"
+"Code syntax" = "კოდის სინტაქსი"
+"Collapse" = "ჩაკეცვა"
+"Collapse panel" = "პანელის ჩაკეცვა"
+"Collection" = "კოლექცია"
+"Collections" = "კოლექციები"
+"Color" = "ფერი"
+"Color burn" = "ფერით ჩამუქება"
+"Color dodge" = "ფერით გაღიავება"
+"Color format" = "ფერის ფორმატი"
+"Color profile" = "ფერის პროფილი"
+"Color styles" = "ფერის სტილები"
+"Color values in this file are in this color space." = "ამ ფაილში ფერის მნიშვნელობები ამ ფერთა სივრცეშია."
+"Color variables" = "ფერის ცვლადები"
+"Colour" = "ფერი"
+"Column" = "სვეტი"
+"Column gap" = "სვეტებს შორის შუალედი"
+"Column sizes" = "სვეტების ზომები"
+"Column span" = "სვეტების გაერთიანება"
+"Columns" = "სვეტები"
+"Columns {count}" = "სვეტები {count}"
+"Comment" = "კომენტარი"
+"Comments" = "კომენტარები"
+"Commits" = "კომიტები"
+"Company" = "კომპანია"
+"Compare changes" = "ცვლილებების შედარება"
+"Compatibility notes" = "თავსებადობის შენიშვნები"
+"Completed" = "დასრულებული"
+"Component" = "კომპონენტი"
+"Component name" = "კომპონენტის სახელი"
+"Component property" = "კომპონენტის თვისება"
+"Component set" = "კომპონენტების ნაკრები"
+"Component sets" = "კომპონენტების ნაკრებები"
+"Components" = "კომპონენტები"
+"Conditional" = "პირობითი"
+"Confetti" = "კონფეტი"
+"Conflicts" = "კონფლიქტები"
+"Connect to code" = "კოდთან დაკავშირება"
+"Connected" = "დაკავშირებულია"
+"Connected to code: {from}" = "დაკავშირებულია კოდთან: {from}"
+"Connection lost, reconnecting (attempt {attempt})…" = "კავშირი გაწყდა, ხელახლა დაკავშირება (მცდელობა {attempt})…"
+"Constrain proportions" = "პროპორციების შენარჩუნება"
+"Constraints" = "შეზღუდვები"
+"Content" = "შიგთავსი"
+"Contents hidden" = "შიგთავსი დამალულია"
+"Contents only" = "მხოლოდ შიგთავსი"
+"Contextual alternates" = "კონტექსტური ალტერნატივები"
+"Contrast" = "კონტრასტი"
+"Contributors" = "მონაწილეები"
+"Contributors: {people} · Commits: {commits}" = "მონაწილეები: {people} · კომიტები: {commits}"
+"Controller" = "კონტროლერი"
+"Cool" = "ცივი"
+"Copied as CSS" = "დაკოპირდა როგორც CSS"
+"Copied as PNG" = "დაკოპირდა როგორც PNG"
+"Copied as SVG" = "დაკოპირდა როგორც SVG"
+"Copied as text" = "დაკოპირდა როგორც ტექსტი"
+"Copied {value}" = "დაკოპირდა: {value}"
+"Copy" = "კოპირება"
+"Copy as" = "კოპირება როგორც"
+"Copy as CSS" = "კოპირება როგორც CSS"
+"Copy as PNG" = "კოპირება როგორც PNG"
+"Copy as SVG" = "კოპირება როგორც SVG"
+"Copy code" = "კოდის კოპირება"
+"Copy link" = "ბმულის კოპირება"
+"Copy the {label}" = "კოპირება: {label}"
+"Copy {value}" = "კოპირება: {value}"
+"Corner radius" = "კუთხის რადიუსი"
+"Corner smoothing" = "კუთხეების დარბილება"
+"Couldn't download the variables" = "ცვლადების ჩამოტვირთვა ვერ მოხერხდა"
+"Couldn't reach {server}: showing what this computer remembers." = "{server}-თან დაკავშირება ვერ მოხერხდა: ნაჩვენებია ის, რაც ამ კომპიუტერს ახსოვს."
+"Couldn't save automatically: {error}" = "ავტომატურად შენახვა ვერ მოხერხდა: {error}"
+"Count" = "რაოდენობა"
+"Create" = "შექმნა"
+"Create a variable collection first" = "ჯერ შექმენით ცვლადების კოლექცია"
+"Create a variable first" = "ჯერ შექმენით ცვლადი"
+"Create alias" = "ალიასის შექმნა"
+"Create branch" = "განშტოების შექმნა"
+"Create collection" = "კოლექციის შექმნა"
+"Create component" = "კომპონენტის შექმნა"
+"Create component property" = "კომპონენტის თვისების შექმნა"
+"Create components, styles or variables to publish them as a library." = "შექმენით კომპონენტები, სტილები ან ცვლადები, რომ ბიბლიოთეკად გამოაქვეყნოთ."
+"Create property…" = "თვისების შექმნა…"
+"Create style" = "სტილის შექმნა"
+"Create style from the selected text" = "სტილის შექმნა მონიშნული ტექსტიდან"
+"Created" = "შექმნილია"
+"Crop" = "ჩამოჭრა"
+"Crop marks" = "ჭრის ნიშნები"
+"Ctrl+arrows" = "Ctrl+ისრები"
+"Ctrl+click" = "Ctrl+დაწკაპუნება"
+"Ctrl+scroll" = "Ctrl+გადახვევა"
+"Current name" = "მიმდინარე სახელი"
+"Current version" = "მიმდინარე ვერსია"
+"Cursor chat" = "კურსორის ჩატი"
+"Custom" = "მორგებული"
+"Custom size" = "მორგებული ზომა"
+"Cut" = "ამოჭრა"
+"Dark" = "ბნელი"
+"Darken" = "ჩამუქება"
+"Dash" = "ტირე"
+"Dashboard" = "სამართავი დაფა"
+"Date created" = "შექმნის თარიღი"
+"Dec" = "დეკ"
+"Decoration style" = "გაფორმების სტილი"
+"Decoration" = "გაფორმება"
+"Deep select" = "ღრმა მონიშვნა"
+"Default" = "ნაგულისხმევი"
+"Default content" = "ნაგულისხმევი შიგთავსი"
+"Default value (the top-left variant)" = "ნაგულისხმევი მნიშვნელობა (ზედა მარცხენა ვარიანტი)"
+"Delay" = "დაყოვნება"
+"Delete" = "წაშლა"
+"Delete category (its annotations stay)" = "კატეგორიის წაშლა (მისი ანოტაციები რჩება)"
+"Delete collection" = "კოლექციის წაშლა"
+"Delete group" = "ჯგუფის წაშლა"
+"Delete mode" = "რეჟიმის წაშლა"
+"Delete page" = "გვერდის წაშლა"
+"Delete preset" = "პრესეტის წაშლა"
+"Delete property" = "თვისების წაშლა"
+"Delete the style (layers keep their values)" = "სტილის წაშლა (შრეები ინარჩუნებს მნიშვნელობებს)"
+"Delete thread" = "კომენტარისა და პასუხების წაშლა"
+"Delete variable" = "ცვლადის წაშლა"
+"Delete “{name}”? This can't be undone." = "წაიშალოს „{name}“? ამის დაბრუნება შეუძლებელია."
+"Density" = "სიმკვრივე"
+"Depth" = "სიღრმე"
+"Describe how and when to use this component" = "აღწერეთ, როგორ და როდის გამოიყენება ეს კომპონენტი"
+"Describe what changed" = "აღწერეთ, რა შეიცვალა"
+"Description" = "აღწერა"
+"Description (optional)" = "აღწერა (არასავალდებულო)"
+"Design" = "დიზაინი"
+"Design panel" = "დიზაინის პანელი"
+"Design system starter" = "დიზაინ-სისტემის საწყისი ნაკრები"
+"Desktop" = "დესკტოპი"
+"Destination" = "დანიშნულება"
+"Detach alias" = "ალიასის გამოყოფა"
+"Detach instance" = "ინსტანსის გამოყოფა"
+"Detach property" = "თვისების გამოყოფა"
+"Detach style" = "სტილის გამოყოფა"
+"Detach styles" = "სტილების გამოყოფა"
+"Detach variable" = "ცვლადის გამოყოფა"
+"Details" = "დეტალები"
+"Dev Mode" = "დეველოპერის რეჟიმი"
+"Dev resources" = "დეველოპერის რესურსები"
+"Development" = "დეველოპმენტი"
+"Device" = "მოწყობილობა"
+"Device at 100%" = "მოწყობილობა 100%-ზე"
+"Diamond" = "ბრილიანტი"
+"Difference" = "სხვაობა"
+"Dimensions" = "ზომები"
+"Direction" = "მიმართულება"
+"Disconnect from code" = "კოდთან კავშირის გაწყვეტა"
+"Dispersion" = "დისპერსია"
+"Display name" = "საჩვენებელი სახელი"
+"Dissolve" = "გადადნობა"
+"Distribute and tidy" = "განაწილება და მოწესრიგება"
+"Distribute horizontal spacing" = "ჰორიზონტალური შუალედების განაწილება"
+"Distribute vertical spacing" = "ვერტიკალური შუალედების განაწილება"
+"Divider" = "გამყოფი"
+"Don't Save" = "არ შეინახო"
+"Don't truncate" = "შეკვეცის გარეშე"
+"Done" = "მზადაა"
+"Done editing" = "რედაქტირების დასრულება"
+"Dots" = "წერტილები"
+"Dotted" = "პუნქტირი"
+"Down" = "ქვემოთ"
+"Drafts" = "მონახაზები"
+"Drag the stroke to add a width point" = "გადაათრიეთ კონტური სიგანის წერტილის დასამატებლად"
+"Draw" = "ხატვა"
+"Draw a frame" = "დახატეთ ჩარჩო"
+"Drawing tools" = "ხატვის ხელსაწყოები"
+"Drop a .figcraft, .fig, .json, .svg or image file." = "ჩააგდეთ .figcraft, .fig, .json, .svg ან გამოსახულების ფაილი."
+"Drop to import" = "ჩააგდეთ იმპორტისთვის"
+"Drop to open" = "ჩააგდეთ გასახსნელად"
+"Drop shadow" = "ჩრდილი"
+"Dual-licensed MIT OR Apache-2.0. Made by the ArtCraft team and community." = "ორმაგი ლიცენზია: MIT OR Apache-2.0. შექმნილია ArtCraft-ის გუნდისა და საზოგადოების მიერ."
+"Duo" = "დუო"
+"Duplicate" = "დუბლირება"
+"Duplicate by dragging" = "დუბლირება გადათრევით"
+"Duplicate mode" = "რეჟიმის დუბლირება"
+"Duplicate page" = "გვერდის დუბლირება"
+"Edit" = "რედაქტირება"
+"Edit as an expression" = "ექსპრესიად რედაქტირება"
+"Edit colour" = "ფერის რედაქტირება"
+"Edit comment" = "კომენტარის რედაქტირება"
+"Edit dev resource" = "დეველოპერის რესურსის რედაქტირება"
+"Edit link" = "რედაქტირების ბმული"
+"Edit link copied" = "რედაქტირების ბმული დაკოპირდა"
+"Edit style" = "სტილის რედაქტირება"
+"Edit variable" = "ცვლადის რედაქტირება"
+"Edit with the builder" = "კონსტრუქტორით რედაქტირება"
+"Edited {when}" = "რედაქტირებულია {when}"
+"Effect settings" = "ეფექტის პარამეტრები"
+"Effect styles" = "ეფექტის სტილები"
+"Effects" = "ეფექტები"
+"Elbow" = "კუთხოვანი"
+"Ellipse" = "ელიფსი"
+"Ellipses" = "ელიფსები"
+"Else" = "სხვა შემთხვევაში"
+"Else if" = "სხვა შემთხვევაში, თუ"
+"Embedded profile" = "ჩაშენებული პროფილი"
+"Empty" = "ცარიელი"
+"End" = "ბოლო"
+"End point" = "საბოლოო წერტილი"
+"Ends the session; everyone keeps their copy" = "ასრულებს სესიას; ყველას თავისი ასლი რჩება"
+"Enter" = "Enter"
+"Enter the address of a figcraft-server and press Browse to see the plugins it offers." = "შეიყვანეთ figcraft-server-ის მისამართი და დააჭირეთ „დათვალიერებას“, რომ ნახოთ მის მიერ შემოთავაზებული პლაგინები."
+"Enter to save · Esc to cancel" = "Enter — შენახვა · Esc — გაუქმება"
+"Eraser" = "საშლელი"
+"Esc" = "Esc"
+"Essential" = "ძირითადი"
+"Every conflict has a choice." = "ყველა კონფლიქტს არჩევანი აქვს."
+"Every top-level frame already starts a flow" = "ყველა ზედა დონის ჩარჩო უკვე იწყებს ნაკადს"
+"Exact opacity (4 then 5: 45%)" = "ზუსტი გაუმჭვირვალობა (4, შემდეგ 5: 45%)"
+"Exclude" = "გამორიცხვა"
+"Excluded" = "გამორიცხული"
+"Excluded from layout" = "განლაგებიდან გამორიცხული"
+"Excludes" = "გამორიცხვები"
+"Exclusion" = "გამორიცხვა"
+"Exit focus view (Esc)" = "ფოკუსის ხედიდან გასვლა (Esc)"
+"Expand" = "გაშლა"
+"Export" = "ექსპორტირება"
+"Export all" = "ყველაფრის ექსპორტირება"
+"Export frames and layers as PNG, JPG, SVG or PDF" = "ჩარჩოებისა და შრეების ექსპორტირება PNG, JPG, SVG ან PDF ფორმატში"
+"Export page as PNG" = "გვერდის PNG ფაილად ექსპორტირება"
+"Export settings" = "ექსპორტის პარამეტრები"
+"Export variables" = "ცვლადების ექსპორტირება"
+"Export {name}" = "{name}-ის ექსპორტირება"
+"Export {n} layers" = { one = "შრის ექსპორტირება: {n}", other = "შრის ექსპორტირება: {n}" }
+"Exported {file}" = "ექსპორტირებულია: {file}"
+"Exported {name}" = "ექსპორტირებულია: {name}"
+"Exported {name}; {n} kinds of content were left out" = { one = "ექსპორტირებულია: {name}; გამოტოვებული შიგთავსის სახეობა: {n}", other = "ექსპორტირებულია: {name}; გამოტოვებული შიგთავსის სახეობა: {n}" }
+"Exported {n} files" = { one = "ექსპორტირებულია ფაილი: {n}", other = "ექსპორტირებულია ფაილი: {n}" }
+"Export…" = "ექსპორტირება…"
+"Expose properties to instances" = "თვისებების ჩვენება ინსტანსებში"
+"Exposure" = "ექსპოზიცია"
+"Expression" = "ექსპრესია"
+"Extend collection" = "კოლექციის გაფართოება"
+"Extends \"{name}\": overridden values are marked" = "აფართოებს „{name}“-ს: შეცვლილი მნიშვნელობები მონიშნულია"
+"Eye" = "თვალი"
+"F" = "F"
+"Fade" = "მილევა"
+"False" = "მცდარი"
+"Feb" = "თებ"
+"Fetching from the server…" = "სერვერიდან მიღება…"
+"FigCraft couldn't open its window: {error}" = "FigCraft-მა ფანჯრის გახსნა ვერ შეძლო: {error}"
+"FigCraft doesn't support every feature of these files yet. The notes list what was left out or changed in the imported copy; the original file is unchanged." = "FigCraft ჯერ ამ ფაილების ყველა შესაძლებლობას არ უჭერს მხარს. შენიშვნებში ჩამოთვლილია, რა გამოტოვდა ან შეიცვალა იმპორტირებულ ასლში; ორიგინალი ფაილი უცვლელია."
+"File" = "ფაილი"
+"File name" = "ფაილის სახელი"
+"File not found" = "ფაილი ვერ მოიძებნა"
+"File published" = "ფაილი გამოქვეყნდა"
+"Files aren't end-to-end encrypted: the server's operator can read them." = "ფაილები ბოლომდე არ არის დაშიფრული: სერვერის ოპერატორს შეუძლია მათი წაკითხვა."
+"Files nobody opens for {n} days are deleted." = { one = "ფაილები, რომლებსაც არავინ ხსნის, იშლება. დღე: {n}.", other = "ფაილები, რომლებსაც არავინ ხსნის, იშლება. დღე: {n}." }
+"Fill" = "შევსება"
+"Fill (fr)" = "შევსება (fr)"
+"Fill container" = "კონტეინერის შევსება"
+"Fill window" = "ფანჯრის შევსება"
+"Fills" = "შევსებები"
+"Fill|sizing" = "შევსება"
+"Filter and sort" = "ფილტრი და სორტირება"
+"Find" = "ძებნა"
+"Find and replace" = "ძებნა და ჩანაცვლება"
+"Find layers" = "შრეების ძებნა"
+"First" = "პირველი"
+"First commit" = "პირველი კომიტი"
+"First on top" = "პირველი ზემოთ"
+"Fit" = "მორგება"
+"Fit device to window" = "მოწყობილობის ფანჯარაში ჩატევა"
+"Fit to contents" = "შიგთავსზე მორგება"
+"Fit to window" = "ფანჯარაში ჩატევა"
+"Fit width" = "სიგანეში ჩატევა"
+"Fixed" = "ფიქსირებული"
+"Fixed gap" = "ფიქსირებული შუალედი"
+"Fixed size" = "ფიქსირებული ზომა"
+"Flatten" = "გაბრტყელება"
+"Flip" = "არეკვლა"
+"Flip horizontal" = "ჰორიზონტალურად არეკვლა"
+"Flip text to the other side" = "ტექსტის მეორე მხარეს გადატანა"
+"Flip vertical" = "ვერტიკალურად არეკვლა"
+"Flip width profile" = "სიგანის პროფილის არეკვლა"
+"Flow starting point" = "ნაკადის საწყისი წერტილი"
+"Flow starting points" = "ნაკადის საწყისი წერტილები"
+"Flows" = "ნაკადები"
+"Focus view" = "ფოკუსის ხედი"
+"Fold autosaves" = "ავტოშენახვების ჩაკეცვა"
+"Folder: click to collapse" = "საქაღალდე: დაწკაპეთ ჩასაკეცად"
+"Folder: click to expand" = "საქაღალდე: დაწკაპეთ გასაშლელად"
+"Follow" = "მიყოლა"
+"Follow {name}" = "{name}-ის მიყოლა"
+"Following" = "მიყოლა"
+"Following {name} · {key} to stop" = "მიჰყვებით: {name} · შესაწყვეტად {key}"
+"Font" = "შრიფტი"
+"Font not installed" = "შრიფტი არ არის დაინსტალირებული"
+"Font size" = "შრიფტის ზომა"
+"Font style" = "შრიფტის სტილი"
+"Forget on this computer" = "ამ კომპიუტერზე დავიწყება"
+"Four screens of a trail app with components and a prototype flow" = "ლაშქრობის აპის ოთხი ეკრანი კომპონენტებითა და პროტოტიპის ნაკადით"
+"Fractions" = "წილადები"
+"Frame" = "ჩარჩო"
+"Frame selection" = "მონიშნულის ჩარჩოში მოქცევა"
+"Frame tools" = "ჩარჩოს ხელსაწყოები"
+"Frames" = "ჩარჩოები"
+"From the library \"{name}\": read-only" = "ბიბლიოთეკიდან „{name}“: მხოლოდ წასაკითხად"
+"From {name}" = "წყარო: {name}"
+"From {server}" = "წყარო: {server}"
+"Frost" = "ჭირხლი"
+"Gap" = "შუალედი"
+"Gap between columns" = "სვეტებს შორის შუალედი"
+"Gap between items" = "ელემენტებს შორის შუალედი"
+"Gap between rows" = "სტრიქონებს შორის შუალედი"
+"Getting started" = "პირველი ნაბიჯები"
+"Give the address of a server open to the public, or a server's address with its key (`figcraft-server key` prints it)." = "მიუთითეთ საჯარო სერვერის მისამართი ან სერვერის მისამართი გასაღებთან ერთად (`figcraft-server key` გამოიტანს მას)."
+"Glass" = "მინა"
+"Go to main component" = "მთავარ კომპონენტზე გადასვლა"
+"Go to {name}" = "{name}-ზე გადასვლა"
+"Grab bag" = "სხვადასხვა"
+"Gradient" = "გრადიენტი"
+"Gray" = "ნაცრისფერი"
+"Green" = "მწვანე"
+"Greyscale components and two example screens to sketch a flow with" = "ნაცრისფერი კომპონენტები და ორი სანიმუშო ეკრანი ნაკადის ჩანახატისთვის"
+"Grid" = "ბადე"
+"Grid ({size})" = "ბადე ({size})"
+"Grid styles" = "ბადის სტილები"
+"Grid {size}" = "ბადე {size}"
+"Group" = "ჯგუფი"
+"Group selection" = "ჯგუფის მონიშვნა"
+"Groups" = "ჯგუფები"
+"Gutter" = "შუალედი"
+"Hand tool" = "ხელის ხელსაწყო"
+"Hanging list" = "გამოწეული სია"
+"Hanging punctuation" = "გამოწეული პუნქტუაცია"
+"Hard light" = "მკვეთრი სინათლე"
+"Heart" = "გული"
+"Height" = "სიმაღლე"
+"Help" = "დახმარება"
+"Help and resources" = "დახმარება და რესურსები"
+"Help page" = "დახმარების გვერდი"
+"Here: {names}" = "აქ: {names}"
+"Hidden" = "დამალული"
+"Hide contents" = "შიგთავსის დამალვა"
+"Hide from publishing" = "გამოქვეყნებისას დამალვა"
+"Hide section contents" = "სექციის შიგთავსის დამალვა"
+"Hide these tips (Getting started in the Help menu shows them again)" = "ამ რჩევების დამალვა („პირველი ნაბიჯები“ დახმარების მენიუში ისევ აჩვენებს მათ)"
+"Hide when publishing" = "გამოქვეყნებისას დამალვა"
+"Highlight layers on hover" = "შრეების გამოკვეთა მაჩვენებლის მიტანისას"
+"Highlighter" = "ხაზგასმის მარკერი"
+"Highlights" = "ღია ტონები"
+"Hold Alt" = "Alt-ის დაჭერა"
+"Hold Alt+Z" = "Alt+Z-ის დაჭერა"
+"Hold Ctrl" = "Ctrl-ის დაჭერა"
+"Hold Z" = "Z-ის დაჭერა"
+"Hold ⌃ or ⌘" = "⌃-ის ან ⌘-ის დაჭერა"
+"Hold ⌥" = "⌥-ის დაჭერა"
+"Hold ⌥Z" = "⌥Z-ის დაჭერა"
+"Home" = "საწყისი ეკრანი"
+"Horizontal" = "ჰორიზონტალური"
+"Horizontal align" = "ჰორიზონტალური სწორება"
+"Horizontal hex" = "ჰორიზონტალური ექვსკუთხედი"
+"Horizontal padding" = "ჰორიზონტალური შიდა დაშორება"
+"Horizontal spacing" = "ჰორიზონტალური დაშორება"
+"Hosted by {operator}" = "მასპინძელი: {operator}"
+"Hover a layer to see its properties" = "მიიტანეთ მაჩვენებელი შრეზე მისი თვისებების სანახავად"
+"Hover other layers to measure the distance" = "მიიტანეთ მაჩვენებელი სხვა შრეებზე მანძილის გასაზომად"
+"Hue" = "ფერის ტონი"
+"Hug" = "შიგთავსზე მორგება"
+"Hug contents" = "შიგთავსზე მორგება"
+"Icon components on a 24 px grid with keylines and a size preview" = "ხატულების კომპონენტები 24 px ბადეზე საორიენტაციო ხაზებითა და ზომების გადახედვით"
+"Icon set starter" = "ხატულების ნაკრების საწყისი"
+"If it keeps happening, please report it at {link} with this message." = "თუ ეს განმეორდება, გთხოვთ, ეს შეტყობინება გამოგვიგზავნეთ აქ: {link}"
+"If" = "თუ"
+"If {condition}" = "თუ {condition}"
+"Ignore auto layout (absolute position)" = "ავტოგანლაგების იგნორირება (აბსოლუტური პოზიცია)"
+"Image" = "გამოსახულება"
+"Images" = "გამოსახულებები"
+"Import" = "იმპორტი"
+"Import path" = "იმპორტის გზა"
+"Import plugin from manifest" = "პლაგინის იმპორტი მანიფესტიდან"
+"Import plugin from manifest…" = "პლაგინის იმპორტი მანიფესტიდან…"
+"Import report" = "იმპორტის ანგარიში"
+"Import variables" = "ცვლადების იმპორტი"
+"Imported document" = "იმპორტირებული დოკუმენტი"
+"Imported {name}" = "იმპორტირებულია: {name}"
+"Imported {n} new variables, updated {updated}" = { one = "იმპორტირებულია ახალი ცვლადი: {n}; განახლდა: {updated}", other = "იმპორტირებულია ახალი ცვლადი: {n}; განახლდა: {updated}" }
+"Import…" = "იმპორტი…"
+"In an instance, this comes from the main component" = "ინსტანსში ეს მთავარი კომპონენტიდან მოდის"
+"In the browser you can join sessions the desktop app hosts and files on a FigCraft server. A page opened over https reaches other computers only through wss:// links (a server behind TLS)." = "ბრაუზერში შეგიძლიათ შეუერთდეთ სესიებს, რომლებსაც სამუშაო მაგიდის აპი მასპინძლობს, და FigCraft-ის სერვერზე არსებულ ფაილებს. https-ით გახსნილი გვერდი სხვა კომპიუტერებს მხოლოდ wss:// ბმულებით აღწევს (TLS-ის მიღმა მყოფი სერვერი)."
+"Include bounding box" = "შემომსაზღვრელი ჩარჩოს ჩართვა"
+"Include id attribute" = "id ატრიბუტის ჩართვა"
+"Included" = "ჩართული"
+"Included in layout" = "განლაგებაში ჩართული"
+"Individual corners" = "ცალკეული კუთხეები"
+"Individual strokes" = "ცალკეული კონტურები"
+"Ink" = "მელანი"
+"Inner shadow" = "შიდა ჩრდილი"
+"Inside" = "შიგნით"
+"Inspect" = "ინსპექტირება"
+"Inspect the layer under the pointer: size, colours, typography" = "მაჩვენებლის ქვეშ მყოფი შრის ინსპექტირება: ზომა, ფერები, ტიპოგრაფია"
+"Install plugin" = "პლაგინის ინსტალაცია"
+"Install" = "ინსტალაცია"
+"Installed {name}" = "დაინსტალირდა: {name}"
+"Installed" = "დაინსტალირებულია"
+"Installing…" = "ინსტალაცია…"
+"Instance" = "ინსტანსი"
+"Instance properties" = "ინსტანსის თვისებები"
+"Instance swap" = "ინსტანსის ჩანაცვლება"
+"Instance swap (no other component)" = "ინსტანსის ჩანაცვლება (სხვა კომპონენტი არ არის)"
+"Instances" = "ინსტანსები"
+"Instant" = "მყისიერი"
+"Intensity" = "ძალა"
+"Interaction" = "ურთიერთქმედება"
+"Interactions" = "ურთიერთქმედებები"
+"Interface design and prototyping. A free, open-source, clean-room design tool written from scratch in Rust, part of the ArtCraft Crafting Apps." = "ინტერფეისის დიზაინი და პროტოტიპირება. უფასო, ღია კოდის, დამოუკიდებლად (clean-room) შექმნილი დიზაინის ხელსაწყო, ნულიდან დაწერილი Rust-ზე, ArtCraft Crafting Apps-ის ნაწილი."
+"Intersect" = "გადაკვეთა"
+"Intersects" = "გადაკვეთები"
+"Invalid color" = "არასწორი ფერი"
+"Invite link" = "მოსაწვევი ბმული"
+"Invite link copied" = "მოსაწვევი ბმული დაკოპირდა"
+"It asks permission to:" = "ის ითხოვს ნებართვას:"
+"Jan" = "იან"
+"Join" = "შეერთება"
+"Join code copied" = "შეერთების კოდი დაკოპირდა"
+"Join code or invite link" = "შეერთების კოდი ან მოსაწვევი ბმული"
+"Join live session" = "ცოცხალ სესიასთან შეერთება"
+"Join us on Discord" = "შემოგვიერთდით Discord-ზე"
+"Join with a code" = "კოდით შეერთება"
+"Joined" = "შეერთებულია"
+"Joined {file}" = "შეერთებულია: {file}"
+"Joining…" = "შეერთება…"
+"Join|stroke" = "შეერთება"
+"Jul" = "ივლ"
+"Jun" = "ივნ"
+"Just now" = "ახლახან"
+"Justify" = "ორმხრივი სწორება"
+"Keep appearance" = "იერსახის შენარჩუნება"
+"Keep appearance converts every color value to {profile} so colors look the same. Keep values leaves the numbers as they are, so colors shift." = "„იერსახის შენარჩუნება“ ყველა ფერის მნიშვნელობას {profile}-ში გარდაქმნის, რომ ფერები იგივენაირად გამოჩნდეს. „მნიშვნელობების შენარჩუნება“ რიცხვებს უცვლელად ტოვებს, ამიტომ ფერები იცვლება."
+"Keep tool selected after use" = "ხელსაწყოს არჩეულად დატოვება გამოყენების შემდეგ"
+"Keep values" = "მნიშვნელობების შენარჩუნება"
+"Key/Gamepad" = "კლავიში/გეიმპადი"
+"Key/Gamepad {key}" = "კლავიში/გეიმპადი {key}"
+"Keyboard shortcuts" = "კლავიატურის მალსახმობები"
+"Kits" = "ნაკრებები"
+"Landing page" = "ლენდინგი"
+"Language" = "ენა"
+"Lasso" = "ლასო"
+"Last" = "ბოლო"
+"Last change: {note}" = "ბოლო ცვლილება: {note}"
+"Last commit" = "ბოლო კომიტი"
+"Last modified" = "ბოლო ცვლილება"
+"Last on top" = "ბოლო ზემოთ"
+"Layer blur" = "შრის გაბუნდოვნება"
+"Layer name" = "შრის სახელი"
+"Layers" = "შრეები"
+"Layers in an instance take their position from the main component" = "ინსტანსის შრეები პოზიციას მთავარი კომპონენტიდან იღებს"
+"Layout" = "განლაგება"
+"Layout grid" = "განლაგების ბადე"
+"Layout grid settings" = "განლაგების ბადის პარამეტრები"
+"Layout grids" = "განლაგების ბადეები"
+"Leave session" = "სესიიდან გასვლა"
+"Leaves" = "ფოთლები"
+"Left" = "მარცხნივ"
+"Left & right" = "მარცხნივ და მარჯვნივ"
+"Left side" = "მარცხენა მხარე"
+"Left side width" = "მარცხენა მხარის სიგანე"
+"Letter case" = "ასოთა რეგისტრი"
+"Letter spacing" = "ასოებს შორის დაშორება"
+"Libraries" = "ბიბლიოთეკები"
+"Libraries in this file" = "ამ ფაილის ბიბლიოთეკები"
+"Library updates available" = "ხელმისაწვდომია ბიბლიოთეკის განახლებები"
+"Library: click to collapse" = "ბიბლიოთეკა: დაწკაპეთ ჩასაკეცად"
+"Library: click to expand" = "ბიბლიოთეკა: დაწკაპეთ გასაშლელად"
+"Library: its variables are read-only here; edit them in the library file and publish it" = "ბიბლიოთეკა: მისი ცვლადები აქ მხოლოდ წასაკითხია; შეცვალეთ ისინი ბიბლიოთეკის ფაილში და გამოაქვეყნეთ"
+"Light" = "ღია"
+"Lighten" = "გაღიავება"
+"Light|glass" = "ღია"
+"Line" = "ხაზი"
+"Line arrow" = "ხაზოვანი ისარი"
+"Line delta" = "სტრიქონების სხვაობა"
+"Line height" = "სტრიქონის სიმაღლე"
+"Linear" = "წრფივი"
+"Lines" = "სტრიქონები"
+"Lines +/−" = "სტრიქონები +/−"
+"Lines added" = "დამატებული სტრიქონები"
+"Lines deleted" = "წაშლილი სტრიქონები"
+"Link" = "ბმული"
+"Link copied" = "ბმული დაკოპირდა"
+"Link docs, code or tickets for developers." = "მიაბით დოკუმენტაცია, კოდი ან ტიკეტები დეველოპერებისთვის."
+"Link frames on the Prototype tab, then present the flow" = "დააკავშირეთ ჩარჩოები „პროტოტიპის“ ჩანართზე, შემდეგ წარადგინეთ ნაკადი"
+"Link this component to its code component: instances then show your real snippet with their values." = "დააკავშირეთ ეს კომპონენტი მის კოდის კომპონენტთან: ინსტანსები მაშინ თქვენს რეალურ ფრაგმენტს აჩვენებს მათი მნიშვნელობებით."
+"List spacing" = "სიის დაშორება"
+"List style" = "სიის სტილი"
+"Live session" = "ცოცხალი სესია"
+"Live · {people}" = "ცოცხლად · {people}"
+"Local components" = "ლოკალური კომპონენტები"
+"Local network" = "ლოკალური ქსელი"
+"Local styles" = "ლოკალური სტილები"
+"Local variables" = "ლოკალური ცვლადები"
+"Lock/Unlock" = "ჩაკეტვა/განბლოკვა"
+"Locked" = "ჩაკეტილი"
+"Lowercase" = "პატარა ასოები"
+"Luminance" = "სიკაშკაშე"
+"Luminosity" = "ნათება"
+"Main" = "მთავარი"
+"Main component deleted" = "მთავარი კომპონენტი წაიშალა"
+"Main menu" = "მთავარი მენიუ"
+"Make a component" = "შექმენით კომპონენტი"
+"Make slot" = "სლოტად გადაქცევა"
+"Mar" = "მარ"
+"Margin" = "ველი"
+"Mark all as read" = "ყველას წაკითხულად მარკირება"
+"Mark as resolved" = "გადაწყვეტილად მარკირება"
+"Mark as unread" = "წაუკითხავად მარკირება"
+"Mark as unresolved" = "გადაუწყვეტლად მარკირება"
+"Marker" = "მარკერი"
+"Mask" = "ნიღაბი"
+"Mass · Stiffness · Damping" = "მასა · სიხისტე · მილევა"
+"Match (empty: the whole name)" = "დამთხვევა (ცარიელი: მთელი სახელი)"
+"Max H" = "მაქს. H"
+"Max W" = "მაქს. W"
+"Max lines" = "მაქს. სტრიქონები"
+"Maximize" = "გაშლა"
+"May" = "მაი"
+"Measure to the selection" = "მონიშნულამდე გაზომვა"
+"Merge into main" = "მთავარში შერწყმა"
+"Merge regions" = "არეების შერწყმა"
+"Merge the branch into the main file (one undo step) and archive it" = "განშტოების მთავარ ფაილთან შერწყმა (დაბრუნების ერთი ნაბიჯი) და მისი დაარქივება"
+"Merged" = "შერწყმულია"
+"Merged PRs" = "გაერთიანებული PR-ები"
+"Min H" = "მინ. H"
+"Min W" = "მინ. W"
+"Minimize" = "ჩაკეცვა"
+"Mirror angle" = "კუთხის არეკვლა"
+"Mirror angle and length" = "კუთხისა და სიგრძის არეკვლა"
+"Mirroring" = "არეკვლა"
+"Missing" = "აკლია"
+"Missing fonts" = "მიუწვდომელი შრიფტები"
+"Missing layer" = "შრე ვერ მოიძებნა"
+"Missing style" = "სტილი ვერ მოიძებნა"
+"Missing variable" = "ცვლადი ვერ მოიძებნა"
+"Miter" = "მახვილი"
+"Miter angle" = "მახვილის კუთხე"
+"Mixed" = "შერეული"
+"Mixed fonts" = "შერეული შრიფტები"
+"Mixed interactions: click + to replace them" = "შერეული ურთიერთქმედებები: დაწკაპეთ +, რომ ჩაანაცვლოთ"
+"Mobile app" = "მობილური აპი"
+"Mode" = "რეჟიმი"
+"Model" = "მოდელი"
+"Models" = "მოდელები"
+"Mono" = "მონო"
+"More" = "მეტი"
+"More instance actions" = "ინსტანსის სხვა მოქმედებები"
+"Mouse down" = "თაგუნას დაჭერა"
+"Mouse enter" = "თაგუნას შესვლა"
+"Mouse leave" = "მაჩვენებლის გასვლა"
+"Mouse up" = "თაგუნას აშვება"
+"Move along the toolbar or the layer rows" = "ხელსაწყოთა ზოლში ან შრეების სტრიქონებში გადაადგილება"
+"Move" = "გადაადგილება"
+"Move column left" = "სვეტის მარცხნივ გადატანა"
+"Move column right" = "სვეტის მარჯვნივ გადატანა"
+"Move down" = "ჩამოწევა"
+"Move in" = "შიგნით გადატანა"
+"Move out" = "გარეთ გადატანა"
+"Move tools" = "გადაადგილების ხელსაწყოები"
+"Move up" = "აწევა"
+"Moved to {name}" = "გადატანილია: {name}"
+"Multi" = "მრავალი"
+"Multiply" = "გამრავლება"
+"Muted" = "მკრთალი"
+"Name" = "სახელი"
+"Name (A–Z)" = "სახელი (ა–ჰ)"
+"Named instance" = "დასახელებული ინსტანსი"
+"Navigate to" = "გადასვლა"
+"Nested instance" = "ჩადგმული ინსტანსი"
+"New board" = "ახალი დაფა"
+"New design file" = "ახალი დიზაინის ფაილი"
+"Newest first" = "ჯერ უახლესი"
+"Next or previous control in the focused region" = "ფოკუსირებულ არეში შემდეგი ან წინა მართვის ელემენტი"
+"Next frame" = "შემდეგი ჩარჩო"
+"Next ready for dev" = "შემდეგი მზად დეველოპერისთვის"
+"Next size option" = "ზომის შემდეგი ვარიანტი"
+"No assets: no export settings, icons or images. Add export settings in the Design tab." = "რესურსები არ არის: არც ექსპორტის პარამეტრები, არც ხატულები, არც გამოსახულებები. ექსპორტის პარამეტრები დაამატეთ „დიზაინის“ ჩანართზე."
+"No boolean variables fit here." = "აქ არცერთი ლოგიკური ცვლადი არ ერგება."
+"No boolean variables yet. Create them in Local variables." = "ლოგიკური ცვლადები ჯერ არ არის. შექმენით ისინი ლოკალურ ცვლადებში."
+"No branches. A branch is a copy of the file to try changes in, then review and merge." = "განშტოებები არ არის. განშტოება ფაილის ასლია, რომელშიც ცვლილებებს ცდით, შემდეგ კი განიხილავთ და შერწყამთ."
+"No category" = "კატეგორიის გარეშე"
+"No changes" = "ცვლილებები არ არის"
+"No color styles" = "ფერის სტილები არ არის"
+"No colour variables fit here." = "აქ არცერთი ფერის ცვლადი არ ერგება."
+"No colour variables yet. Create them in Local variables." = "ფერის ცვლადები ჯერ არ არის. შექმენით ისინი ლოკალურ ცვლადებში."
+"No comments yet" = "კომენტარები ჯერ არ არის"
+"No compatibility warnings reported" = "თავსებადობის გაფრთხილებები არ დაფიქსირებულა"
+"No components yet. Select layers and press {keys}." = "კომპონენტები ჯერ არ არის. მონიშნეთ შრეები და დააჭირეთ {keys}."
+"No conflicts." = "კონფლიქტები არ არის."
+"No contributor data was built into this copy." = "ამ ასლში მონაწილეების მონაცემები არ არის ჩაშენებული."
+"No device" = "მოწყობილობის გარეშე"
+"No fonts match" = "შესაბამისი შრიფტი არ მოიძებნა"
+"No files or templates match your search" = "ძიების შესაბამისი ფაილი ან შაბლონი არ მოიძებნა"
+"No join code here (the server is older than join codes, or this address can't be put in one): share the link instead." = "აქ შეერთების კოდი არ არის (სერვერი შეერთების კოდებზე ძველია, ან ეს მისამართი კოდში ვერ ეტევა): ამის ნაცვლად გააზიარეთ ბმული."
+"No layer changes to show." = "საჩვენებელი შრეების ცვლილებები არ არის."
+"No libraries yet. Add a .figcraft file that was published as a library, or paste a team library's link." = "ბიბლიოთეკები ჯერ არ არის. დაამატეთ ბიბლიოთეკად გამოქვეყნებული .figcraft ფაილი ან ჩასვით გუნდის ბიბლიოთეკის ბმული."
+"No list" = "სიის გარეშე"
+"No matching comments" = "შესაბამისი კომენტარი არ მოიძებნა"
+"No matching components" = "შესაბამისი კომპონენტი არ მოიძებნა"
+"No matching layers" = "შესაბამისი შრე არ მოიძებნა"
+"No matching styles" = "შესაბამისი სტილი არ მოიძებნა"
+"No matching variables" = "შესაბამისი ცვლადი არ მოიძებნა"
+"No mirroring" = "არეკვლის გარეშე"
+"No model credits were built into this copy." = "ამ ასლში მოდელების მონაცემები არ არის ჩაშენებული."
+"No number variables fit here." = "აქ არცერთი რიცხვითი ცვლადი არ ერგება."
+"No number variables yet. Create them in Local variables." = "რიცხვითი ცვლადები ჯერ არ არის. შექმენით ისინი ლოკალურ ცვლადებში."
+"No other pages" = "სხვა გვერდები არ არის"
+"No paints" = "საღებავების გარეშე"
+"No plugins on {server}." = "{server}-ზე პლაგინები არ არის."
+"No plugins yet. Import a development plugin from its figcraft-plugin.json." = "პლაგინები ჯერ არ არის. დეველოპერის პლაგინის იმპორტი მოახდინეთ მისი figcraft-plugin.json-იდან."
+"No preferred components" = "სასურველი კომპონენტების გარეშე"
+"No preset" = "პრესეტის გარეშე"
+"No saved versions yet. Save a version to mark a point in your work you can come back to." = "შენახული ვერსიები ჯერ არ არის. შეინახეთ ვერსია, რომ მონიშნოთ თქვენი სამუშაოს წერტილი, სადაც შეგიძლიათ დაბრუნდეთ."
+"No scrolling" = "გადახვევის გარეშე"
+"No shortcuts match" = "შესაბამისი მალსახმობი არ მოიძებნა"
+"No status" = "სტატუსის გარეშე"
+"No string variables fit here." = "აქ არცერთი სტრიქონული ცვლადი არ ერგება."
+"No string variables yet. Create them in Local variables." = "სტრიქონული ცვლადები ჯერ არ არის. შექმენით ისინი ლოკალურ ცვლადებში."
+"No styles yet." = "სტილები ჯერ არ არის."
+"No styles yet. Click + to create one from the selection." = "სტილები ჯერ არ არის. დაწკაპეთ +, რომ მონიშნულიდან შექმნათ."
+"No templates match your search" = "ძიების შესაბამისი შაბლონი არ მოიძებნა"
+"No text styles yet. Click + to create one from the selected text." = "ტექსტის სტილები ჯერ არ არის. დაწკაპეთ +, რომ მონიშნული ტექსტიდან შექმნათ."
+"No variables fit here." = "აქ არცერთი ცვლადი არ ერგება."
+"No variables yet. Create them in Local variables." = "ცვლადები ჯერ არ არის. შექმენით ისინი ლოკალურ ცვლადებში."
+"Nobody else is here yet" = "აქ ჯერ სხვა არავინ არის"
+"Noise" = "ხმაური"
+"None" = "არცერთი"
+"None." = "არაფერი."
+"Normal" = "ჩვეულებრივი"
+"Not bound" = "მიბმული არ არის"
+"Not in a live session" = "ცოცხალ სესიაში არ ხართ"
+"Not in this font" = "ამ შრიფტში არ არის"
+"Not properties, kept as written: {names}" = "არ არის თვისებები, დარჩა დაწერილი სახით: {names}"
+"Not read yet" = "ჯერ არ არის წაკითხული"
+"Not shared" = "არ არის გაზიარებული"
+"Note {n}" = "შენიშვნა {n}"
+"Nothing changed since this was marked ready for dev." = "მას შემდეგ, რაც მზად დეველოპერისთვის მოინიშნა, არაფერი შეცვლილა."
+"Nothing here yet. Set a frame's status to list it." = "აქ ჯერ არაფერია. ჩარჩოს სიაში გამოსაჩენად მიანიჭეთ სტატუსი."
+"Nothing online yet. Use Share on a file to put it online and it is listed here." = "ონლაინ ჯერ არაფერია. ფაილის ონლაინ განსათავსებლად გამოიყენეთ „გაზიარება“ და ის აქ გამოჩნდება."
+"Nothing to export" = "საექსპორტო არაფერია"
+"Nov" = "ნოე"
+"Now" = "ახლა"
+"Nudge (Shift: big nudge)" = "მცირედ გადაწევა (Shift: დიდი ბიჯით)"
+"Nudge amount" = "მცირედ გადაწევის ბიჯი"
+"Number" = "რიცხვი"
+"Number ↑" = "რიცხვი ↑"
+"Number ↓" = "რიცხვი ↓"
+"Numbered list" = "დანომრილი სია"
+"Object" = "ობიექტი"
+"Oct" = "ოქტ"
+"Off" = "გამორთული"
+"Offered first when filling the slot (any content is allowed)" = "სლოტის შევსებისას პირველად შემოთავაზებული (ნებისმიერი შიგთავსი დასაშვებია)"
+"Offered first when swapping the instance (any component is allowed)" = "ინსტანსის ჩანაცვლებისას პირველად შემოთავაზებული (ნებისმიერი კომპონენტი დასაშვებია)"
+"Offset" = "წანაცვლება"
+"Oldest first" = "ჯერ უძველესი"
+"On click" = "დაწკაპუნებით"
+"On drag" = "გადათრევისას"
+"On this page" = "ამ გვერდზე"
+"One announcement in five common sizes: square, portrait, story, link and banner" = "ერთი განცხადება ხუთ ხშირად გამოყენებულ ზომაში: კვადრატი, ვერტიკალური, სთორი, ბმული და ბანერი"
+"Online" = "ონლაინ"
+"Online files" = "ონლაინ ფაილები"
+"Online sharing is off: files are shared on the local network only." = "ონლაინ გაზიარება გამორთულია: ფაილები მხოლოდ ლოკალურ ქსელში ზიარდება."
+"Only the first changed layers are listed." = "ნაჩვენებია მხოლოდ პირველი შეცვლილი შრეები."
+"Only the first {n} changed layers are listed." = "ნაჩვენებია მხოლოდ პირველი შეცვლილი შრეები. შრე: {n}."
+"Only your threads" = "მხოლოდ თქვენი მიმოწერები"
+"Opacity" = "გაუმჭვირვალობა"
+"Opacity & blend" = "გაუმჭვირვალობა და შერევა"
+"Opacity 10%…90%, 0: 100%" = "გაუმჭვირვალობა 10%…90%, 0: 100%"
+"Open" = "გახსნა"
+"Open .figcraft, .svg or images" = ".figcraft, .svg ან გამოსახულებების გახსნა"
+"Open branch" = "განშტოების გახსნა"
+"Open file" = "ფაილის გახსნა"
+"Open files" = "გახსნილი ფაილები"
+"Open in focus view" = "ფოკუსის ხედში გახსნა"
+"Open in new window" = "გახსნა ახალ ფანჯარაში"
+"Open invite links in FigCraft" = "მოსაწვევი ბმულების FigCraft-ში გახსნა"
+"Open link" = "ბმულის გახსნა"
+"Open link {url}" = "ბმულის გახსნა {url}"
+"Open overlay" = "გადაფარვის გახსნა"
+"Open prototype preview" = "პროტოტიპის წინასწარი ნახვის გახსნა"
+"Open variables ({count})" = "ცვლადების გახსნა ({count})"
+"Opened as a new document" = "გაიხსნა ახალ დოკუმენტად"
+"Opened “{name}” in a new tab" = "„{name}“ გაიხსნა ახალ ჩანართში"
+"Opening the file…" = "ფაილის გახსნა…"
+"Opening {n} files as new files" = { one = "ახალ ფაილად გახსნა", other = "ახალ ფაილებად გახსნა: {n}" }
+"Open|comments" = "გახსნა"
+"Options" = "პარამეტრები"
+"Orange" = "ნარინჯისფერი"
+"Order" = "რიგი"
+"Other apps may not open every .fig file exported here." = "სხვა აპებმა შეიძლება ვერ გახსნან აქ ექსპორტირებული ყველა .fig ფაილი."
+"Other" = "სხვა"
+"Others lose access and keep their copy; the file stays on the server for you" = "სხვები კარგავენ წვდომას და ინარჩუნებენ თავიანთ ასლს; ფაილი სერვერზე თქვენთვის რჩება"
+"Others type this under Share ▸ Join with a code" = "სხვები ამას შეიყვანენ აქ: გაზიარება ▸ კოდით შეერთება"
+"Outline stroke" = "კონტურის ფიგურად გარდაქმნა"
+"Outline text" = "ტექსტის კონტურებად გარდაქმნა"
+"Outlines" = "კონტურები"
+"Outside" = "გარეთ"
+"Overflow" = "გადავსება"
+"Overlay" = "ზედდება"
+"Overlay position" = "გადაფარვის პოზიცია"
+"Overridden here (the collection it extends has another value)" = "აქ შეცვლილია (კოლექციას, რომელსაც აფართოებს, სხვა მნიშვნელობა აქვს)"
+"Overrides" = "გადაფარვები"
+"Owner token" = "მფლობელის ტოკენი"
+"Owner token copied" = "მფლობელის ტოკენი დაკოპირდა"
+"PDF print options" = "PDF-ის ბეჭდვის პარამეტრები"
+"PDF print settings" = "PDF-ის ბეჭდვის პარამეტრები"
+"Padding" = "შიდა დაშორება"
+"Page" = "გვერდი"
+"Pages" = "გვერდები"
+"Pages added to the document" = "გვერდები დაემატა დოკუმენტს"
+"Pink" = "ვარდისფერი"
+"Placed on the current page" = "განთავსდა მიმდინარე გვერდზე"
+"Pages: {pages}" = "გვერდი: {pages}"
+"Paint bucket" = "საღებავის ვედრო"
+"Pan the canvas" = "ტილოს გადაადგილება"
+"Pan with nothing selected (Shift: farther)" = "გადაადგილება, როცა არაფერია მონიშნული (Shift: უფრო შორს)"
+"Panels" = "პანელები"
+"Paper" = "ქაღალდი"
+"Paragraph indent" = "აბზაცის შეწევა"
+"Paragraph indent applies to left-aligned text" = "აბზაცის შეწევა ვრცელდება მარცხნივ სწორებულ ტექსტზე"
+"Paragraph spacing" = "აბზაცთა ინტერვალი"
+"Pass through" = "გატარება"
+"Paste a link (https://…)" = "ჩასვით ბმული (https://…)"
+"Paste a team library link (a view link)" = "ჩასვით გუნდის ბიბლიოთეკის ბმული (ნახვის ბმული)"
+"Paste here" = "აქ ჩასმა"
+"Paste to replace" = "ჩასმა ჩასანაცვლებლად"
+"Pasted design layers; {n} kinds of content were left out" = { one = "ჩასმულია დიზაინის შრეები; გამოტოვებული შიგთავსის სახეობა: {n}", other = "ჩასმულია დიზაინის შრეები; გამოტოვებული შიგთავსის სახეობა: {n}" }
+"Pattern" = "პატერნი"
+"Pattern alignment" = "პატერნის სწორება"
+"Pattern scale" = "პატერნის მასშტაბი"
+"Pattern source" = "პატერნის წყარო"
+"Pen" = "კალამი"
+"Pencil" = "ფანქარი"
+"People in this file" = "ამ ფაილში მყოფი ადამიანები"
+"People join from anywhere with a code. The file is kept on {server} while you share it." = "ადამიანები ნებისმიერი ადგილიდან კოდით უერთდებიან. სანამ აზიარებთ, ფაილი {server}-ზე ინახება."
+"People on your network join with a code. Nothing goes through a server." = "თქვენი ქსელის ადამიანები კოდით უერთდებიან. სერვერზე არაფერი გადის."
+"Phone" = "ტელეფონი"
+"Pick color" = "ფერის არჩევა"
+"Pick color (I)" = "ფერის აღება (I)"
+"Pick one font family first" = "ჯერ აირჩიეთ ერთი შრიფტის ოჯახი"
+"Pick the Frame tool, then drag on the canvas or choose a device size" = "აირჩიეთ ჩარჩოს ხელსაწყო, შემდეგ გადაათრიეთ ტილოზე ან აირჩიეთ მოწყობილობის ზომა"
+"Pin a property" = "თვისების მიმაგრება"
+"Pinch" = "მოჭყლეტა"
+"Pixel grid" = "პიქსელური ბადე"
+"Pixel preview 1x" = "პიქსელების წინასწარი ნახვა 1x"
+"Pixel preview 2x" = "პიქსელების წინასწარი ნახვა 2x"
+"Place a shape or frame (its tool chosen)" = "ფიგურის ან ჩარჩოს განთავსება (არჩეული ხელსაწყოთი)"
+"Place automatically" = "ავტომატურად განთავსება"
+"Place image" = "გამოსახულების განთავსება"
+"Plugin" = "პლაგინი"
+"Plugins run in FigCraft's sandbox, without files, network or clock. Install only plugins you trust." = "პლაგინები FigCraft-ის იზოლირებულ გარემოში მუშაობს, ფაილების, ქსელისა და საათის გარეშე. დააინსტალირეთ მხოლოდ სანდო პლაგინები."
+"Plugins" = "პლაგინები"
+"Plugins & widgets" = "პლაგინები და ვიჯეტები"
+"Plus darker" = "პლუს მუქი"
+"Plus lighter" = "პლუს ღია"
+"Plus one" = "პლუს ერთი"
+"Point" = "წერტილი"
+"Points" = "წერტილები"
+"Polygon" = "მრავალკუთხედი"
+"Polygons" = "მრავალკუთხედები"
+"Port" = "პორტი"
+"Position" = "პოზიცია"
+"Post" = "გაგზავნა"
+"Preferences" = "პარამეტრები"
+"Preferred" = "სასურველი"
+"Present" = "წარდგენა"
+"Present or preview" = "წარდგენა ან წინასწარი ნახვა"
+"Present this flow" = "ამ ნაკადის წარდგენა"
+"Presentation" = "პრეზენტაცია"
+"Presentation slides" = "პრეზენტაციის სლაიდები"
+"Presenting: comments" = "წარდგენა: კომენტარები"
+"Presenting: cycle the size options" = "წარდგენა: ზომის ვარიანტების მონაცვლეობა"
+"Presenting: full screen" = "წარდგენა: სრული ეკრანი"
+"Presenting: next frame" = "წარდგენა: შემდეგი ჩარჩო"
+"Presenting: previous frame" = "წარდგენა: წინა ჩარჩო"
+"Presenting: restart" = "წარდგენა: თავიდან დაწყება"
+"Preserve scroll position" = "გადახვევის პოზიციის შენარჩუნება"
+"Presets" = "პრესეტები"
+"Press a key…" = "დააჭირეთ კლავიშს…"
+"Playground" = "საცდელი სივრცე"
+"Preview" = "წინასწარი ნახვა"
+"Preview this flow" = "ამ ნაკადის წინასწარი ნახვა"
+"Preview this frame" = "ამ ჩარჩოს წინასწარი ნახვა"
+"Previous frame" = "წინა ჩარჩო"
+"Previous ready for dev" = "წინა მზად დეველოპერისთვის"
+"Progressive" = "პროგრესული"
+"Properties" = "თვისებები"
+"Prototype" = "პროტოტიპი"
+"Prototype preview" = "პროტოტიპის წინასწარი ნახვა"
+"Prototype settings" = "პროტოტიპის პარამეტრები"
+"Publish" = "გამოქვეყნება"
+"Publish changes" = "ცვლილებების გამოქვეყნება"
+"Publish to another server…" = "სხვა სერვერზე გამოქვეყნება…"
+"Publish to server" = "სერვერზე გამოქვეყნება"
+"Published version {v}" = "გამოქვეყნდა ვერსია {v}"
+"Published version {v} to the server" = "ვერსია {v} გამოქვეყნდა სერვერზე"
+"Published version {v}: save the file so other files can use it" = "გამოქვეყნდა ვერსია {v}: შეინახეთ ფაილი, რომ სხვა ფაილებმა შეძლონ მისი გამოყენება"
+"Published · {people}" = "გამოქვეყნებულია · {people}"
+"Publishing to a server needs the desktop app; in the browser you can join a server's files" = "სერვერზე გამოსაქვეყნებლად სამუშაო მაგიდის აპია საჭირო; ბრაუზერში შეგიძლიათ სერვერის ფაილებს შეუერთდეთ"
+"Publishing with the server's key." = "ქვეყნდება სერვერის გასაღებით."
+"Publishing…" = "გამოქვეყნება…"
+"Push" = "ბიძგი"
+"Push changes to main component" = "ცვლილებების მთავარ კომპონენტში გადაგზავნა"
+"Put text on path" = "ტექსტის ტრაექტორიაზე განთავსება"
+"Question" = "კითხვა"
+"R" = "R"
+"Radial" = "რადიალური"
+"Radius" = "რადიუსი"
+"Ratio" = "თანაფარდობა"
+"Reading the library…" = "ბიბლიოთეკის წაკითხვა…"
+"Ready for dev" = "მზადაა დეველოპერისთვის"
+"Real name" = "ნამდვილი სახელი"
+"Recent" = "ბოლოდროინდელი"
+"Recent files" = "ბოლოს გახსნილი ფაილები"
+"Recents" = "ბოლოდროინდელი"
+"Recovered {n} unsaved files after the app quit unexpectedly: save them to keep them" = { one = "აპის მოულოდნელი დახურვის შემდეგ აღდგა შეუნახავი ფაილი: შესანარჩუნებლად შეინახეთ", other = "აპის მოულოდნელი დახურვის შემდეგ აღდგა შეუნახავი ფაილი: {n}. შესანარჩუნებლად შეინახეთ" }
+"Rectangle" = "მართკუთხედი"
+"Rectangles" = "მართკუთხედები"
+"Red" = "წითელი"
+"Reduce motion" = "მოძრაობის შემცირება"
+"Refraction" = "გარდატეხა"
+"Regular expression" = "რეგულარული გამოსახულება"
+"Remove" = "წაშლა"
+"Remove all" = "ყველას წაშლა"
+"Remove annotation" = "ანოტაციის წაშლა"
+"Remove auto layout" = "ავტოგანლაგების მოხსნა"
+"Remove dev resource" = "დეველოპერის რესურსის წაშლა"
+"Remove export setting" = "ექსპორტის პარამეტრის წაშლა"
+"Remove from recents" = "ბოლოდროინდელებიდან ამოშლა"
+"Remove from server" = "სერვერიდან წაშლა"
+"Remove from server…" = "სერვერიდან წაშლა…"
+"Remove guide" = "დამხმარე ხაზის მოცილება"
+"Remove interaction" = "ურთიერთქმედების წაშლა"
+"Remove library from this file" = "ბიბლიოთეკის ამ ფაილიდან ამოშლა"
+"Remove min and max" = "მინ. და მაქს. მოხსნა"
+"Remove min and max height" = "მინ. და მაქს. სიმაღლის მოხსნა"
+"Remove min and max width" = "მინ. და მაქს. სიგანის მოხსნა"
+"Remove regions" = "არეების წაშლა"
+"Remove slot" = "სლოტის მოხსნა"
+"Remove starting point" = "საწყისი წერტილის წაშლა"
+"Remove stop" = "გადასვლის წერტილის წაშლა"
+"Remove text from path" = "ტექსტის ტრაექტორიიდან მოხსნა"
+"Remove the else and its actions" = "„სხვა შემთხვევაში“ და მისი მოქმედებების წაშლა"
+"Remove this condition and its actions" = "ამ პირობისა და მისი მოქმედებების წაშლა"
+"Remove this file from the server? It can't be shared or opened from there again. Your copy stays open here." = "წაიშალოს ეს ფაილი სერვერიდან? იქიდან მისი გაზიარება ან გახსნა აღარ იქნება შესაძლებელი. თქვენი ასლი აქ ღია რჩება."
+"Remove {name} from session" = "სესიიდან მოცილება: {name}"
+"Remove {name} from {server}?" = "წაიშალოს {name} {server}-იდან?"
+"Removed" = "წაშლილია"
+"Removed from the server" = "წაიშალა სერვერიდან"
+"Removed since it was marked" = "წაიშალა მონიშვნის შემდეგ"
+"Rename" = "სახელის შეცვლა"
+"Rename duplicated layers" = "დუბლირებული შრეების სახელის შეცვლა"
+"Rename folder" = "საქაღალდის სახელის შეცვლა"
+"Rename group" = "ჯგუფის სახელის შეცვლა"
+"Rename layers" = "შრეების სახელის შეცვლა"
+"Rename mode" = "რეჟიმის სახელის შეცვლა"
+"Rename on the server" = "სახელის შეცვლა სერვერზე"
+"Rename on the server…" = "სახელის შეცვლა სერვერზე…"
+"Rename page" = "გვერდის სახელის შეცვლა"
+"Rename to" = "ახალი სახელი"
+"Replace all" = "ყველას ჩანაცვლება"
+"Replace mixed export settings" = "შერეული ექსპორტის პარამეტრების ჩანაცვლება"
+"Replace with" = "ჩანაცვლება:"
+"Replace with a new interaction" = "ახალი ურთიერთქმედებით ჩანაცვლება"
+"Reply" = "პასუხი"
+"Report" = "საჩივარი"
+"Report this file…" = "ამ ფაილზე საჩივარი…"
+"Reset" = "ჩამოყრა"
+"Reset adjustments" = "კორექციების ჩამოყრა"
+"Reset all changes" = "ყველა ცვლილების ჩამოყრა"
+"Reset all overrides on this layer" = "ამ შრის ყველა გადაფარვის ჩამოყრა"
+"Reset overrides" = "გადაფარვების ჩამოყრა"
+"Reset slot" = "სლოტის ჩამოყრა"
+"Reset this override" = "ამ გადაფარვის ჩამოყრა"
+"Reset to style" = "სტილზე ჩამოყრა"
+"Reset to the inherited value" = "მემკვიდრეობით მიღებულ მნიშვნელობაზე ჩამოყრა"
+"Resize by the nudge amount" = "ზომის შეცვლა მცირედ გადაწევის ბიჯით"
+"Resize frames to the device's screen (or the window without a device): their constraints and auto layout respond" = "ჩარჩოების ზომის მორგება მოწყობილობის ეკრანზე (ან ფანჯარაზე, თუ მოწყობილობა არ არის): მათი შეზღუდვები და ავტოგანლაგება რეაგირებს"
+"Resize to fit" = "ზომის მორგება"
+"Resizing" = "ზომის შეცვლა"
+"Resolve" = "გადაწყვეტა"
+"Resolve change" = "ცვლილების გადაწყვეტა"
+"Resolved" = "გადაწყვეტილია"
+"Resources" = "რესურსები"
+"Responsive" = "ადაპტური"
+"Restart" = "გადატვირთვა"
+"Restore" = "აღდგენა"
+"Restore main component" = "მთავარი კომპონენტის აღდგენა"
+"Restore this version" = "ამ ვერსიის აღდგენა"
+"Restored “{name}”" = "„{name}“ აღდგა"
+"Reverse the order" = "რიგის შებრუნება"
+"Reversed triangle" = "შებრუნებული სამკუთხედი"
+"Review and merge" = "განხილვა და შერწყმა"
+"Ribbon" = "ლენტი"
+"Right" = "მარჯვნივ"
+"Right side" = "მარჯვენა მხარე"
+"Right side width" = "მარჯვენა მხარის სიგანე"
+"Rotate 90°" = "90°-ით შემობრუნება"
+"Rotate 90° right" = "90°-ით მარჯვნივ შემობრუნება"
+"Rotate to landscape" = "ჰორიზონტალურად შემობრუნება"
+"Rotate to portrait" = "ვერტიკალურად შემობრუნება"
+"Rotation" = "შემობრუნება"
+"Rotation jitter" = "შემობრუნების ცვალებადობა"
+"Round" = "მომრგვალებული"
+"Rounded" = "მომრგვალებული"
+"Rounded rectangle" = "მომრგვალებული მართკუთხედი"
+"Row" = "სტრიქონი"
+"Row gap" = "სტრიქონებს შორის შუალედი"
+"Row sizes" = "სტრიქონების ზომები"
+"Row span" = "სტრიქონების გაერთიანება"
+"Rows" = "სტრიქონები"
+"Rows {count}" = "სტრიქონები {count}"
+"Rulers" = "სახაზავები"
+"Run" = "გაშვება"
+"Run {label}" = "გაშვება: {label}"
+"Save files automatically" = "ფაილების ავტომატურად შენახვა"
+"Search templates" = "შაბლონების ძიება"
+"See all templates" = "ყველა შაბლონის ნახვა"
+"Select layers and they space themselves as their content changes" = "მონიშნეთ შრეები და შიგთავსის ცვლილებისას ისინი ავტომატურად დაშორდება ერთმანეთს"
+"SHA-256: {sha}…" = "SHA-256: {sha}…"
+"Same as layer" = "შრის მსგავსად"
+"Saturation" = "გაჯერება"
+"Save" = "შენახვა"
+"Save as" = "შენახვა როგორც"
+"Save as preset…" = "პრესეტად შენახვა…"
+"Save version  {key}" = "ვერსიის შენახვა  {key}"
+"Saved" = "შენახულია"
+"Saved {name}" = "შენახულია {name}"
+"Say something" = "დაწერეთ რამე"
+"Scale" = "მასშტაბი"
+"Scatter" = "გაბნევა"
+"Scoping: where pickers offer it" = "არე: სად სთავაზობენ ამომრჩევები"
+"Screen" = "ეკრანი"
+"Scroll behavior" = "გადახვევის ქცევა"
+"Scroll to" = "გადახვევა:"
+"Scroll to layer" = "შრემდე გადახვევა"
+"Scroll with parent" = "მშობელთან ერთად გადახვევა"
+"Search plugins" = "პლაგინების ძიება"
+"Search" = "ძიება"
+"Search actions, layers and tools" = "მოქმედებების, შრეებისა და ხელსაწყოების ძიება"
+"Search assets" = "რესურსების ძიება"
+"Search comments" = "კომენტარების ძიება"
+"Search files and templates" = "ფაილებისა და შაბლონების ძიება"
+"Search results" = "ძიების შედეგები"
+"Search fonts" = "შრიფტების ძიება"
+"Search layers" = "შრეების ძიება"
+"Search shortcuts" = "მალსახმობების ძიება"
+"Section" = "სექცია"
+"Section color" = "სექციის ფერი"
+"Sections" = "სექციები"
+"Select a frame and add a starting point to present it as a flow." = "მონიშნეთ ჩარჩო და დაამატეთ საწყისი წერტილი, რომ ნაკადად წარადგინოთ."
+"Select a frame to preview it" = "მონიშნეთ ჩარჩო მისი წინასწარი ნახვისთვის"
+"Select a layer to see its properties and code" = "მონიშნეთ შრე მისი თვისებებისა და კოდის სანახავად"
+"Select all" = "ყველაფრის მონიშვნა"
+"Select all with same" = "ყველაფრის მონიშვნა იგივე"
+"Select layer" = "შრის მონიშვნა"
+"Select layers to apply the style to" = "მონიშნეთ შრეები, რომლებზეც სტილი უნდა გამოიყენოთ"
+"Select layers with this color" = "ამ ფერის შრეების მონიშვნა"
+"Select overlapping shapes" = "გადაფარული ფიგურების მონიშვნა"
+"Select points to edit their position, radius and mirroring" = "მონიშნეთ წერტილები მათი პოზიციის, რადიუსისა და არეკვლის შესაცვლელად"
+"Select slot" = "სლოტის მონიშვნა"
+"Selection colors" = "მონიშნულის ფერები"
+"Selection" = "მონიშნული"
+"Selection box, {w} by {h} at {x}, {y}: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "მონიშვნის ჩარჩო, {w} × {h}, მდებარეობა {x}, {y}: ისრები გადააადგილებს, Shift+ისრები ან {cmd}+ისრები ზომას ცვლის, Enter მონიშნავს, Escape გააუქმებს"
+"Selection box: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "მონიშვნის ჩარჩო: ისრები გადააადგილებს, Shift+ისრები ან {cmd}+ისრები ზომას ცვლის, Enter მონიშნავს, Escape გააუქმებს"
+"Send backward" = "უკან გადატანა"
+"Send report" = "საჩივრის გაგზავნა"
+"Send to back" = "უკანა პლანზე გადატანა"
+"Sep" = "სექ"
+"Server address (ws://host:47900/)" = "სერვერის მისამართი (ws://host:47900/)"
+"Server address" = "სერვერის მისამართი"
+"Server for online sharing" = "ონლაინ გაზიარების სერვერი"
+"Set as default" = "ნაგულისხმევად დაყენება"
+"Set variable" = "ცვლადის დაყენება"
+"Set variable mode" = "ცვლადის რეჟიმის დაყენება"
+"Set variable {name}" = "ცვლადის დაყენება: {name}"
+"Set {name} to {value}" = "{name}-ისთვის {value}-ის დაყენება"
+"Shadows" = "ჩრდილები"
+"Shape" = "ფიგურა"
+"Shape builder" = "ფიგურების კონსტრუქტორი"
+"Shape tools" = "ფიგურის ხელსაწყოები"
+"Shapes" = "ფიგურები"
+"Share" = "გაზიარება"
+"Share this file" = "ამ ფაილის გაზიარება"
+"Share with a code" = "კოდით გაზიარება"
+"Share: live session, export" = "გაზიარება: ცოცხალი სესია, ექსპორტირება"
+"Shared" = "გაზიარებულია"
+"Shared: copy its code from the file's menu" = "გაზიარებულია: მისი კოდი დააკოპირეთ ფაილის მენიუდან"
+"Sharing a file needs the desktop app; here you can join one." = "ფაილის გასაზიარებლად სამუშაო მაგიდის აპია საჭირო; აქ შეგიძლიათ შეუერთდეთ."
+"Sharing on the local network (online sharing is off: no server is set in Preferences)." = "ზიარდება ლოკალურ ქსელში (ონლაინ გაზიარება გამორთულია: პარამეტრებში სერვერი არ არის მითითებული)."
+"Sharing on your network · {people}" = "ზიარდება თქვენს ქსელში · {people}"
+"Sharing online · {people}" = "ზიარდება ონლაინ · {people}"
+"Sharing stopped: the file stays on the server, open only to you" = "გაზიარება შეწყდა: ფაილი სერვერზე რჩება და მხოლოდ თქვენთვისაა ღია"
+"Show" = "ჩვენება"
+"Show all templates" = "ყველა შაბლონის ჩვენება"
+"Show as grid" = "ბადის სახით ჩვენება"
+"Show as list" = "სიის სახით ჩვენება"
+"Show autosaves" = "ავტოშენახვების ჩვენება"
+"Show behind transparent areas" = "გამჭვირვალე არეების მიღმა ჩვენება"
+"Show comments (Shift+C)" = "კომენტარების ჩვენება (Shift+C)"
+"Show device frame" = "მოწყობილობის კორპუსის ჩვენება"
+"Show dimensions on objects" = "ზომების ჩვენება ობიექტებზე"
+"Show hotspot hints" = "აქტიური არეების მინიშნებების ჩვენება"
+"Show in Explorer" = "Explorer-ში ჩვენება"
+"Show in Finder" = "Finder-ში ჩვენება"
+"Show in folder" = "საქაღალდეში ჩვენება"
+"Show only this on the canvas" = "ტილოზე მხოლოდ ამის ჩვენება"
+"Show open" = "გახსნილის ჩვენება"
+"Show section contents" = "სექციის შიგთავსის ჩვენება"
+"Show this layer" = "ამ შრის ჩვენება"
+"Show usage" = "გამოყენების ჩვენება"
+"Show/Hide" = "ჩვენება/დამალვა"
+"Show/Hide UI" = "ინტერფეისის ჩვენება/დამალვა"
+"Side by side" = "გვერდიგვერდ"
+"Sidebar" = "გვერდითი ზოლი"
+"Simplify stroke" = "კონტურის გამარტივება"
+"Size" = "ზომა"
+"Size jitter" = "ზომის ცვალებადობა"
+"Skip ink" = "ხაზგასმის გაწყვეტა ასოებთან"
+"Slashed zero" = "გადახაზული ნული"
+"Slice" = "ნაჭერი"
+"Slices" = "ნაჭრები"
+"Slide in" = "შემოსრიალება"
+"Slide out" = "გასრიალება"
+"Slot" = "სლოტი"
+"Slot content" = "სლოტის შიგთავსი"
+"Small capitals" = "პატარა მთავრული"
+"Small caps" = "პატარა მთავრული"
+"Smart animate" = "ჭკვიანი ანიმაცია"
+"Snap to pixel grid" = "პიქსელურ ბადეზე მიბმა"
+"Social and slides" = "სოციალური ქსელები და სლაიდები"
+"Social media" = "სოციალური ქსელები"
+"Social post sizes" = "სოციალური ქსელების პოსტების ზომები"
+"Soft light" = "რბილი ღია"
+"Solid" = "ერთფეროვანი"
+"Some variants have the same property values: give each one a unique combination" = "ზოგ ვარიანტს თვისებების ერთნაირი მნიშვნელობები აქვს: მიეცით თითოეულს უნიკალური კომბინაცია"
+"Sort" = "სორტირება"
+"Sort by" = "სორტირება:"
+"Sort by date" = "თარიღის მიხედვით სორტირება"
+"Sort by page" = "გვერდის მიხედვით სორტირება"
+"Sort by {column}" = "სორტირება: {column}"
+"Space around" = "დაშორება გარშემო"
+"Space between" = "დაშორება შორის"
+"Space drag" = "Space და გადათრევა"
+"Space evenly" = "თანაბარი დაშორება"
+"Space+drag" = "Space+გადათრევა"
+"Spacing" = "ინტერვალი"
+"Spam, stolen work, abuse…" = "სპამი, მოპარული ნამუშევარი, შეურაცხყოფა…"
+"Speech bubble" = "სიტყვის ბუშტი"
+"Splay" = "გაშლილობა"
+"Spotlight me" = "ჩემი ხედის ჩვენება ყველასთვის"
+"Spread" = "გაფართოება"
+"Square" = "კვადრატი"
+"Stamp" = "შტამპი"
+"Stamps" = "შტამპები"
+"Standard" = "სტანდარტული"
+"Standard ligatures" = "სტანდარტული ლიგატურები"
+"Star" = "ვარსკვლავი"
+"Stars" = "ვარსკვლავები"
+"Start" = "დასაწყისი"
+"Start ascending from / stop descending at" = "ზრდადობით დაწყება / კლებადობით დასრულება"
+"Start from a blank canvas" = "ცარიელი ტილოთი დაწყება"
+"Start from a template" = "შაბლონით დაწყება"
+"Start on path" = "დასაწყისი ტრაექტორიაზე"
+"Start point" = "საწყისი წერტილი"
+"Start sharing" = "გაზიარების დაწყება"
+"Start sharing with the Share button, then pass on the code it gives" = "გაზიარება დაიწყეთ ღილაკით „გაზიარება“, შემდეგ გადაეცით მის მიერ მოცემული კოდი"
+"Starting to share…" = "გაზიარების დაწყება…"
+"Status" = "სტატუსი"
+"Sticky" = "მიმაგრებული"
+"Sticky note" = "სტიკერი"
+"Sticky note colors" = "სტიკერების ფერები"
+"Sticky notes, shapes and connectors" = "სტიკერები, ფიგურები და შემაერთებლები"
+"Stop" = "შეწყვეტა"
+"Stop following {name}" = "{name}-ის მიყოლის შეწყვეტა"
+"Stop session" = "სესიის შეწყვეტა"
+"Stop sharing" = "გაზიარების შეწყვეტა"
+"Stop spotlighting" = "ჩემი ხედის ჩვენების შეწყვეტა"
+"Stop {n}  {hex}" = "გადასვლის წერტილი {n}  {hex}"
+"Straight" = "სწორი"
+"Stretch" = "გაწელვა"
+"Strikethrough" = "გადახაზული"
+"String" = "ტექსტი"
+"Stroke" = "კონტური"
+"Stroke style" = "კონტურის სტილი"
+"Stroke weight" = "კონტურის სისქე"
+"Strokes" = "კონტურები"
+"Style" = "სტილი"
+"Styles" = "სტილები"
+"Stylistic set 1" = "სტილისტური ნაკრები 1"
+"Stylistic set 2" = "სტილისტური ნაკრები 2"
+"Stylistic set 3" = "სტილისტური ნაკრები 3"
+"Stylistic set 4" = "სტილისტური ნაკრები 4"
+"Stylistic set 5" = "სტილისტური ნაკრები 5"
+"Subtract" = "გამოკლება"
+"Subtracts" = "გამოკლებები"
+"Suffix" = "სუფიქსი"
+"Suspend snapping while dragging" = "მიბმის შეჩერება გადათრევისას"
+"Swap instance" = "ინსტანსის ჩანაცვლება"
+"Swap library: use another library's assets of the same names" = "ბიბლიოთეკის ჩანაცვლება: სხვა ბიბლიოთეკის იმავე სახელის რესურსების გამოყენება"
+"Swap orientation" = "ორიენტაციის შეცვლა"
+"Swap overlay" = "გადაფარვის ჩანაცვლება"
+"Swap to {name}" = "ჩანაცვლება: {name}"
+"Swap width and height" = "სიგანისა და სიმაღლის გაცვლა"
+"Swapped instance" = "ჩანაცვლებული ინსტანსი"
+"Swapped {n} assets" = { one = "ჩანაცვლებული რესურსი: {n}", other = "ჩანაცვლებული რესურსი: {n}" }
+"Swapped {n} assets; {missed} had no match and still use the old library" = { one = "ჩანაცვლებული რესურსი: {n}; {missed} ვერ დაემთხვა და ისევ ძველ ბიბლიოთეკას იყენებს", other = "ჩანაცვლებული რესურსი: {n}; {missed} ვერ დაემთხვა და ისევ ძველ ბიბლიოთეკას იყენებს" }
+"Sweep" = "სიგრძე"
+"System" = "სისტემა"
+"Tab / Shift+Tab" = "Tab / Shift+Tab"
+"Table" = "ცხრილი"
+"Tablet" = "პლანშეტი"
+"Tabular numbers" = "ცხრილური ციფრები"
+"Take the values from the first selected layer" = "მნიშვნელობების აღება პირველი მონიშნული შრიდან"
+"Taper" = "წაწვეტება"
+"Taper both ends" = "ორივე ბოლოს წაწვეტება"
+"Tell the server's operator what is wrong with it" = "აცნობეთ სერვერის ოპერატორს, რა არის მასში არასწორი"
+"Temperature" = "ტემპერატურა"
+"Template" = "შაბლონი"
+"Templates" = "შაბლონები"
+"Terms" = "პირობები"
+"Text" = "ტექსტი"
+"Text align" = "ტექსტის სწორება"
+"Text content" = "ტექსტის შიგთავსი"
+"Text size" = "ტექსტის ზომა"
+"Text style" = "ტექსტის სტილი"
+"Text styles" = "ტექსტის სტილები"
+"Texts" = "ტექსტები"
+"Texture" = "ტექსტურა"
+"The canvas previews colors in sRGB; exported PNG, JPG and WebP files are tagged Display P3." = "ტილო ფერებს sRGB-ში აჩვენებს; ექსპორტირებულ PNG, JPG და WebP ფაილებს Display P3 ჭდე აქვს."
+"The destination document is unavailable. Nothing was imported." = "დანიშნულების დოკუმენტი მიუწვდომელია. იმპორტი არ შესრულდა."
+"The destination document was closed. Nothing was imported." = "დანიშნულების დოკუმენტი დაიხურა. იმპორტი არ შესრულდა."
+"The destination page was removed. Nothing was imported." = "დანიშნულების გვერდი წაიშალა. იმპორტი არ შესრულდა."
+"The file is deleted from the server: nobody can open or join it from there again, and this can't be undone. Copies that are open stay with whoever has them." = "ფაილი სერვერიდან წაიშლება: იქიდან მის გახსნას ან შეერთებას ვეღარავინ შეძლებს და ამის დაბრუნება შეუძლებელია. ღია ასლები მათ მფლობელებთან რჩება."
+"The file now holds another library" = "ფაილი ახლა სხვა ბიბლიოთეკას შეიცავს"
+"The file now holds another library (\"{name}\")" = "ფაილი ახლა სხვა ბიბლიოთეკას შეიცავს („{name}“)"
+"The files you shared or published online from this computer. They stay on their server until you remove them." = "ფაილები, რომლებიც ამ კომპიუტერიდან ონლაინ გააზიარეთ ან გამოაქვეყნეთ. ისინი თავიანთ სერვერზე რჩება, სანამ არ წაშლით."
+"The link carries the session's secret: share it only with people you invite." = "ბმული სესიის საიდუმლო გასაღებს შეიცავს: გააზიარეთ მხოლოდ მოწვეულ ადამიანებთან."
+"The name in your online files and on the server. The document inside keeps its own name." = "სახელი თქვენს ონლაინ ფაილებსა და სერვერზე. შიგნით არსებული დოკუმენტი თავის სახელს ინარჩუნებს."
+"The selection uses several text styles: click to apply one" = "მონიშნული ტექსტის რამდენიმე სტილს იყენებს: დაწკაპეთ ერთის გამოსაყენებლად"
+"The server deletes this file if nobody opens it before {date}." = "სერვერი ამ ფაილს წაშლის, თუ მას {date}-მდე არავინ გახსნის."
+"The whole file" = "მთელი ფაილი"
+"Theme" = "თემა"
+"There's no destination for that action" = "ამ მოქმედებას დანიშნულება არ აქვს"
+"Thickness" = "სისქე"
+"This branch can't be reviewed: {e}" = "ამ განშტოების განხილვა შეუძლებელია: {e}"
+"This branch was merged or archived." = "ეს განშტოება შერწყმულია ან დაარქივებულია."
+"This computer only" = "მხოლოდ ეს კომპიუტერი"
+"This computer remembers the owner token, so the file can be managed from the home screen's Online list. Copy it to manage the file from somewhere else: it is a password for this file and won't be shown again." = "ეს კომპიუტერი იმახსოვრებს მფლობელის ტოკენს, ამიტომ ფაილის მართვა საწყისი ეკრანის „ონლაინ“ სიიდან შეიძლება. ფაილის სხვა ადგილიდან სამართავად დააკოპირეთ ის: ეს ამ ფაილის პაროლია და აღარ გამოჩნდება."
+"This condition is edited as an expression" = "ეს პირობა ექსპრესიად რედაქტირდება"
+"This file" = "ეს ფაილი"
+"This file has unsaved changes" = "ამ ფაილს შეუნახავი ცვლილებები აქვს"
+"This file uses fonts that aren't installed on this computer. Their text is drawn in a fallback font until you install them." = "ეს ფაილი იყენებს შრიფტებს, რომლებიც ამ კომპიუტერზე დაინსტალირებული არ არის. მათი ტექსტი სათადარიგო შრიფტით გამოისახება, სანამ მათ არ დააინსტალირებთ."
+"This file is on {server}, open only to you. Share it to let others in with a new code." = "ეს ფაილი {server}-ზეა და მხოლოდ თქვენთვისაა ღია. გააზიარეთ, რომ სხვები ახალი კოდით შემოუშვათ."
+"This frame is new on the branch." = "ეს ჩარჩო განშტოებაში ახალია."
+"This frame isn't on the branch." = "ეს ჩარჩო განშტოებაში არ არის."
+"This server is open to the public: no key needed." = "ეს სერვერი საჯაროა: გასაღები საჭირო არ არის."
+"This server needs its key: add ?key=… to the address (`figcraft-server key` prints it on the server's machine)." = "ამ სერვერს გასაღები სჭირდება: მისამართს დაუმატეთ ?key=… (`figcraft-server key` გამოიტანს მას სერვერის კომპიუტერზე)."
+"This server takes files only with its key: see Advanced." = "ეს სერვერი ფაილებს მხოლოდ გასაღებით იღებს: იხილეთ „დამატებითი“."
+"Thumbs up" = "ცერი ზემოთ"
+"Tidy up" = "მოწესრიგება"
+"Tile" = "ფილებად"
+"Tile type" = "ფილის ტიპი"
+"Tint" = "ტონირება"
+"Title" = "დასახელება"
+"Title case" = "სათაურის რეგისტრი"
+"To share this library with your team, publish the file to a server (Share ▸ Publish to server…), then publish the library there." = "ამ ბიბლიოთეკის გუნდთან გასაზიარებლად გამოაქვეყნეთ ფაილი სერვერზე (გაზიარება ▸ სერვერზე გამოქვეყნება…), შემდეგ იქ გამოაქვეყნეთ ბიბლიოთეკა."
+"Toggle" = "გადართვა"
+"Toggle light/dark theme" = "ღია/ბნელი თემის გადართვა"
+"Toggle visibility" = "ხილვადობის ჩართვა/გამორთვა"
+"Tools" = "ხელსაწყოები"
+"Top" = "ზემოთ"
+"Top & bottom" = "ზემოთ და ქვემოთ"
+"Top left radius" = "ზედა მარცხენა რადიუსი"
+"Top right radius" = "ზედა მარჯვენა რადიუსი"
+"Transform" = "გარდაქმნა"
+"Triangle" = "სამკუთხედი"
+"Triangle arrow" = "სამკუთხა ისარი"
+"Trigger" = "გამშვები"
+"True" = "ჭეშმარიტი"
+"Truncate text" = "ტექსტის შეკვეცა"
+"Truncate with an ellipsis" = "შეკვეცა მრავალწერტილით"
+"Try again" = "ხელახლა ცდა"
+"Try another search or filter." = "სცადეთ სხვა ძიება ან ფილტრი."
+"Try another search, or browse templates." = "სცადეთ სხვა ძიება ან დაათვალიერეთ შაბლონები."
+"Try another word, or look at every kind." = "სცადეთ სხვა სიტყვა ან ნახეთ ყველა სახეობა."
+"Turn a layer into a component, reuse it, and change every copy at once" = "შრე აქციეთ კომპონენტად, გამოიყენეთ ხელახლა და შეცვალეთ ყველა ასლი ერთდროულად"
+"Two digits" = "ორი ციფრი"
+"Type" = "ტიპი"
+"Type settings" = "ტექსტის პარამეტრები"
+"Type the join code you were given, or paste an invite link." = "შეიყვანეთ მოცემული შეერთების კოდი ან ჩასვით მოსაწვევი ბმული."
+"Typography" = "ტიპოგრაფია"
+"Underline" = "ხაზგასმული"
+"Undo takes back only your own changes; what others changed since stays." = "დაბრუნება მხოლოდ თქვენს ცვლილებებს აუქმებს; რაც სხვებმა ამასობაში შეცვალეს, რჩება."
+"Ungroup" = "დაჯგუფების მოხსნა"
+"Uniform" = "ერთგვაროვანი"
+"Union" = "გაერთიანება"
+"Unions" = "გაერთიანებები"
+"Unknown — treated as sRGB" = "უცნობი — განიხილება როგორც sRGB"
+"Unread" = "წაუკითხავი"
+"Unresolve" = "ხელახლა გახსნა"
+"Unsaved changes" = "შეუნახავი ცვლილებები"
+"Unsaved changes in {names}. Save them before closing?" = "შეუნახავი ცვლილებები: {names}. შევინახოთ დახურვამდე?"
+"Unsaved changes: save first ({save}), or close the tab with {alt}-click to discard" = "შეუნახავი ცვლილებები: ჯერ შეინახეთ ({save}) ან გასაუქმებლად დახურეთ ჩანართი {alt}+დაწკაპუნებით"
+"Unsaved changes: save first, or close again with {key} to discard" = "შეუნახავი ცვლილებები: ჯერ შეინახეთ ან გასაუქმებლად ხელახლა დახურეთ {key}-ით"
+"Up" = "ზემოთ"
+"Update plugin" = "პლაგინის განახლება"
+"Update" = "განახლება"
+"Update from main" = "მთავარიდან განახლება"
+"Update from selection" = "მონიშნულიდან განახლება"
+"Updated {components} and {styles}" = "განახლდა {components} და {styles}"
+"Updated {name}" = "განახლდა: {name}"
+"Updating the graphics driver often helps. To use OpenGL only, start FigCraft from a Command Prompt with:" = "ხშირად გრაფიკის დრაივერის განახლება შველის. მხოლოდ OpenGL-ის გამოსაყენებლად FigCraft გაუშვით ბრძანების სტრიქონიდან (Command Prompt) ასე:"
+"Updating the graphics driver often helps. WGPU_BACKEND (vulkan, gl, metal) names another graphics API to try." = "ხშირად გრაფიკის დრაივერის განახლება შველის. WGPU_BACKEND-ით (vulkan, gl, metal) შეგიძლიათ სხვა გრაფიკული API სცადოთ."
+"Uploads this file to a FigCraft server and keeps this tab in sync with it. You get a link to edit and a link to view." = "ტვირთავს ამ ფაილს FigCraft-ის სერვერზე და ამ ჩანართს მასთან სინქრონში ინახავს. მიიღებთ რედაქტირებისა და ნახვის ბმულებს."
+"Uppercase" = "მთავრული"
+"Use a fixed value" = "ფიქსირებული მნიშვნელობის გამოყენება"
+"Use an expression, e.g. count + 1" = "ექსპრესიის გამოყენება, მაგ. count + 1"
+"Use as mask" = "ნიღბად გამოყენება"
+"Use auto layout" = "ავტოგანლაგების გამოყენება"
+"Use number keys for opacity" = "გაუმჭვირვალობისთვის ციფრული კლავიშების გამოყენება"
+"Use the .figcraft or .fig extension." = "გამოიყენეთ .figcraft ან .fig გაფართოება."
+"Use the layer's fill" = "შრის შევსების გამოყენება"
+"Used in {files} · {instances}" = "გამოიყენება: {files} · {instances}"
+"Username" = "მომხმარებლის სახელი"
+"Value" = "მნიშვნელობა"
+"Uses variables: each layer shows them in its own mode" = "იყენებს ცვლადებს: თითოეული შრე მათ თავის რეჟიმში აჩვენებს"
+"Variable" = "ცვლადი"
+"Variable collections" = "ცვლადების კოლექციები"
+"Variable modes" = "ცვლადების რეჟიმები"
+"Variable width" = "ცვლადი სიგანე"
+"Variables" = "ცვლადები"
+"Variables JSON…" = "ცვლადების JSON…"
+"Variables store reusable values (colours, numbers, strings, booleans) with modes such as Light and Dark." = "ცვლადები ინახავს ხელახლა გამოსაყენებელ მნიშვნელობებს (ფერები, რიცხვები, სტრიქონები, ლოგიკური მნიშვნელობები) ისეთი რეჟიმებით, როგორიცაა ღია და მუქი."
+"Variant" = "ვარიანტი"
+"Vector" = "ვექტორი"
+"Vectors" = "ვექტორები"
+"Version" = "ვერსია"
+"Version history" = "ვერსიების ისტორია"
+"Version {version}" = "ვერსია {version}"
+"Version {v} · {components} · {styles} · {variables}" = "ვერსია {v} · {components} · {styles} · {variables}"
+"Vertical" = "ვერტიკალური"
+"Vertical align" = "ვერტიკალური სწორება"
+"Vertical hex" = "ვერტიკალური ექვსკუთხედი"
+"Vertical padding" = "ვერტიკალური შიდა დაშორება"
+"Vertical spacing" = "ვერტიკალური დაშორება"
+"Vertical trim" = "ვერტიკალური ჩამოჭრა"
+"View" = "ხედი"
+"View link" = "ნახვის ბმული"
+"View link copied" = "ნახვის ბმული დაკოპირდა"
+"View only" = "მხოლოდ ნახვა"
+"View only: you see every change as it happens but can't edit. Leave to keep a copy you can edit." = "მხოლოდ ნახვა: ყოველ ცვლილებას ხედავთ მისი მოხდენისთანავე, მაგრამ რედაქტირება არ შეგიძლიათ. რედაქტირებადი ასლის შესანარჩუნებლად გადით სესიიდან."
+"Viewing “{name}”" = "დათვალიერება: „{name}“"
+"Violet" = "იისფერი"
+"Visibility" = "ხილვადობა"
+"Visible" = "ხილული"
+"Vivid" = "ცოცხალი"
+"WGPU_BACKEND is set and names the graphics API to use; unsetting it lets FigCraft choose." = "WGPU_BACKEND დაყენებულია და გამოსაყენებელ გრაფიკულ API-ს განსაზღვრავს; მისი მოხსნის შემდეგ FigCraft თავად აირჩევს."
+"Warm" = "თბილი"
+"Watch" = "საათი"
+"Wavy" = "ტალღოვანი"
+"Web" = "ვები"
+"Websites" = "ვებსაიტები"
+"WebSocket URL" = "WebSocket URL"
+"WebSocket URL copied" = "WebSocket URL დაკოპირდა"
+"Wedge" = "სოლი"
+"Weight" = "სისქე"
+"What you try here changes this preview and the code below, not the file" = "რასაც აქ ცდით, ცვლის ამ გადახედვას და ქვემოთ კოდს და არა ფაილს"
+"What changed since it was marked ready for dev" = "რა შეიცვალა მზად დეველოპერისთვის მონიშვნის შემდეგ"
+"What is wrong with this file? The server's operator gets your report." = "რა არის ამ ფაილში არასწორი? სერვერის ოპერატორი მიიღებს თქვენს საჩივარს."
+"What it's for" = "რისთვისაა"
+"What this changed from isn't known: it changed before FigCraft kept a copy of ready-for-dev frames. Resolve the change (or mark it ready again) to compare from now on." = "არ არის ცნობილი, რისგან შეიცვალა: ცვლილება მოხდა მანამ, სანამ FigCraft მზად დეველოპერისთვის ჩარჩოების ასლებს შეინახავდა. გადაწყვიტეთ ცვლილება (ან ხელახლა მონიშნეთ მზადად), რომ ამიერიდან შედარდეს."
+"While hovering" = "მაჩვენებლის მიტანისას"
+"While pressing" = "დაჭერისას"
+"White" = "თეთრი"
+"Who runs it, its terms and how long it keeps files" = "ვინ მართავს, მისი პირობები და რამდენ ხანს ინახავს ფაილებს"
+"Why it changed" = "რატომ შეიცვალა"
+"Widget" = "ვიჯეტი"
+"Widgets" = "ვიჯეტები"
+"Width" = "სიგანე"
+"Width point" = "სიგანის წერტილი"
+"Width profile" = "სიგანის პროფილი"
+"Wireframe kit" = "კარკასების ნაკრები"
+"With the layers' export settings" = "შრეების ექსპორტის პარამეტრებით"
+"Wrap" = "გადატანა"
+"Wrap in new section" = "ახალ სექციაში მოქცევა"
+"Yellow" = "ყვითელი"
+"Yesterday" = "გუშინ"
+"You" = "თქვენ"
+"You'll get the shared file as a new tab and edit it together." = "გაზიარებულ ფაილს ახალ ჩანართად მიიღებთ და ერთად დაარედაქტირებთ."
+"You're spotlighting: everyone follows your view" = "ყურადღება თქვენზეა: ყველა თქვენს ხედს მიჰყვება"
+"Your copy of the file stays open" = "თქვენი ფაილის ასლი ღია რჩება"
+"Your copy stays open; the file stays on the server" = "თქვენი ასლი ღია რჩება; ფაილი სერვერზე რჩება"
+"Your name" = "თქვენი სახელი"
+"Your name in comments" = "თქვენი სახელი კომენტარებში"
+"Your system asks for reduced motion: animations stay off." = "თქვენი სისტემა ითხოვს მოძრაობის შემცირებას: ანიმაციები გამორთული რჩება."
+"Z" = "Z"
+"Z to A" = "ჰ-დან ა-მდე"
+"Zoom" = "მასშტაბი"
+"Zoom around the pointer" = "მასშტაბირება მაჩვენებლის გარშემო"
+"Zoom device to fill window" = "მოწყობილობის მასშტაბირება ფანჯრის შესავსებად"
+"Zoom in" = "გადიდება"
+"Zoom out" = "დაპატარავება"
+"Zoom to 100%" = "მასშტაბი 100%"
+"Zoom to 200%" = "მასშტაბი 200%"
+"Zoom to 50%" = "მასშტაბი 50%"
+"Zoom to fit" = "ეკრანში ჩატევა"
+"Zoom to selection" = "მონიშნულის მასშტაბირება"
+"Zoom tool: click to zoom in, drag an area" = "მასშტაბის ხელსაწყო: დაწკაპეთ გასადიდებლად, მონიშნეთ არე გადათრევით"
+"Zoom tool: zoom out" = "მასშტაბის ხელსაწყო: დაპატარავება"
+"and {n} more" = { one = "და კიდევ {n}", other = "და კიდევ {n}" }
+"bleed marks" = "ჭრისპირა არის ნიშნები"
+"by {author}" = "ავტორი: {author}"
+"call any command its access allows" = "ნებისმიერი ბრძანების გამოძახება, რასაც მისი წვდომა უშვებს"
+"call only: {commands}" = "მხოლოდ გამოძახება: {commands}"
+"can edit the document" = "შეუძლია დოკუმენტის რედაქტირება"
+"conditional prototype actions nested too deeply were skipped" = "ზედმეტად ღრმად ჩადგმული პირობითი მოქმედებები პროტოტიპში გამოტოვებულია"
+"conditional prototype actions with conditions that can't be evaluated were skipped" = "პროტოტიპის პირობითი მოქმედებები, რომელთა პირობების გამოთვლა ვერ ხერხდება, გამოტოვებულია"
+"connector label background was skipped: style data is missing" = "შემაერთებლის იარლიყის ფონი გამოტოვებულია: სტილის მონაცემები აკლია"
+"connector label was skipped: background bounds are invalid" = "შემაერთებლის იარლიყი გამოტოვებულია: ფონის საზღვრები არასწორია"
+"connector label was skipped: background transform is invalid" = "შემაერთებლის იარლიყი გამოტოვებულია: ფონის გარდაქმნა არასწორია"
+"connector label was skipped: composed text transform is invalid" = "შემაერთებლის იარლიყი გამოტოვებულია: ტექსტის შედგენილი გარდაქმნა არასწორია"
+"connector label was skipped: derived background bounds are missing" = "შემაერთებლის იარლიყი გამოტოვებულია: ფონის გამოთვლილი საზღვრები აკლია"
+"connector label was skipped: derived text bounds are missing" = "შემაერთებლის იარლიყი გამოტოვებულია: ტექსტის გამოთვლილი საზღვრები აკლია"
+"connector label was skipped: text bounds are invalid" = "შემაერთებლის იარლიყი გამოტოვებულია: ტექსტის საზღვრები არასწორია"
+"connector label was skipped: text style data is missing" = "შემაერთებლის იარლიყი გამოტოვებულია: ტექსტის სტილის მონაცემები აკლია"
+"connector label was skipped: text transform is invalid" = "შემაერთებლის იარლიყი გამოტოვებულია: ტექსტის გარდაქმნა არასწორია"
+"connector labels were skipped" = "შემაერთებლების იარლიყები გამოტოვებულია"
+"connector layers import as static frame/vector snapshots with labels when present; live endpoint bindings are not retained" = "შემაერთებლის შრეები იმპორტირდება ჩარჩოს ან ვექტორის სტატიკური სნეპშოტების სახით, იარლიყებით (თუ არის); ბოლოების ცოცხალი მიბმები არ ნარჩუნდება"
+"connector snapshot vector data is missing; connector was left empty" = "შემაერთებლის სნეპშოტის ვექტორული მონაცემები აკლია; შემაერთებელი ცარიელი დარჩა"
+"connectors whose ends can't be placed are empty" = "შემაერთებლები, რომელთა ბოლოების განთავსება ვერ ხერხდება, ცარიელია"
+"crop marks" = "ჭრის ნიშნები"
+"damaged vector geometry was skipped" = "დაზიანებული ვექტორული გეომეტრია გამოტოვებულია"
+"damaged vector networks import as outlines" = "დაზიანებული ვექტორული ქსელები კონტურებად იმპორტირდება"
+"development: {path}" = "დეველოპმენტი: {path}"
+"document children other than pages were skipped" = "დოკუმენტის ქვეელემენტები, რომლებიც გვერდები არ არის, გამოტოვებულია"
+"duplicate grid track sizing entries use equal tracks" = "ბადის ტრეკის ზომის დუბლირებული ჩანაწერებისას ტრეკები თანაბარია"
+"e.g. count + 1" = "მაგ. count + 1"
+"e.g. count >= 3 and not done" = "მაგ. count >= 3 and not done"
+"elbowed and curved connectors without a saved path import as straight lines" = "შენახული ტრაექტორიის გარეშე კუთხოვანი და მრუდი შემაერთებლები სწორ ხაზებად იმპორტირდება"
+"entries without a node type were skipped" = "კვანძის ტიპის გარეშე ჩანაწერები გამოტოვებულია"
+"figcraft:// links from a browser, chat or email open this app and join the session." = "ბრაუზერიდან, ჩატიდან ან ელფოსტიდან figcraft:// ბმულები ხსნის ამ აპს და უერთდება სესიას."
+"filled areas of a vector with their own fill use the layer's fill" = "ვექტორის შევსებული არეები საკუთარი შევსებით შრის შევსებას იყენებს"
+"from {server}" = "წყარო: {server}"
+"gamepad triggers without exactly one known controller button were skipped" = "გეიმპადის გამშვებები, რომლებსაც ზუსტად ერთი ცნობილი კონტროლერის ღილაკი არ აქვს, გამოტოვებულია"
+"grid track list exceeds 1000 entries; the tracks use the default equal sizing" = "ბადის ტრეკების სია 1000 ჩანაწერს აღემატება; ტრეკები ნაგულისხმევ თანაბარ ზომებს იყენებს"
+"grid track sizing is unsupported or malformed; affected tracks use equal sizing" = "ბადის ტრეკის ზომა მხარდაუჭერელი ან დაზიანებულია; შესაბამისი ტრეკები თანაბარ ზომებს იყენებს"
+"grid track sizing list exceeds 1000 entries; the tracks use the default equal sizing" = "ბადის ტრეკების ზომების სია 1000 ჩანაწერს აღემატება; ტრეკები ნაგულისხმევ თანაბარ ზომებს იყენებს"
+"hidden" = "დამალული"
+"iOS" = "iOS"
+"image filters are ambiguous because both filter containers are present; filter conversion was skipped" = "გამოსახულების ფილტრები ორაზროვანია, რადგან ფილტრების ორივე კონტეინერია მოცემული; ფილტრების გარდაქმნა გამოტოვებულია"
+"image filters use FigCraft's approximate renderer" = "გამოსახულების ფილტრები FigCraft-ის მიახლოებითი რენდერით გამოისახება"
+"instance swap properties whose default component isn't in the file were skipped" = "ინსტანსის ჩანაცვლების თვისებები, რომელთა ნაგულისხმევი კომპონენტი ფაილში არ არის, გამოტოვებულია"
+"instances inside their own main component were imported as frames" = "საკუთარი მთავარი კომპონენტის შიგნით მყოფი ინსტანსები ჩარჩოებად იმპორტირდა"
+"instances of components that aren't in the file show no layers" = "იმ კომპონენტების ინსტანსები, რომლებიც ფაილში არ არის, შრეებს არ აჩვენებს"
+"instances of components that aren't in the file were imported as frames" = "იმ კომპონენტების ინსტანსები, რომლებიც ფაილში არ არის, ჩარჩოებად იმპორტირდა"
+"instances that would nest a component inside itself were imported as frames" = "ინსტანსები, რომლებიც კომპონენტს საკუთარ თავში ჩადგამდა, ჩარჩოებად იმპორტირდა"
+"instances without a main component were imported as empty frames" = "მთავარი კომპონენტის გარეშე ინსტანსები ცარიელ ჩარჩოებად იმპორტირდა"
+"invalid internal .fig text path data was ignored" = ".fig-ის შიდა ტექსტის ტრაექტორიის არასწორი მონაცემები იგნორირებულია"
+"invalid or oversized vector networks import as outlines" = "არასწორი ან ზედმეტად დიდი ვექტორული ქსელები კონტურებად იმპორტირდება"
+"invalid or oversized vector path data was skipped" = "ვექტორული ტრაექტორიის არასწორი ან ზედმეტად დიდი მონაცემები გამოტოვებულია"
+"just now" = "ახლახან"
+"key triggers without a supported key were skipped" = "მხარდაჭერილი კლავიშის გარეშე კლავიშის გამშვებები გამოტოვებულია"
+"key up triggers import as key presses" = "კლავიშის აშვების გამშვებები კლავიშის დაჭერებად იმპორტირდება"
+"layers without a position were placed at their parent's origin" = "პოზიციის გარეშე შრეები მშობლის საწყის წერტილში განთავსდა"
+"layers without a type were skipped" = "ტიპის გარეშე შრეები გამოტოვებულია"
+"legacy image filter container is unsupported; filter conversion was skipped" = "გამოსახულების ფილტრების ძველი კონტეინერი მხარდაუჭერელია; ფილტრების გარდაქმნა გამოტოვებულია"
+"locked" = "ჩაკეტილი"
+"malformed image filters container was skipped" = "გამოსახულების ფილტრების დაზიანებული კონტეინერი გამოტოვებულია"
+"malformed image paintFilter container was skipped" = "გამოსახულების paintFilter-ის დაზიანებული კონტეინერი გამოტოვებულია"
+"malformed slot content assignment was skipped" = "სლოტის შიგთავსის დაზიანებული მინიჭება გამოტოვებულია"
+"no bleed" = "ჭრისპირა არის გარეშე"
+"nobody else here yet" = "აქ ჯერ სხვა არავინაა"
+"non-default slot settings are not represented and were skipped" = "სლოტის არანაგულისხმევი პარამეტრები არ არის წარმოდგენილი და გამოტოვებულია"
+"now" = "ახლა"
+"only in a text style or variable" = "მხოლოდ ტექსტის სტილში ან ცვლადში"
+"or" = "ან"
+"point stroke joins were preserved; dashed or variable-width strokes render with the layer join" = "წერტილების კონტურის შეერთებები შენარჩუნებულია; ტირეებიანი ან ცვლადი სისქის კონტურები შრის შეერთებით გამოისახება"
+"preferred slot component keys cannot be resolved to file nodes and were skipped" = "სლოტის სასურველი კომპონენტების გასაღებები ფაილის კვანძებთან ვერ დაკავშირდა და გამოტოვებულია"
+"prototype actions of unknown types were skipped" = "უცნობი ტიპის პროტოტიპის მოქმედებები გამოტოვებულია"
+"prototype actions without a destination in the file were skipped" = "პროტოტიპის მოქმედებები, რომელთა დანიშნულება ფაილში არ არის, გამოტოვებულია"
+"prototype expressions on variables that aren't in the variables JSON were skipped" = "პროტოტიპის ექსპრესიები იმ ცვლადებზე, რომლებიც ცვლადების JSON-ში არ არის, გამოტოვებულია"
+"prototype expressions with unsupported functions were skipped" = "მხარდაუჭერელი ფუნქციების შემცველი პროტოტიპის ექსპრესიები გამოტოვებულია"
+"prototype interactions without supported actions were skipped" = "მხარდაჭერილი მოქმედებების გარეშე პროტოტიპის ურთიერთქმედებები გამოტოვებულია"
+"prototype navigations of unknown types were skipped" = "უცნობი ტიპის პროტოტიპის ნავიგაციები გამოტოვებულია"
+"prototype transitions of unknown types play instantly" = "უცნობი ტიპის პროტოტიპის გადასვლები მყისიერად სრულდება"
+"prototype triggers of unknown types were skipped" = "უცნობი ტიპის პროტოტიპის გამშვებები გამოტოვებულია"
+"put a widget on the canvas" = "ვიჯეტის ტილოზე განთავსება"
+"read and edit the document" = "დოკუმენტის წაკითხვა და რედაქტირება"
+"read the document" = "დოკუმენტის წაკითხვა"
+"reads the document" = "კითხულობს დოკუმენტს"
+"set-variable actions on variables that aren't in the variables JSON were skipped" = "ცვლადის დაყენების მოქმედებები იმ ცვლადებზე, რომლებიც ცვლადების JSON-ში არ არის, გამოტოვებულია"
+"set-variable actions with values that can't be evaluated were skipped" = "ცვლადის დაყენების მოქმედებები, რომელთა მნიშვნელობის გამოთვლა ვერ ხერხდება, გამოტოვებულია"
+"set-variable actions with values that don't fit the variable were skipped" = "ცვლადის დაყენების მოქმედებები, რომელთა მნიშვნელობა ცვლადს არ შეესაბამება, გამოტოვებულია"
+"set-variable actions without a value were skipped" = "მნიშვნელობის გარეშე ცვლადის დაყენების მოქმედებები გამოტოვებულია"
+"set-variable-mode actions on collections or modes that aren't in the variables JSON were skipped" = "ცვლადის რეჟიმის დაყენების მოქმედებები იმ კოლექციებზე ან რეჟიმებზე, რომლებიც ცვლადების JSON-ში არ არის, გამოტოვებულია"
+"slot content assignment target is missing or is not slot content" = "სლოტის შიგთავსის მინიჭების სამიზნე აკლია ან სლოტის შიგთავსი არ არის"
+"slot content assignment uses the empty GUID sentinel and was skipped" = "სლოტის შიგთავსის მინიჭება ცარიელ GUID მარკერს იყენებს და გამოტოვებულია"
+"slot layers without a matching slot property were imported as frames" = "სლოტის შრეები, რომლებსაც შესაბამისი სლოტის თვისება არ აქვს, ჩარჩოებად იმპორტირდა"
+"some vector points refer to point settings missing from the file; they use the layer's joins and plain corners" = "ზოგი ვექტორული წერტილი მიუთითებს წერტილის პარამეტრებზე, რომლებიც ფაილს აკლია; ისინი შრის შეერთებებსა და ჩვეულებრივ კუთხეებს იყენებს"
+"some vector segments refer to style settings missing from the file; they use the layer's stroke" = "ზოგი ვექტორული სეგმენტი მიუთითებს სტილის პარამეტრებზე, რომლებიც ფაილს აკლია; ისინი შრის კონტურს იყენებს"
+"stale or invalid grid track sizing entries were ignored" = "ბადის ტრეკის ზომის მოძველებული ან არასწორი ჩანაწერები იგნორირებულია"
+"stars and polygons without point counts or geometry use the default point count" = "ვარსკვლავები და მრავალკუთხედები წვეროების რაოდენობის ან გეომეტრიის გარეშე წვეროების ნაგულისხმევ რაოდენობას იყენებს"
+"style settings of some vector segments aren't supported; those segments use the layer's stroke" = "ზოგი ვექტორული სეგმენტის სტილის პარამეტრები მხარდაუჭერელია; ეს სეგმენტები შრის კონტურს იყენებს"
+"text path underline or strikethrough decoration is not rendered" = "ტრაექტორიაზე განთავსებული ტექსტის ხაზგასმა ან გადახაზვა არ გამოისახება"
+"text style overrides refer to missing table entries" = "ტექსტის სტილის გადაფარვები ცხრილის არარსებულ ჩანაწერებზე მიუთითებს"
+"the file has no pages" = "ფაილს გვერდები არ აქვს"
+"the plugin" = "პლაგინი"
+"the variables JSON has no `variableCollections` (expected the local variables response) and was ignored" = "ცვლადების JSON-ს `variableCollections` არ აქვს (მოსალოდნელი იყო ლოკალური ცვლადების პასუხი) და იგნორირებულია"
+"this session only" = "მხოლოდ ეს სესია"
+"unknown component property types were skipped" = "კომპონენტის თვისებების უცნობი ტიპები გამოტოვებულია"
+"variable aliases to variables that aren't in the variables JSON (or of another type) were skipped" = "ცვლადის ალიასები იმ ცვლადებზე, რომლებიც ცვლადების JSON-ში არ არის (ან სხვა ტიპისაა), გამოტოვებულია"
+"variable bindings to properties the layer doesn't have were skipped" = "ცვლადების მიბმები იმ თვისებებზე, რომლებიც შრეს არ აქვს, გამოტოვებულია"
+"variable bindings to variables that aren't in the variables JSON (library variables) were skipped" = "ცვლადების მიბმები იმ ცვლადებზე, რომლებიც ცვლადების JSON-ში არ არის (ბიბლიოთეკის ცვლადები), გამოტოვებულია"
+"variable bindings were skipped: the file JSON has no variable definitions (pass the local variables JSON as `variables`, or embed its `meta` next to the file JSON)" = "ცვლადების მიბმები გამოტოვებულია: ფაილის JSON-ში ცვლადების განსაზღვრებები არ არის (გადაეცით ლოკალური ცვლადების JSON როგორც `variables`, ან ჩააშენეთ მისი `meta` ფაილის JSON-ის გვერდით)"
+"variable bindings whose variable type doesn't fit the property were skipped" = "ცვლადების მიბმები, რომელთა ცვლადის ტიპი თვისებას არ შეესაბამება, გამოტოვებულია"
+"variable collections without modes were skipped" = "რეჟიმების გარეშე ცვლადების კოლექციები გამოტოვებულია"
+"variable mode lookups in prototype expressions that aren't a variable and one of its modes were skipped" = "პროტოტიპის ექსპრესიებში ცვლადის რეჟიმის მოძიებები, რომლებიც ცვლადსა და მის ერთ-ერთ რეჟიმს არ წარმოადგენს, გამოტოვებულია"
+"variable modes of collections that aren't in the file were skipped" = "იმ კოლექციების ცვლადის რეჟიმები, რომლებიც ფაილში არ არის, გამოტოვებულია"
+"variable modes of collections that aren't in the variables JSON were skipped" = "იმ კოლექციების ცვლადის რეჟიმები, რომლებიც ცვლადების JSON-ში არ არის, გამოტოვებულია"
+"variable values that don't match their type (or composed colours) were skipped" = "ცვლადის მნიშვნელობები, რომლებიც თავიანთ ტიპს არ შეესაბამება (ან შედგენილი ფერები), გამოტოვებულია"
+"variables of unknown types were skipped" = "უცნობი ტიპის ცვლადები გამოტოვებულია"
+"variables whose collection isn't in the variables JSON were skipped" = "ცვლადები, რომელთა კოლექცია ცვლადების JSON-ში არ არის, გამოტოვებულია"
+"variables without readable values were skipped" = "წაკითხვადი მნიშვნელობების გარეშე ცვლადები გამოტოვებულია"
+"vector points with unknown stroke joins use the layer join" = "უცნობი კონტურის შეერთების მქონე ვექტორული წერტილები შრის შეერთებას იყენებს"
+"vectors without geometry are empty" = "გეომეტრიის გარეშე ვექტორები ცარიელია"
+"vectors without geometry are empty (export the file JSON with geometry=paths)" = "გეომეტრიის გარეშე ვექტორები ცარიელია (ფაილის JSON-ის ექსპორტი გააკეთეთ geometry=paths პარამეტრით)"
+"very long text was cut to 1,048,576 characters" = "ძალიან გრძელი ტექსტი 1 048 576 სიმბოლომდე შემოკლდა"
+"very long vector paths were skipped" = "ძალიან გრძელი ვექტორული ტრაექტორიები გამოტოვებულია"
+"video actions are not supported and were skipped" = "ვიდეოს მოქმედებები მხარდაუჭერელია და გამოტოვებულია"
+"video triggers are not supported and were skipped" = "ვიდეოს გამშვებები მხარდაუჭერელია და გამოტოვებულია"
+"yesterday" = "გუშინ"
+"{instances} in {files}" = "{instances} — {files}"
+"{language}: draft translation, waiting for a native speaker's review." = "{language}: თარგმანის მონახაზი, ელოდება მშობლიური ენის მცოდნის განხილვას."
+"{length} bleed" = "ჭრისპირა არე: {length}"
+"{month} {day}, {year}" = "{day} {month}, {year}"
+"{name} cleared from the list" = "{name} ამოიშალა სიიდან"
+"{name} is forgotten on this computer; the file stays on {server}" = "{name} დავიწყებულია ამ კომპიუტერზე; ფაილი {server}-ზე რჩება"
+"{name} is on the server." = "{name} სერვერზეა."
+"{name} is spotlighting" = "ყურადღება {name}-ზეა"
+"{name}\nClick to apply to the selection" = "{name}\nდაწკაპეთ მონიშნულზე გამოსაყენებლად"
+"{name}\nDrag onto the canvas, or click to place in the middle of the view.\nHold Alt (Option) while dropping onto an instance to swap it." = "{name}\nგადაათრიეთ ტილოზე ან დაწკაპეთ ხედის შუაში განსათავსებლად.\nინსტანსის ჩასანაცვლებლად მასზე ჩაგდებისას დააჭირეთ Alt-ს (Option)."
+"{name} (from {library})" = "{name} ({library}-იდან)"
+"{name} (you)" = "{name} (თქვენ)"
+"{name} ({layers} layers)" = "{name} (შრე: {layers})"
+"{name} ({tag}): {min} – {max}, default {default}. Double-click the slider to go back to the style's value; Escape while dragging cancels." = "{name} ({tag}): {min} – {max}, ნაგულისხმევი {default}. სტილის მნიშვნელობაზე დასაბრუნებლად ორჯერ დაწკაპეთ სლაიდერზე; Escape გადათრევისას აუქმებს."
+"{name} from {path}" = "{name} — {path}"
+"{name} was removed from the server" = "{name} წაიშალა სერვერიდან"
+"{name} · deleted on main" = "{name} · წაშლილია მთავარში"
+"{name} · deleted on the branch" = "{name} · წაშლილია განშტოებაში"
+"{name} · not published" = "{name} · არ არის გამოქვეყნებული"
+"{name} · on a server" = "{name} · სერვერზე"
+"{name} · published version {v}" = "{name} · გამოქვეყნებული ვერსია {v}"
+"{name} · version {v} on the server" = "{name} · ვერსია {v} სერვერზე"
+"{name}, in a live session" = "{name}, ცოცხალ სესიაში"
+"{name}, online, open only to you" = "{name}, ონლაინ, ღიაა მხოლოდ თქვენთვის"
+"{name}, {kind}, {w} by {h}, selected" = "{name}, {kind}, {w} × {h}, მონიშნულია"
+"{n} added" = { one = "დამატებულია: {n}", other = "დამატებულია: {n}" }
+"{n} autosave versions" = { one = "ავტოშენახული ვერსია: {n}", other = "ავტოშენახული ვერსია: {n}" }
+"{n} changed" = { one = "შეცვლილია: {n}", other = "შეცვლილია: {n}" }
+"{n} columns" = { one = "სვეტი: {n}", other = "სვეტი: {n}" }
+"{n} components" = { one = "კომპონენტი: {n}", other = "კომპონენტი: {n}" }
+"{n} components and styles have newer versions" = { one = "ახალი ვერსია აქვს კომპონენტს ან სტილს: {n}", other = "ახალი ვერსია აქვს კომპონენტს ან სტილს: {n}" }
+"{n} conflicts to resolve" = { one = "გადასაწყვეტი კონფლიქტი: {n}", other = "გადასაწყვეტი კონფლიქტი: {n}" }
+"{n} days ago" = { one = "{n} დღის წინ", other = "{n} დღის წინ" }
+"{n} files" = { one = "ფაილი: {n}", other = "ფაილი: {n}" }
+"{n} hours ago" = { one = "{n} საათის წინ", other = "{n} საათის წინ" }
+"{n} instances" = { one = "ინსტანსი: {n}", other = "ინსტანსი: {n}" }
+"{n} layers" = { one = "შრე: {n}", other = "შრე: {n}" }
+"{n} layers as one file" = { one = "შრე: {n}, ერთ ფაილად", other = "შრე: {n}, ერთ ფაილად" }
+"{n} layers selected" = { one = "მონიშნული შრე: {n}", other = "მონიშნული შრე: {n}" }
+"{n} layers · {parts}" = { one = "შრე: {n} · {parts}", other = "შრე: {n} · {parts}" }
+"{n} matches" = { one = "დამთხვევა: {n}", other = "დამთხვევა: {n}" }
+"{n} minutes ago" = { one = "{n} წუთის წინ", other = "{n} წუთის წინ" }
+"{n} months ago" = { one = "{n} თვის წინ", other = "{n} თვის წინ" }
+"{n} more notes omitted from this report" = { one = "ამ ანგარიშიდან გამოტოვებული სხვა შენიშვნები: {n}", other = "ამ ანგარიშიდან გამოტოვებული სხვა შენიშვნები: {n}" }
+"{n} of {total}" = "{n} / {total}"
+"{n} people joined" = { one = "შემოუერთდა ადამიანი: {n}", other = "შემოუერთდა ადამიანი: {n}" }
+"{n} preferred components" = { one = "სასურველი კომპონენტი: {n}", other = "სასურველი კომპონენტი: {n}" }
+"{n} ready" = { one = "მზადაა: {n}", other = "მზადაა: {n}" }
+"{n} removed" = { one = "წაშლილია: {n}", other = "წაშლილია: {n}" }
+"{n} replies" = { one = "პასუხი: {n}", other = "პასუხი: {n}" }
+"{n} rows" = { one = "სტრიქონი: {n}", other = "სტრიქონი: {n}" }
+"{n} styles" = { one = "სტილი: {n}", other = "სტილი: {n}" }
+"{n} text layers" = { one = "ტექსტის შრე: {n}", other = "ტექსტის შრე: {n}" }
+"{n} variables" = { one = "ცვლადი: {n}", other = "ცვლადი: {n}" }
+"{n} weeks ago" = { one = "{n} კვირის წინ", other = "{n} კვირის წინ" }
+"{n} years ago" = { one = "{n} წლის წინ", other = "{n} წლის წინ" }
+"{n}d" = "{n} დღ"
+"{n}h" = "{n} სთ"
+"{n}m" = "{n} წთ"
+"{n}w" = "{n} კვ"
+"{page}, nothing selected" = "{page}, არაფერია მონიშნული"
+"{profile} (current)" = "{profile} (მიმდინარე)"
+"{property} is its value; {property ? \"a\" : \"b\"} picks a string. Other {…} stays as written." = "{property} მისი მნიშვნელობაა; {property ? \"a\" : \"b\"} ირჩევს სტრიქონს. ნებისმიერი სხვა {…} რჩება დაწერილი სახით."
+"{server} can't say what became of your files (it is older than this app)." = "{server} ვერ გეტყვით, რა მოუვიდა თქვენს ფაილებს (ის ამ აპზე ძველია)."
+"{server} · No longer on the server" = "{server} · სერვერზე აღარ არის"
+"{server} · {shared} · Opened {date}" = "{server} · {shared} · გაიხსნა {date}"
+"{tool}  hold {key}" = "{tool}  დააჭირეთ {key}"
+"{value} isn't a colour" = "{value} ფერი არ არის"
+"{when} · edited" = "{when} · რედაქტირებულია"
+"← ↑ → ↓" = "← ↑ → ↓"
+"← → ↑ ↓" = "← → ↑ ↓"
+"←" = "←"
+"→, Space or N" = "→, Space ან N"
+"↵" = "↵"
+"⇥ / ⇧⇥" = "⇥ / ⇧⇥"
+"⌘ arrows" = "⌘ ისრები"
+"⌘ click" = "⌘ დაწკაპუნება"
+"⌘ scroll" = "⌘ გადახვევა"
+"⌥ drag" = "⌥ გადათრევა"
+
+[commands]
+"align.bottom" = "ქვემოთ სწორება"
+"align.hcenter" = "ჰორიზონტალური ცენტრების სწორება"
+"align.left" = "მარცხნივ სწორება"
+"align.right" = "მარჯვნივ სწორება"
+"align.top" = "ზემოთ სწორება"
+"align.vcenter" = "ვერტიკალური ცენტრების სწორება"
+"annotation.add" = "ანოტაციის დამატება"
+"annotation.addCategory" = "ანოტაციის კატეგორიის დამატება"
+"annotation.categories" = "ანოტაციის კატეგორიები"
+"annotation.edit" = "ანოტაციის რედაქტირება"
+"annotation.editCategory" = "ანოტაციის კატეგორიის რედაქტირება"
+"annotation.list" = "ანოტაციების სია"
+"annotation.remove" = "ანოტაციის წაშლა"
+"annotation.removeCategory" = "ანოტაციის კატეგორიის წაშლა"
+"app.actions" = "მოქმედებები"
+"app.preferences" = "პარამეტრები"
+"arrange.back" = "უკანა პლანზე გადატანა"
+"arrange.backward" = "უკან გადატანა"
+"arrange.forward" = "წინ გადმოტანა"
+"arrange.front" = "წინა პლანზე გადმოტანა"
+"arrange.packH" = "ჰორიზონტალურად შეკვრა"
+"arrange.packV" = "ვერტიკალურად შეკვრა"
+"arrange.roundToPixels" = "პიქსელებამდე დამრგვალება"
+"arrange.spacing" = "ინტერვალი"
+"arrange.tidy" = "მოწესრიგება"
+"board.connector" = "შემაერთებელი"
+"board.ink" = "მარკერის შტრიხი"
+"board.label" = "შემაერთებლის წარწერა"
+"board.nextSticky" = "შემდეგი სტიკერი"
+"board.setColor" = "დაფის ფერი"
+"board.setStyle" = "დაფის სტილი"
+"board.shape" = "ფიგურა ტექსტით"
+"board.stamp" = "შტამპი"
+"board.sticky" = "სტიკერი"
+"bool.exclude" = "მონიშნულის გამორიცხვა"
+"bool.flatten" = "ლოგიკური ოპერაციის გაბრტყელება"
+"bool.intersect" = "მონიშნულის გადაკვეთა"
+"bool.subtract" = "მონიშნულის გამოკლება"
+"bool.union" = "მონიშნულის გაერთიანება"
+"branch.archive" = "განშტოების დაარქივება"
+"branch.create" = "განშტოების შექმნა"
+"branch.list" = "განშტოებების სია"
+"branch.merge" = "განშტოების შერწყმა"
+"branch.open" = "განშტოების გახსნა"
+"branch.review" = "განშტოების განხილვა"
+"branch.updateFromMain" = "მთავარიდან განახლება"
+"codeConnect.export" = "კოდთან კავშირების ექსპორტირება"
+"codeConnect.import" = "კოდთან კავშირების იმპორტი"
+"codeConnect.remove" = "კოდთან კავშირის გაწყვეტა"
+"codeConnect.set" = "კოდთან დაკავშირება"
+"collab.cursor" = "კურსორის ჩვენება მდებარეობაზე"
+"collab.cursorChat" = "კურსორის ჩატი"
+"collab.diff" = "სინქრონიზებული ცვლილებების ჩვენება"
+"collab.files" = "თქვენი ონლაინ ფაილები"
+"collab.follow" = "მიყოლა"
+"collab.forgetFile" = "ონლაინ ფაილის დავიწყება"
+"collab.host" = "ცოცხალი სესიის დაწყება"
+"collab.join" = "ცოცხალ სესიასთან შეერთება"
+"collab.leave" = "ცოცხალი სესიიდან გასვლა"
+"collab.manageFile" = "გამოქვეყნებული ფაილის მართვა"
+"collab.openFile" = "ონლაინ ფაილის გახსნა"
+"collab.peers" = "ამ ფაილში მყოფი ადამიანები"
+"collab.publish" = "სერვერზე გამოქვეყნება"
+"collab.recoverFile" = "ონლაინ ფაილის აღდგენა"
+"collab.registerLinks" = "მოსაწვევი ბმულების FigCraft-ში გახსნა"
+"collab.removePerson" = "სესიიდან მოცილება"
+"collab.report" = "ფაილზე საჩივარი სერვერის ოპერატორთან"
+"collab.serverInfo" = "სერვერის ინფორმაცია"
+"collab.share" = "შეერთების კოდით გაზიარება"
+"collab.spotlight" = "ჩემზე ყურადღების გამახვილება"
+"collab.stop" = "ცოცხალი სესიის შეწყვეტა"
+"command.batch" = "რამდენიმე ბრძანების გაშვება"
+"comment.add" = "კომენტარის დამატება"
+"comment.delete" = "კომენტარის წაშლა"
+"comment.edit" = "კომენტარის რედაქტირება"
+"comment.link" = "კომენტარის ბმულის კოპირება"
+"comment.list" = "კომენტარების სია"
+"comment.markRead" = "კომენტარის წაკითხულად მარკირება"
+"comment.move" = "კომენტარის გადატანა"
+"comment.next" = "შემდეგი კომენტარი"
+"comment.open" = "კომენტარის გახსნა"
+"comment.people" = "კომენტარებში მონაწილე ადამიანები"
+"comment.react" = "კომენტარზე რეაგირება"
+"comment.reply" = "კომენტარზე პასუხი"
+"comment.resolve" = "კომენტარის გადაწყვეტა"
+"comment.zoom" = "კომენტარების მასშტაბირება"
+"component.addProperty" = "კომპონენტის თვისების დამატება"
+"component.addVariant" = "ვარიანტის დამატება"
+"component.bindProperty" = "შრის თვისებაზე მიბმა"
+"component.combineVariants" = "ვარიანტებად გაერთიანება"
+"component.create" = "კომპონენტის შექმნა"
+"component.createMultiple" = "რამდენიმე კომპონენტის შექმნა"
+"component.deleteProperty" = "კომპონენტის თვისების წაშლა"
+"component.detach" = "ინსტანსის გამოყოფა"
+"component.editProperty" = "კომპონენტის თვისების რედაქტირება"
+"component.exposeInstance" = "ჩადგმული ინსტანსის გამოტანა"
+"component.goToMain" = "მთავარ კომპონენტზე გადასვლა"
+"component.hideWhenPublishing" = "გამოქვეყნებისას დამალვა"
+"component.list" = "კომპონენტების სია"
+"component.makeSlot" = "სლოტად გადაქცევა"
+"component.playground" = "კომპონენტის სავარჯიშო მოედანი"
+"component.properties" = "კომპონენტის თვისებები"
+"component.pushChanges" = "ცვლილებების მთავარ კომპონენტში გადაგზავნა"
+"component.removeSlot" = "სლოტის მოხსნა"
+"component.resetInstance" = "ყველა ცვლილების ჩამოყრა"
+"component.resetOverride" = "გადაფარვის ჩამოყრა"
+"component.restoreMain" = "მთავარი კომპონენტის აღდგენა"
+"dev.compare" = "ცვლილებების შედარება"
+"dev.focus" = "ფოკუსის ხედი"
+"dev.resolveChange" = "ცვლილების გადაწყვეტა"
+"dev.unfocus" = "ფოკუსის ხედიდან გასვლა"
+"devResource.add" = "დეველოპერის რესურსის დამატება"
+"devResource.edit" = "დეველოპერის რესურსის რედაქტირება"
+"devResource.list" = "დეველოპერის რესურსების სია"
+"devResource.remove" = "დეველოპერის რესურსის წაშლა"
+"distribute.horizontal" = "ჰორიზონტალური შუალედების განაწილება"
+"distribute.vertical" = "ვერტიკალური შუალედების განაწილება"
+"doc.home" = "საწყისი ეკრანი"
+"doc.list" = "დოკუმენტების სია"
+"doc.nextTab" = "შემდეგი ჩანართი"
+"doc.previousTab" = "წინა ჩანართი"
+"doc.switch" = "დოკუმენტის გადართვა"
+"edit.copy" = "კოპირება"
+"edit.copyAsCss" = "კოპირება როგორც CSS"
+"edit.copyAsPng" = "კოპირება როგორც PNG"
+"edit.copyAsSvg" = "კოპირება როგორც SVG"
+"edit.copyAsText" = "კოპირება როგორც ტექსტი"
+"edit.copyLink" = "მონიშნულის ბმულის კოპირება"
+"edit.copyProperties" = "თვისებების კოპირება"
+"edit.cut" = "ამოჭრა"
+"edit.delete" = "წაშლა"
+"edit.duplicate" = "დუბლირება"
+"edit.findReplace" = "ძებნა და ჩანაცვლება"
+"edit.paste" = "ჩასმა"
+"edit.pasteDesignLayers" = "დიზაინის შრეების ჩასმა"
+"edit.pasteOver" = "მონიშნულზე ჩასმა"
+"edit.pasteProperties" = "თვისებების ჩასმა"
+"edit.pasteReplace" = "ჩასმა ჩასანაცვლებლად"
+"edit.pickColor" = "ფერის არჩევა"
+"edit.redo" = "ხელახლა შესრულება"
+"edit.repeat" = "ბოლო ბრძანების გამეორება"
+"edit.setDefaultProperties" = "ნაგულისხმევი თვისებების დაყენება"
+"edit.undo" = "დაბრუნება"
+"effect.add" = "ეფექტის დამატება"
+"effect.move" = "ეფექტის გადატანა"
+"effect.remove" = "ეფექტის წაშლა"
+"effect.set" = "ეფექტის დაყენება"
+"export.add" = "ექსპორტის პარამეტრის დამატება"
+"export.remove" = "ექსპორტის პარამეტრის წაშლა"
+"export.update" = "ექსპორტის პარამეტრის რედაქტირება"
+"file.close" = "ჩანართის დახურვა"
+"file.colorProfile" = "ფერის პროფილი"
+"file.duplicate" = "ფაილის დუბლირება"
+"file.export" = "ექსპორტირება"
+"file.exportFramesPdf" = "ჩარჩოების PDF-ად ექსპორტირება"
+"file.exportLayers" = "შრეების ექსპორტირება"
+"file.exportSvg" = "მონიშნულის SVG-ად ექსპორტირება"
+"file.import" = "იმპორტი"
+"file.new" = "ახალი დიზაინის ფაილი"
+"file.newBoard" = "ახალი დაფა"
+"file.newFromTemplate" = "შაბლონიდან შექმნა"
+"file.open" = "გახსნა"
+"file.openRecent" = "ბოლოს გახსნილი ფაილების გახსნა"
+"file.placeImage" = "გამოსახულების განთავსება"
+"file.recover" = "ფაილის აღდგენა"
+"file.rename" = "ფაილის სახელის შეცვლა"
+"file.revert" = "წინა ვერსიაზე დაბრუნება"
+"file.save" = "შენახვა"
+"file.saveAs" = "შენახვა როგორც"
+"file.saveVersion" = "ვერსიების ისტორიაში შენახვა"
+"file.versionHistory" = "ვერსიების ისტორიის ჩვენება"
+"fill.add" = "შევსების დამატება"
+"fill.move" = "შევსების გადატანა"
+"fill.pattern" = "პატერნით შევსება"
+"fill.remove" = "შევსების წაშლა"
+"fill.set" = "შევსების დაყენება"
+"frame.create" = "ჩარჩოს შექმნა"
+"frame.presets" = "ჩარჩოს პრესეტების სია"
+"frame.swapOrientation" = "ორიენტაციის შეცვლა"
+"grid.add" = "განლაგების ბადის დამატება"
+"grid.move" = "განლაგების ბადის გადატანა"
+"grid.remove" = "განლაგების ბადის წაშლა"
+"guide.add" = "დამხმარე ხაზის დამატება"
+"guide.clear" = "ყველა დამხმარე ხაზის წაშლა"
+"guide.move" = "დამხმარე ხაზის გადაადგილება"
+"guide.remove" = "დამხმარე ხაზის მოცილება"
+"guide.select" = "დამხმარე ხაზის მონიშვნა"
+"help.about" = "FigCraft-ის შესახებ"
+"help.gettingStarted" = "პირველი ნაბიჯები"
+"help.page" = "დახმარების გვერდი"
+"help.shortcuts" = "კლავიატურის მალსახმობები"
+"image.adjust" = "გამოსახულების კორექცია"
+"image.deletePreset" = "გამოსახულების პრესეტის წაშლა"
+"image.place" = "გამოსახულების განთავსება"
+"image.presets" = "გამოსახულების პრესეტები"
+"image.savePreset" = "გამოსახულების პრესეტის შენახვა"
+"inspect.assets" = "რესურსების ინსპექტირება"
+"inspect.code" = "შრის კოდი"
+"inspect.componentCode" = "კომპონენტის კოდი"
+"inspect.properties" = "თვისებების ინსპექტირება"
+"inspect.readyForDev" = "მზადაა დეველოპერისთვის"
+"instance.create" = "ინსტანსის შექმნა"
+"instance.exposed" = "გამოტანილი ჩადგმული ინსტანსები"
+"instance.place" = "ინსტანსის განთავსება"
+"instance.resetSlot" = "სლოტის ჩამოყრა"
+"instance.setProperties" = "ინსტანსის თვისებების დაყენება"
+"instance.slotInsert" = "სლოტში ჩასმა"
+"instance.swap" = "ინსტანსის ჩანაცვლება"
+"instance.swapAt" = "ინსტანსის ჩანაცვლება წერტილში"
+"layers.collapseAll" = "შრეების ჩაკეცვა"
+"layout.add" = "ავტოგანლაგების დამატება"
+"layout.remove" = "ავტოგანლაგების მოხსნა"
+"layout.setTrack" = "ბადის ტრეკის ზომის დაყენება"
+"layout.suggest" = "ავტოგანლაგების შეთავაზება"
+"libraries.open" = "ბიბლიოთეკები"
+"libraries.publish" = "ბიბლიოთეკის გამოქვეყნება…"
+"library.acceptUpdates" = "ბიბლიოთეკის განახლებების მიღება"
+"library.add" = "ბიბლიოთეკის დამატება"
+"library.aliasVariable" = "ბიბლიოთეკის ცვლადის ალიასი"
+"library.applyStyle" = "ბიბლიოთეკის სტილის გამოყენება"
+"library.bindVariable" = "ბიბლიოთეკის ცვლადის მიბმა"
+"library.extendCollection" = "ბიბლიოთეკის კოლექციის გაფართოება"
+"library.import" = "ბიბლიოთეკის კომპონენტის იმპორტი"
+"library.importVariable" = "ბიბლიოთეკის ცვლადის იმპორტი"
+"library.list" = "ბიბლიოთეკების სია"
+"library.place" = "ბიბლიოთეკის კომპონენტის განთავსება"
+"library.publish" = "ბიბლიოთეკის გამოქვეყნება"
+"library.publishToServer" = "ბიბლიოთეკის სერვერზე გამოქვეყნება"
+"library.remove" = "ბიბლიოთეკის წაშლა"
+"library.setVariableMode" = "ბიბლიოთეკის ცვლადის რეჟიმის დაყენება"
+"library.swap" = "ბიბლიოთეკის ჩანაცვლება"
+"library.swapAt" = "ინსტანსის ბიბლიოთეკის კომპონენტით ჩანაცვლება"
+"library.updates" = "ბიბლიოთეკის განახლებები"
+"library.usage" = "ბიბლიოთეკის გამოყენება"
+"measure.distances" = "მანძილების გაზომვა"
+"measure.padding" = "ავტოგანლაგების შიდა დაშორების გაზომვა"
+"node.create" = "შრის შექმნა"
+"node.get" = "შრის მიღება"
+"node.reorder" = "შრის გადალაგება"
+"node.reparent" = "შრის შიგნით გადატანა"
+"node.set" = "თვისებების დაყენება"
+"object.batchRename" = "ჯგუფური სახელის შეცვლა"
+"object.convertToFrame" = "ჩარჩოდ გარდაქმნა"
+"object.convertToGroup" = "ჯგუფად გარდაქმნა"
+"object.convertToSection" = "სექციად გარდაქმნა"
+"object.flipH" = "ჰორიზონტალურად არეკვლა"
+"object.flipV" = "ვერტიკალურად არეკვლა"
+"object.frameSelection" = "მონიშნულის ჩარჩოში მოქცევა"
+"object.group" = "ჯგუფის მონიშვნა"
+"object.hideOthers" = "სხვა შრეების დამალვა"
+"object.mask" = "ნიღბად გამოყენება"
+"object.moveToPage" = "გვერდზე გადატანა"
+"object.opacityKeys" = "გაუმჭვირვალობა ციფრული კლავიშებით"
+"object.rasterize" = "მონიშნულის რასტრირება"
+"object.releaseMask" = "ნიღბის მოხსნა"
+"object.removeFill" = "შევსების წაშლა"
+"object.removeFrame" = "ჩარჩოს მოხსნა"
+"object.removeStroke" = "კონტურის წაშლა"
+"object.rename" = "სახელის შეცვლა"
+"object.resizeToFit" = "შიგთავსზე ზომის მორგება"
+"object.rotate180" = "180°-ით შემობრუნება"
+"object.rotateLeft" = "90°-ით მარცხნივ შემობრუნება"
+"object.rotateRight" = "90°-ით მარჯვნივ შემობრუნება"
+"object.setThumbnail" = "ესკიზად დაყენება"
+"object.swapFillStroke" = "შევსებისა და კონტურის გაცვლა"
+"object.toggleLock" = "მონიშნულის ჩაკეტვა/განბლოკვა"
+"object.toggleVisible" = "მონიშნულის ჩვენება/დამალვა"
+"object.ungroup" = "მონიშნულის დაჯგუფების მოხსნა"
+"object.wrapInSection" = "ახალ სექციაში მოქცევა"
+"page.add" = "გვერდის დამატება"
+"page.delete" = "გვერდის წაშლა"
+"page.duplicate" = "გვერდის დუბლირება"
+"page.list" = "გვერდების სია"
+"page.move" = "გვერდის გადატანა"
+"page.rename" = "გვერდის სახელის შეცვლა"
+"page.select" = "გვერდზე გადასვლა"
+"page.setBackground" = "გვერდის ფონი"
+"paint.documentColors" = "დოკუმენტის ფერები"
+"plugin.close" = "პლაგინის პანელის დახურვა"
+"plugin.directory.install" = "პლაგინის ინსტალაცია კატალოგიდან"
+"plugin.directory.list" = "პლაგინების კატალოგის დათვალიერება"
+"plugin.directory.publish" = "პლაგინის კატალოგში გამოქვეყნება"
+"plugin.directory.unpublish" = "პლაგინის კატალოგიდან მოხსნა"
+"plugin.event" = "პლაგინის პანელის მართვის ელემენტის გამოყენება"
+"plugin.import" = "პლაგინის იმპორტი მანიფესტიდან…"
+"plugin.list" = "პლაგინების სია"
+"plugin.remove" = "პლაგინის წაშლა"
+"plugin.run" = "პლაგინის გაშვება"
+"plugin.ui" = "პლაგინის პანელი"
+"plugins.manage" = "პლაგინების მართვა…"
+"plugins.runLast" = "ბოლო პლაგინის გაშვება"
+"pref.autoSave" = "ფაილების ავტომატურად შენახვა"
+"pref.highlightHover" = "შრეების გამოკვეთა მაჩვენებლის მიტანისას"
+"pref.keepTool" = "ხელსაწყოს არჩეულად დატოვება გამოყენების შემდეგ"
+"pref.language" = "ინტერფეისის ენა"
+"pref.nudge" = "მცირედ გადაწევის ბიჯი"
+"pref.numberKeysOpacity" = "გაუმჭვირვალობისთვის ციფრული კლავიშების გამოყენება"
+"pref.publishServer" = "ონლაინ გაზიარების სერვერი"
+"pref.reduceMotion" = "მოძრაობის შემცირება"
+"pref.renameDuplicates" = "დუბლირებული შრეების სახელის შეცვლა"
+"pref.showDimensions" = "ზომების ჩვენება ობიექტებზე"
+"pref.userName" = "თქვენი სახელი კომენტარებში"
+"proto.action.add" = "პროტოტიპის მოქმედების დამატება"
+"proto.action.move" = "პროტოტიპის მოქმედების გადალაგება"
+"proto.action.remove" = "პროტოტიპის მოქმედების წაშლა"
+"proto.action.set" = "პროტოტიპის მოქმედების რედაქტირება"
+"proto.closePreview" = "პროტოტიპის წინასწარი ნახვის დახურვა"
+"proto.conditional.addBlock" = "„სხვა შემთხვევაში, თუ“ / „სხვა შემთხვევაში“-ს დამატება"
+"proto.conditional.removeBlock" = "„თუ“ / „სხვა შემთხვევაში, თუ“ / „სხვა შემთხვევაში“-ს წაშლა"
+"proto.conditional.setCondition" = "პირობის რედაქტირება"
+"proto.evaluate" = "პროტოტიპის ექსპრესიის გამოთვლა"
+"proto.flow.add" = "ნაკადის საწყისი წერტილის დამატება"
+"proto.flow.remove" = "ნაკადის წაშლა"
+"proto.flow.rename" = "ნაკადის სახელის შეცვლა"
+"proto.interaction.add" = "ურთიერთქმედების დამატება"
+"proto.interaction.clear" = "ყველა ურთიერთქმედების წაშლა"
+"proto.interaction.remove" = "ურთიერთქმედების წაშლა"
+"proto.interaction.set" = "ურთიერთქმედების რედაქტირება"
+"proto.present" = "წარდგენა"
+"proto.presentOptions" = "წარდგენის პარამეტრები"
+"proto.preview" = "პროტოტიპის წინასწარი ნახვის გახსნა"
+"proto.settings" = "პროტოტიპის პარამეტრები"
+"section.toggleContents" = "სექციის შიგთავსის დამალვა/ჩვენება"
+"select.add" = "მონიშნულზე დამატება"
+"select.all" = "ყველაფრის მონიშვნა"
+"select.area" = "არის მონიშვნა"
+"select.byName" = "შრეების სახელით მონიშვნა"
+"select.children" = "შვილობილების მონიშვნა"
+"select.inverse" = "მონიშვნის შებრუნება"
+"select.layersAt" = "შრეები წერტილში"
+"select.matching" = "შესაბამისი შრეების მონიშვნა"
+"select.next" = "შემდეგი მეზობლის მონიშვნა"
+"select.none" = "მონიშვნის მოხსნა"
+"select.parent" = "მშობლის მონიშვნა"
+"select.previous" = "წინა მეზობლის მონიშვნა"
+"select.remove" = "მონიშნულიდან ამოღება"
+"select.sameEffect" = "იგივე ეფექტის მონიშვნა"
+"select.sameFill" = "იგივე შევსების მონიშვნა"
+"select.sameFont" = "იგივე შრიფტის მონიშვნა"
+"select.sameInstance" = "იგივე ინსტანსის მონიშვნა"
+"select.sameProperties" = "იგივე თვისებების მონიშვნა"
+"select.sameStroke" = "იგივე კონტურის მონიშვნა"
+"select.sameText" = "ტექსტის იგივე თვისებების მონიშვნა"
+"select.set" = "მონიშვნა"
+"selection.applyColorStyle" = "მონიშნულის ფერის სტილის გამოყენება"
+"selection.colors" = "მონიშნულის ფერები"
+"selection.selectColor" = "ამ ფერის შრეების მონიშვნა"
+"selection.setPaint" = "მონიშნულის ფერის შეცვლა"
+"shape.arrow" = "ისარი"
+"shape.ellipse" = "ელიფსი"
+"shape.line" = "ხაზი"
+"shape.polygon" = "მრავალკუთხედი"
+"shape.rectangle" = "მართკუთხედი"
+"shape.star" = "ვარსკვლავი"
+"shapeBuilder.merge" = "არეების შერწყმა"
+"shapeBuilder.mode" = "ფიგურების კონსტრუქტორის რეჟიმი"
+"shapeBuilder.regions" = "ფიგურების კონსტრუქტორის არეები"
+"shapeBuilder.remove" = "არეების წაშლა"
+"stroke.add" = "კონტურის დამატება"
+"stroke.brush" = "ფუნჯი"
+"stroke.move" = "კონტურის გადატანა"
+"stroke.remove" = "კონტურის წაშლა"
+"stroke.set" = "კონტურის დაყენება"
+"stroke.widthProfile" = "სიგანის პროფილი"
+"style.apply" = "სტილის გამოყენება"
+"style.bind" = "ცვლადის სტილში მიბმა"
+"style.create" = "სტილის შექმნა"
+"style.delete" = "სტილის წაშლა"
+"style.detach" = "სტილის გამოყოფა"
+"style.duplicate" = "სტილის დუბლირება"
+"style.list" = "სტილების სია"
+"style.move" = "სტილების გადატანა"
+"style.renameFolder" = "სტილების საქაღალდის სახელის შეცვლა"
+"style.update" = "სტილის რედაქტირება"
+"template.list" = "შაბლონების სია"
+"text.alignCenter" = "ცენტრში სწორება"
+"text.alignJustify" = "ორმხრივი სწორება"
+"text.alignLeft" = "მარცხნივ სწორება"
+"text.alignRight" = "მარჯვნივ სწორება"
+"text.bold" = "მუქი"
+"text.bulletList" = "ბურთულებიანი სია"
+"text.case" = "ასოთა რეგისტრი"
+"text.caseLower" = "პატარა ასოები"
+"text.caseOriginal" = "საწყისი რეგისტრი"
+"text.caseSmallCaps" = "პატარა მთავრული"
+"text.caseTitle" = "სათაურის რეგისტრი"
+"text.caseUpper" = "მთავრული"
+"text.create" = "ტექსტი"
+"text.decoration" = "გაფორმება"
+"text.edit.begin" = "ტექსტის რედაქტირება"
+"text.edit.caret" = "კურსორის დაყენება"
+"text.edit.end" = "ტექსტის რედაქტირების დასრულება"
+"text.edit.insert" = "ტექსტის აკრეფა"
+"text.edit.key" = "ტექსტის კლავიში"
+"text.edit.preedit" = "ტექსტის აწყობა (IME)"
+"text.edit.selectLine" = "სტრიქონის მონიშვნა"
+"text.edit.selectWord" = "სიტყვის მონიშვნა"
+"text.edit.selection" = "ტექსტის მონიშვნა"
+"text.endPreview" = "ტექსტის გადახედვის დასრულება"
+"text.fonts" = "შრიფტების სია"
+"text.italic" = "დახრილი"
+"text.lineHeightDown" = "სტრიქონის სიმაღლის შემცირება"
+"text.lineHeightUp" = "სტრიქონის სიმაღლის გაზრდა"
+"text.link" = "ბმულის შექმნა"
+"text.listIndent" = "სიის შეწევის გაზრდა"
+"text.listOutdent" = "სიის შეწევის შემცირება"
+"text.listStyle" = "სიის სტილი"
+"text.maxLines" = "მაქს. სტრიქონები"
+"text.missingFonts" = "მიუწვდომელი შრიფტები"
+"text.numberList" = "დანომრილი სია"
+"text.onPath" = "ტექსტი ტრაექტორიაზე"
+"text.paragraphIndent" = "აბზაცის შეწევა"
+"text.paragraphSpacing" = "აბზაცთა ინტერვალი"
+"text.pathOptions" = "ტრაექტორიაზე ტექსტის პარამეტრები"
+"text.preview" = "ტექსტის ცვლილების გადახედვა"
+"text.removeFromPath" = "ტექსტის ტრაექტორიიდან მოხსნა"
+"text.set" = "ტექსტის დაყენება"
+"text.setFeatures" = "OpenType შესაძლებლობები"
+"text.setVariations" = "ცვლადი შრიფტის ღერძები"
+"text.sizeDown" = "შრიფტის ზომის შემცირება"
+"text.sizeUp" = "შრიფტის ზომის გაზრდა"
+"text.strikethrough" = "გადახაზული"
+"text.style" = "ტექსტის დიაპაზონის სტილის მინიჭება"
+"text.trackingDown" = "ასოებს შორის დაშორების შემცირება"
+"text.trackingUp" = "ასოებს შორის დაშორების გაზრდა"
+"text.underline" = "ხაზგასმული"
+"text.weightDown" = "შრიფტის სისქის შემცირება"
+"text.weightUp" = "შრიფტის სისქის გაზრდა"
+"tool.arrow" = "ისარი"
+"tool.comment" = "კომენტარი"
+"tool.connector" = "შემაერთებელი"
+"tool.ellipse" = "ელიფსი"
+"tool.eraser" = "საშლელი"
+"tool.frame" = "ჩარჩო"
+"tool.hand" = "ხელი"
+"tool.highlighter" = "ხაზგასმის მარკერი"
+"tool.line" = "ხაზი"
+"tool.marker" = "მარკერი"
+"tool.move" = "გადაადგილება"
+"tool.pen" = "კალამი"
+"tool.pencil" = "ფანქარი"
+"tool.pencilBrush" = "ფანქრის ფუნჯი"
+"tool.place" = "ხელსაწყოთი განთავსება"
+"tool.polygon" = "მრავალკუთხედი"
+"tool.rectangle" = "მართკუთხედი"
+"tool.scale" = "მასშტაბირება"
+"tool.scaleAnchor" = "მასშტაბირების საყრდენი წერტილი"
+"tool.section" = "სექცია"
+"tool.set" = "ხელსაწყოს არჩევა"
+"tool.shape" = "ფიგურები"
+"tool.shapeBuilder" = "ფიგურების კონსტრუქტორი"
+"tool.slice" = "ნაჭერი"
+"tool.stamp" = "შტამპი"
+"tool.star" = "ვარსკვლავი"
+"tool.sticky" = "სტიკერი"
+"tool.text" = "ტექსტი"
+"transform.move" = "გადაადგილება"
+"transform.moveTo" = "გადატანა"
+"transform.nudge" = "მცირედ გადაწევა"
+"transform.nudgeSize" = "ზომის შეცვლა მცირედ გადაწევით"
+"transform.resize" = "ზომის შეცვლა"
+"transform.rotate" = "შემობრუნება"
+"transform.rotationOrigin" = "შემობრუნების ცენტრის გადატანა"
+"transform.scale" = "მასშტაბირება"
+"transform.setRotationOrigin" = "შემობრუნების ცენტრის დაყენება"
+"variable.addMode" = "რეჟიმის დამატება"
+"variable.bind" = "ცვლადის მიბმა"
+"variable.create" = "ცვლადის შექმნა"
+"variable.createCollection" = "ცვლადების კოლექციის შექმნა"
+"variable.delete" = "ცვლადის წაშლა"
+"variable.deleteCollection" = "კოლექციის წაშლა"
+"variable.duplicate" = "ცვლადის დუბლირება"
+"variable.export" = "ცვლადების ექსპორტირება"
+"variable.import" = "ცვლადების იმპორტი"
+"variable.list" = "ცვლადების სია"
+"variable.moveMode" = "რეჟიმის გადატანა"
+"variable.removeMode" = "რეჟიმის წაშლა"
+"variable.renameCollection" = "კოლექციის სახელის შეცვლა"
+"variable.renameMode" = "რეჟიმის სახელის შეცვლა"
+"variable.resetOverride" = "ცვლადის გადაფარვის ჩამოყრა"
+"variable.set" = "ცვლადის მნიშვნელობის დაყენება"
+"variable.setMode" = "ცვლადის რეჟიმის დაყენება"
+"variable.update" = "ცვლადის რედაქტირება"
+"vector.create" = "ვექტორი"
+"vector.deleteHeal" = "მონიშნულის წაშლა ხარვეზის შევსებით"
+"vector.edit.addVertex" = "წერტილის დამატება"
+"vector.edit.begin" = "ვექტორის რედაქტირება"
+"vector.edit.bend" = "სეგმენტის მოხრა"
+"vector.edit.bounds" = "მონიშნული წერტილების საზღვრები"
+"vector.edit.connect" = "წერტილების შეერთება"
+"vector.edit.cornerRadius" = "წერტილის კუთხის რადიუსი"
+"vector.edit.cut" = "ტრაექტორიის გაჭრა"
+"vector.edit.delete" = "წერტილების წაშლა"
+"vector.edit.end" = "რედაქტირების დასრულება"
+"vector.edit.erase" = "წაშლა"
+"vector.edit.lasso" = "ლასოთი მონიშვნა"
+"vector.edit.mirroring" = "სახელურების არეკვლა"
+"vector.edit.moveHandles" = "სახელურების გადატანა"
+"vector.edit.moveVertices" = "წერტილების გადატანა"
+"vector.edit.nudge" = "წერტილების მცირედ გადაწევა"
+"vector.edit.paint" = "საღებავის ვედრო"
+"vector.edit.pen" = "კალმის წერტილი"
+"vector.edit.penEnd" = "კალმის ტრაექტორიის დასრულება"
+"vector.edit.position" = "წერტილის პოზიცია"
+"vector.edit.resize" = "წერტილების ზომის შეცვლა"
+"vector.edit.rotate" = "წერტილების შემობრუნება"
+"vector.edit.select" = "წერტილების მონიშვნა"
+"vector.edit.selectAll" = "ყველა წერტილის მონიშვნა"
+"vector.edit.setHandle" = "სახელურის დაყენება"
+"vector.edit.smooth" = "წერტილების მოგლუვება ან გამახვილება"
+"vector.edit.state" = "ვექტორის რედაქტირების მდგომარეობა"
+"vector.edit.strokeCap" = "კონტურის დაბოლოება წერტილში"
+"vector.edit.strokeJoin" = "კონტურის შეერთება წერტილში"
+"vector.edit.tool" = "ვექტორის რედაქტირების ხელსაწყო"
+"vector.edit.transform" = "წერტილების გარდაქმნა"
+"vector.edit.widthPoint" = "სიგანის წერტილი"
+"vector.flatten" = "გაბრტყელება"
+"vector.join" = "მონიშნულის შეერთება"
+"vector.offset" = "ტრაექტორიის წანაცვლება"
+"vector.outlineStroke" = "კონტურის ფიგურად გარდაქმნა"
+"vector.reverse" = "ტრაექტორიის მიმართულების შებრუნება"
+"vector.simplify" = "ვექტორის გამარტივება"
+"vector.smoothJoin" = "მონიშნულის გლუვი შეერთება"
+"version.autosave" = "ვერსიის ავტოშენახვა"
+"version.delete" = "ვერსიის წაშლა"
+"version.duplicate" = "ვერსიის დუბლირება"
+"version.exitPreview" = "მიმდინარე ვერსიაზე დაბრუნება"
+"version.list" = "ვერსიების სია"
+"version.preview" = "ვერსიის ნახვა"
+"version.rename" = "ვერსიის სახელის შეცვლა"
+"version.restore" = "ვერსიის აღდგენა"
+"view.assets" = "რესურსების პანელი"
+"view.comments" = "კომენტარები"
+"view.contextMenu" = "კონტექსტური მენიუს ჩვენება"
+"view.design" = "დიზაინის პანელი"
+"view.designPrototype" = "გადართვა დიზაინსა და პროტოტიპს შორის"
+"view.devMode" = "დეველოპერის რეჟიმი"
+"view.frameOutlines" = "ჩარჩოების კონტურები"
+"view.fullscreen" = "სრული ეკრანი"
+"view.get" = "ხედის მიღება"
+"view.layers" = "შრეების პანელი"
+"view.layoutGrids" = "განლაგების ბადეები"
+"view.leftSidebar" = "მარცხენა გვერდითი ზოლის ჩვენება/დამალვა"
+"view.maskOutlines" = "ნიღბების კონტურები"
+"view.multiplayerCursors" = "სხვა მონაწილეების კურსორები"
+"view.nextFrame" = "შემდეგი ჩარჩოს მასშტაბირება"
+"view.nextPage" = "შემდეგი გვერდი"
+"view.nextRegion" = "შემდეგ არეზე ფოკუსირება"
+"view.outlines" = "კონტურები"
+"view.outlinesHiddenLayers" = "კონტურებში დამალული შრეების ჩართვა"
+"view.outlinesObjectBounds" = "კონტურებში ობიექტების საზღვრების ჩართვა"
+"view.outlinesSelection" = "მონიშნულის კონტურები"
+"view.pan" = "ხედის გადაადგილება"
+"view.panelWidths" = "პანელების სიგანის ჩამოყრა"
+"view.pixelGrid" = "პიქსელური ბადე"
+"view.pixelPreview" = "პიქსელების წინასწარი ნახვა"
+"view.prevFrame" = "წინა ჩარჩოს მასშტაბირება"
+"view.prevPage" = "წინა გვერდი"
+"view.previousRegion" = "წინა არეზე ფოკუსირება"
+"view.proofSrgb" = "ეკრანზე sRGB-ის სიმულაცია"
+"view.prototype" = "პროტოტიპის პანელი"
+"view.rulers" = "სახაზავები"
+"view.set" = "ხედის დაყენება"
+"view.slices" = "ნაჭრები"
+"view.snapGeometry" = "გეომეტრიაზე მიბმა"
+"view.snapObjects" = "ობიექტებზე მიბმა"
+"view.snapPixel" = "პიქსელურ ბადეზე მიბმა"
+"view.themeDark" = "ბნელი თემა"
+"view.themeLight" = "ღია თემა"
+"view.themeSystem" = "სისტემის თემის მიყოლა"
+"view.toggleUi" = "ინტერფეისის ჩვენება/დამალვა"
+"view.zoom100" = "მასშტაბი 100%"
+"view.zoom200" = "მასშტაბი 200%"
+"view.zoom50" = "მასშტაბი 50%"
+"view.zoomAt" = "მასშტაბის ხელსაწყო"
+"view.zoomFit" = "ეკრანში ჩატევა"
+"view.zoomIn" = "გადიდება"
+"view.zoomOut" = "დაპატარავება"
+"view.zoomSelection" = "მონიშნულის მასშტაბირება"
+"widget.click" = "ვიჯეტზე დაწკაპუნება"
+"widget.insert" = "ვიჯეტის ჩასმა"
+"widget.list" = "ვიჯეტების სია"
+"window.focus" = "ფანჯრის წინა პლანზე გადმოტანა"
+"window.new" = "ახალი ფანჯარა"
+
+[menu]
+"bool.exclude" = "გამორიცხვა"
+"bool.flatten" = "გაბრტყელება"
+"bool.intersect" = "გადაკვეთა"
+"bool.subtract" = "გამოკლება"
+"bool.union" = "გაერთიანება"
+"file.duplicate" = "დუბლირება"
+"file.import" = "ფაილიდან იმპორტი…"
+"file.rename" = "სახელის შეცვლა"
+"libraries.open" = "ბიბლიოთეკების გახსნა"
+"select.sameEffect" = "ეფექტი"
+"select.sameFill" = "შევსება"
+"select.sameFont" = "შრიფტი"
+"select.sameInstance" = "ინსტანსი"
+"select.sameProperties" = "თვისებები"
+"select.sameStroke" = "კონტური"
+"select.sameText" = "ტექსტის თვისებები"
+"text.alignCenter" = "ტექსტის ცენტრში სწორება"
+"text.alignJustify" = "ტექსტის ორმხრივი სწორება"
+"text.alignLeft" = "ტექსტის მარცხნივ სწორება"
+"text.alignRight" = "ტექსტის მარჯვნივ სწორება"
+"view.assets" = "რესურსები"
+"view.design" = "დიზაინი"
+"view.layers" = "შრეები"
+"view.outlines" = "კონტურების ჩვენება"
+"view.outlinesHiddenLayers" = "დამალული შრეების ჩართვა"
+"view.outlinesObjectBounds" = "ობიექტების საზღვრების ჩართვა"
+"view.outlinesSelection" = "მონიშნულის კონტურების ჩვენება"
+"view.prototype" = "პროტოტიპი"
+"view.themeDark" = "ბნელი"
+"view.themeLight" = "ღია"
+"view.themeSystem" = "სისტემის მიყოლა"
diff --git a/crates/ui-egui/locales/ko.toml b/crates/ui-egui/locales/ko.toml
index ec732905c..66eb54c21 100644
--- a/crates/ui-egui/locales/ko.toml
+++ b/crates/ui-egui/locales/ko.toml
@@ -18,6 +18,7 @@ status = "draft — needs native review"
 "1…9, 0" = "1…9, 0"
 "@{login}: {prs} PRs, {commits} commits, +{added} / −{deleted} lines (Δ {delta}), +{bin_added} / −{bin_deleted} binary assets, {first} – {last}" = "@{login}: PR {prs}개, 커밋 {commits}개, +{added} / −{deleted}줄 (Δ {delta}), 바이너리 에셋 +{bin_added} / −{bin_deleted}, {first} – {last}"
 "A collection of this file with these modes and variables: override their values per mode and add variables of its own" = "이 파일의 컬렉션과 그 모드 및 변수: 모드별로 값을 재정의하고 자체 변수를 추가할 수 있음"
+"A .figcraft file with this name already exists. Choose its full name to confirm replacement." = "이 이름의 .figcraft 파일이 이미 있습니다. 바꾸려면 확장자까지 포함한 전체 이름을 선택하세요."
 "A layer on its own aligns to its frame: select more layers, or one in a frame" = "레이어 하나는 프레임에 맞춰 정렬됩니다: 레이어를 더 선택하거나 프레임 안의 레이어를 선택하세요"
 "A spring plays until it settles: its mass, stiffness and damping set how long" = "스프링은 멈출 때까지 재생됨. 길이는 질량, 강성, 감쇠로 결정됨"
 "About" = "정보"
@@ -117,6 +118,7 @@ status = "draft — needs native review"
 "Archived" = "보관됨"
 "Arrange" = "배치"
 "Arrow" = "화살표"
+"Arrow at the end" = "끝에 화살표"
 "As typed" = "입력한 대로"
 "Asking the server…" = "서버에 확인하는 중…"
 "Assets" = "에셋"
@@ -188,7 +190,9 @@ status = "draft — needs native review"
 "C or ⇧C" = "C 또는 ⇧C"
 "CMYK colour" = "CMYK 색상"
 "Can view" = "보기 가능"
+"Check" = "체크"
 "Checking the server…" = "서버 확인 중…"
+"Chevron" = "셰브런"
 "Clear from this list" = "이 목록에서 지우기"
 "Code or invite link" = "코드 또는 초대 링크"
 "Color profile: {name}" = "색상 프로필: {name}"
@@ -234,7 +238,6 @@ status = "draft — needs native review"
 "Close tab" = "탭 닫기"
 "Close version history" = "버전 기록 닫기"
 "Close when clicking outside" = "바깥쪽을 클릭하면 닫기"
-"Close without saving" = "저장하지 않고 닫기"
 "Code" = "코드"
 "Code syntax" = "코드 구문"
 "Collapse" = "접기"
@@ -261,6 +264,8 @@ status = "draft — needs native review"
 "Commits" = "커밋"
 "Company" = "회사"
 "Compare changes" = "변경 사항 비교"
+"Compare with" = "비교 대상"
+"Compatibility notes" = "호환성 참고 사항"
 "Completed" = "완료됨"
 "Component" = "컴포넌트"
 "Component name" = "컴포넌트 이름"
@@ -275,6 +280,7 @@ status = "draft — needs native review"
 "Connected" = "연결됨"
 "Connected to code: {from}" = "코드에 연결됨: {from}"
 "Connection lost, reconnecting (attempt {attempt})…" = "연결이 끊어짐. 다시 연결하는 중({attempt}번째 시도)…"
+"Connector" = "커넥터"
 "Constrain proportions" = "비율 고정"
 "Constraints" = "제약"
 "Content" = "콘텐츠"
@@ -303,6 +309,7 @@ status = "draft — needs native review"
 "Corner radius" = "모서리 반경"
 "Corner smoothing" = "모서리 스무딩"
 "Couldn't reach {server}: showing what this computer remembers." = "{server}에 연결할 수 없음: 이 컴퓨터가 기억하는 내용을 표시함."
+"Couldn't read {name}." = "{name}을(를) 읽을 수 없습니다."
 "Couldn't save automatically: {error}" = "자동으로 저장할 수 없음: {error}"
 "Count" = "개수"
 "Create" = "만들기"
@@ -326,6 +333,7 @@ status = "draft — needs native review"
 "Current version" = "현재 버전"
 "Cursor chat" = "커서 채팅"
 "Custom" = "사용자 지정"
+"Custom size" = "사용자 지정 크기"
 "Cut" = "잘라내기"
 "Dark" = "다크"
 "Darken" = "어둡게 하기"
@@ -356,6 +364,7 @@ status = "draft — needs native review"
 "Description" = "설명"
 "Description (optional)" = "설명(선택 사항)"
 "Design" = "디자인"
+"Design panel" = "디자인 패널"
 "Desktop" = "데스크톱"
 "Destination" = "대상"
 "Detach alias" = "별칭 분리"
@@ -366,6 +375,7 @@ status = "draft — needs native review"
 "Detach variable" = "변수 분리"
 "Details" = "세부 정보"
 "Dev Mode" = "개발 모드"
+"Dev Mode only inspects: switch to Design (Shift+D) to edit" = "개발 모드는 검사 전용입니다. 편집하려면 디자인(Shift+D)으로 전환하세요"
 "Dev resources" = "개발 리소스"
 "Development" = "개발"
 "Device" = "기기"
@@ -382,6 +392,7 @@ status = "draft — needs native review"
 "Distribute horizontal spacing" = "수평 간격 균등 분포"
 "Distribute vertical spacing" = "수직 간격 균등 분포"
 "Divider" = "구분선"
+"Don't Save" = "저장 안 함"
 "Don't truncate" = "자르지 않음"
 "Done" = "완료"
 "Done editing" = "편집 완료"
@@ -412,6 +423,7 @@ status = "draft — needs native review"
 "Effect settings" = "효과 설정"
 "Effect styles" = "효과 스타일"
 "Effects" = "효과"
+"Elbow" = "꺾은선"
 "Ellipse" = "타원"
 "Ellipses" = "타원"
 "Else" = "그 외"
@@ -460,6 +472,7 @@ status = "draft — needs native review"
 "False" = "거짓"
 "Fetching from the server…" = "서버에서 가져오는 중…"
 "FigCraft couldn't open its window: {error}" = "FigCraft 창을 열 수 없음: {error}"
+"FigCraft doesn't support every feature of these files yet. The notes list what was left out or changed in the imported copy; the original file is unchanged." = "FigCraft는 아직 이 파일의 모든 기능을 지원하지 않습니다. 참고 사항에는 가져온 사본에서 빠지거나 바뀐 내용이 나와 있으며, 원본 파일은 바뀌지 않습니다."
 "File" = "파일"
 "File name" = "파일 이름"
 "File published" = "파일 게시됨"
@@ -541,6 +554,7 @@ status = "draft — needs native review"
 "Hanging list" = "내어쓰기 목록"
 "Hanging punctuation" = "문장 부호 내어쓰기"
 "Hard light" = "하드 라이트"
+"Heart" = "하트"
 "Height" = "높이"
 "Help" = "도움말"
 "Help and resources" = "도움말 및 리소스"
@@ -551,6 +565,7 @@ status = "draft — needs native review"
 "Hide from publishing" = "게시에서 숨기기"
 "Hide section contents" = "섹션 콘텐츠 숨기기"
 "Highlight layers on hover" = "마우스를 올리면 레이어 강조"
+"Highlighter" = "형광펜"
 "Highlights" = "밝은 영역"
 "Hold Alt" = "Alt 누른 채로"
 "Hold Alt+Z" = "Alt+Z 누른 채로"
@@ -576,11 +591,14 @@ status = "draft — needs native review"
 "If {condition}" = "조건: {condition}"
 "Ignore auto layout (absolute position)" = "자동 레이아웃 무시(절대 위치)"
 "Image" = "이미지"
+"Images" = "이미지"
 "Import" = "가져오기"
 "Import path" = "가져오기 경로"
 "Import plugin from manifest" = "매니페스트에서 플러그인 가져오기"
 "Import plugin from manifest…" = "매니페스트에서 플러그인 가져오기…"
+"Import report" = "가져오기 보고서"
 "Import variables" = "변수 가져오기"
+"Imported document" = "가져온 문서"
 "Imported {name}" = "{name} 가져옴"
 "Imported {n} new variables, updated {updated}" = { other = "새 변수 {n}개를 가져오고 {updated}개를 업데이트함" }
 "Import…" = "가져오기…"
@@ -608,11 +626,13 @@ status = "draft — needs native review"
 "Instance swap (no other component)" = "인스턴스 교체(다른 컴포넌트 없음)"
 "Instances" = "인스턴스"
 "Instant" = "즉시"
+"Intensity" = "강도"
 "Interaction" = "인터랙션"
 "Interactions" = "인터랙션"
 "Interface design and prototyping. A free, open-source, clean-room design tool written from scratch in Rust, part of the ArtCraft Crafting Apps." = "인터페이스 디자인과 프로토타이핑. Rust로 처음부터 작성한 무료 오픈 소스 클린룸 디자인 도구이며 ArtCraft Crafting Apps의 하나."
 "Intersect" = "교차"
 "Intersects" = "교차"
+"Invalid color" = "잘못된 색상"
 "Invite link" = "초대 링크"
 "Invite link copied" = "초대 링크 복사됨"
 "It asks permission to:" = "다음 권한을 요청함:"
@@ -701,6 +721,7 @@ status = "draft — needs native review"
 "Mark as resolved" = "해결됨으로 표시"
 "Mark as unread" = "읽지 않음으로 표시"
 "Mark as unresolved" = "미해결로 표시"
+"Marker" = "마커"
 "Mask" = "마스크"
 "Mass · Stiffness · Damping" = "질량 · 강성 · 감쇠"
 "Match (empty: the whole name)" = "일치(비우면 이름 전체)"
@@ -757,7 +778,9 @@ status = "draft — needs native review"
 "Named instance" = "명명된 인스턴스"
 "Navigate to" = "이동 대상"
 "Nested instance" = "중첩된 인스턴스"
+"New board" = "새 보드"
 "New design file" = "새 디자인 파일"
+"Next frame" = "다음 프레임"
 "Next or previous control in the focused region" = "포커스된 영역의 다음 또는 이전 컨트롤"
 "Next ready for dev" = "다음 개발 준비 완료"
 "Next size option" = "다음 크기 옵션"
@@ -767,12 +790,15 @@ status = "draft — needs native review"
 "No branches. A branch is a copy of the file to try changes in, then review and merge." = "브랜치 없음. 브랜치는 변경을 시험해 본 뒤 검토하고 병합하는 파일 사본임."
 "No category" = "카테고리 없음"
 "No changes" = "변경 사항 없음"
+"No color styles" = "색상 스타일 없음"
 "No colour variables fit here." = "여기에 맞는 색상 변수가 없음."
 "No colour variables yet. Create them in Local variables." = "아직 색상 변수가 없음. 로컬 변수에서 만드세요."
 "No comments yet" = "아직 댓글 없음"
+"No compatibility warnings reported" = "보고된 호환성 경고 없음"
 "No components yet. Select layers and press {keys}." = "아직 컴포넌트가 없음. 레이어를 선택하고 {keys}를 누르세요."
 "No conflicts." = "충돌 없음."
 "No contributor data was built into this copy." = "이 사본에는 기여자 데이터가 포함되지 않음."
+"No device" = "기기 없음"
 "No fonts match" = "일치하는 글꼴 없음"
 "No join code here (the server is older than join codes, or this address can't be put in one): share the link instead." = "참여 코드 없음(서버가 참여 코드 이전 버전이거나 이 주소를 코드에 담을 수 없음): 대신 링크를 공유하세요."
 "No layer changes to show." = "표시할 레이어 변경 사항 없음."
@@ -815,6 +841,7 @@ status = "draft — needs native review"
 "Not read yet" = "아직 읽지 않음"
 "Not shared" = "공유 안 함"
 "Note {n}" = "메모 {n}"
+"Nothing changed since this version." = "이 버전 이후 변경된 내용 없음."
 "Nothing changed since this was marked ready for dev." = "개발 준비 완료로 표시된 뒤 변경된 내용 없음."
 "Nothing here yet. Set a frame's status to list it." = "아직 아무것도 없음. 프레임의 상태를 설정하면 목록에 표시됨."
 "Nothing online yet. Use Share on a file to put it online and it is listed here." = "아직 온라인에 올린 파일이 없음. 파일에서 공유를 사용해 온라인에 올리면 여기에 표시됨."
@@ -848,6 +875,7 @@ status = "draft — needs native review"
 "Open branch" = "브랜치 열기"
 "Open file" = "파일 열기"
 "Open files" = "열린 파일"
+"Open presentations" = "열린 프레젠테이션"
 "Open in focus view" = "포커스 보기로 열기"
 "Open in new window" = "새 창에서 열기"
 "Open invite links in FigCraft" = "초대 링크를 FigCraft에서 열기"
@@ -856,6 +884,7 @@ status = "draft — needs native review"
 "Open overlay" = "오버레이 열기"
 "Open prototype preview" = "프로토타입 미리 보기 열기"
 "Open variables ({count})" = "변수 열기({count})"
+"Opened as a new document" = "새 문서로 열림"
 "Opened “{name}” in a new tab" = "\"{name}\"을(를) 새 탭에서 열었음"
 "Open|comments" = "미해결"
 "Options" = "옵션"
@@ -878,7 +907,11 @@ status = "draft — needs native review"
 "PDF print settings" = "PDF 인쇄 설정"
 "Padding" = "패딩"
 "Page" = "페이지"
+"Page deleted" = "페이지가 삭제됨"
 "Pages" = "페이지"
+"Pages added to the document" = "문서에 페이지 추가됨"
+"Pink" = "분홍"
+"Placed on the current page" = "현재 페이지에 배치됨"
 "Pages: {pages}" = "페이지: {pages}"
 "Paint bucket" = "페인트 통"
 "Pan the canvas" = "캔버스 이동"
@@ -893,6 +926,7 @@ status = "draft — needs native review"
 "Paste a team library link (a view link)" = "팀 라이브러리 링크(보기 링크) 붙여 넣기"
 "Paste here" = "여기에 붙여 넣기"
 "Paste to replace" = "붙여 넣어 바꾸기"
+"Pasted design layers; {n} kinds of content were left out" = { other = "디자인 레이어를 붙여 넣음. 콘텐츠 {n}종은 제외됨" }
 "Pattern" = "패턴"
 "Pattern alignment" = "패턴 정렬"
 "Pattern scale" = "패턴 배율"
@@ -918,6 +952,7 @@ status = "draft — needs native review"
 "Plugins run in FigCraft's sandbox, without files, network or clock. Install only plugins you trust." = "플러그인은 FigCraft 샌드박스에서 파일, 네트워크, 시계 없이 실행됨. 신뢰할 수 있는 플러그인만 설치하세요."
 "Plus darker" = "더 어둡게"
 "Plus lighter" = "더 밝게"
+"Plus one" = "플러스 원"
 "Point" = "점"
 "Points" = "점"
 "Polygon" = "다각형"
@@ -943,6 +978,7 @@ status = "draft — needs native review"
 "Preview" = "미리 보기"
 "Preview this flow" = "이 플로우 미리 보기"
 "Preview this frame" = "이 프레임 미리 보기"
+"Previous frame" = "이전 프레임"
 "Previous ready for dev" = "이전 개발 준비 완료"
 "Progressive" = "점진적"
 "Properties" = "속성"
@@ -963,6 +999,7 @@ status = "draft — needs native review"
 "Push" = "밀어내기"
 "Push changes to main component" = "변경 사항을 메인 컴포넌트에 푸시"
 "Put text on path" = "텍스트를 패스에 배치"
+"Question" = "질문"
 "R" = "R"
 "Radial" = "방사형"
 "Radius" = "반경"
@@ -1007,6 +1044,7 @@ status = "draft — needs native review"
 "Removed" = "제거됨"
 "Removed from the server" = "서버에서 제거됨"
 "Removed since it was marked" = "표시된 뒤 제거됨"
+"Removed since this version" = "이 버전 이후 삭제됨"
 "Rename" = "이름 바꾸기"
 "Rename duplicated layers" = "복제한 레이어 이름 바꾸기"
 "Rename folder" = "폴더 이름 바꾸기"
@@ -1036,6 +1074,7 @@ status = "draft — needs native review"
 "Resize by the nudge amount" = "미세 이동 거리만큼 크기 조정"
 "Resize frames to the device's screen (or the window without a device): their constraints and auto layout respond" = "프레임 크기를 기기 화면(기기가 없으면 창)에 맞게 조정: 제약과 자동 레이아웃이 반응함"
 "Resize to fit" = "크기 맞춤"
+"Resizing" = "크기 조정"
 "Resolve" = "해결"
 "Resolve change" = "변경 사항 해결"
 "Resolved" = "해결됨"
@@ -1061,6 +1100,7 @@ status = "draft — needs native review"
 "Rotation jitter" = "회전 지터"
 "Round" = "둥글게"
 "Rounded" = "둥근"
+"Rounded rectangle" = "둥근 사각형"
 "Row" = "행"
 "Row gap" = "행 간격"
 "Row sizes" = "행 크기"
@@ -1107,12 +1147,14 @@ status = "draft — needs native review"
 "Select all with same" = "같은 항목 모두 선택"
 "Select layer" = "레이어 선택"
 "Select layers to apply the style to" = "스타일을 적용할 레이어를 선택하세요"
+"Select layers with this color" = "이 색상의 레이어 선택"
 "Select overlapping shapes" = "겹친 도형 선택"
 "Select points to edit their position, radius and mirroring" = "점을 선택해 위치, 반경, 대칭 편집"
 "Select slot" = "슬롯 선택"
 "Selection" = "선택 항목"
 "Selection box, {w} by {h} at {x}, {y}: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "선택 상자, {w} × {h}, 위치 {x}, {y}: 화살표로 이동, Shift+화살표 또는 {cmd}+화살표로 크기 조정, Enter로 선택, Escape로 취소"
 "Selection box: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "선택 상자: 화살표로 이동, Shift+화살표 또는 {cmd}+화살표로 크기 조정, Enter로 선택, Escape로 취소"
+"Selection colors" = "선택 항목 색상"
 "Send backward" = "뒤로 보내기"
 "Send report" = "신고 보내기"
 "Send to back" = "맨 뒤로 보내기"
@@ -1128,6 +1170,7 @@ status = "draft — needs native review"
 "Shape" = "도형"
 "Shape builder" = "도형 빌더"
 "Shape tools" = "도형 도구"
+"Shapes" = "도형"
 "Share" = "공유"
 "Share this file" = "이 파일 공유"
 "Share: live session, export" = "공유: 라이브 세션, 내보내기"
@@ -1185,10 +1228,13 @@ status = "draft — needs native review"
 "Space+drag" = "Space+드래그"
 "Spacing" = "간격"
 "Spam, stolen work, abuse…" = "스팸, 도용, 악용…"
+"Speech bubble" = "말풍선"
 "Splay" = "펼침"
 "Spotlight me" = "나를 스포트라이트"
 "Spread" = "확산"
 "Square" = "정사각형"
+"Stamp" = "스탬프"
+"Stamps" = "스탬프"
 "Standard" = "표준"
 "Standard ligatures" = "표준 합자"
 "Star" = "별"
@@ -1197,17 +1243,22 @@ status = "draft — needs native review"
 "Start ascending from / stop descending at" = "오름차순 시작 값 / 내림차순 끝 값"
 "Start from a blank canvas" = "빈 캔버스로 시작"
 "Start on path" = "패스 시작 위치"
+"Start on the Home screen" = "홈에서 시작"
 "Start point" = "시작점"
 "Start sharing" = "공유 시작"
 "Starting to share…" = "공유를 시작하는 중…"
 "Status" = "상태"
 "Sticky" = "고정"
+"Sticky note" = "스티커 메모"
+"Sticky note colors" = "스티커 메모 색상"
+"Sticky notes, shapes and connectors" = "스티커 메모, 도형, 커넥터"
 "Stop" = "중지"
 "Stop following {name}" = "{name} 따라가기 중지"
 "Stop session" = "세션 중지"
 "Stop sharing" = "공유 중지"
 "Stop spotlighting" = "스포트라이트 중지"
 "Stop {n}  {hex}" = "정지점 {n}  {hex}"
+"Straight" = "직선"
 "Stretch" = "늘이기"
 "Strikethrough" = "취소선"
 "String" = "문자열"
@@ -1251,6 +1302,7 @@ status = "draft — needs native review"
 "Text" = "텍스트"
 "Text align" = "텍스트 정렬"
 "Text content" = "텍스트 내용"
+"Text size" = "텍스트 크기"
 "Text style" = "텍스트 스타일"
 "Text styles" = "텍스트 스타일"
 "Texts" = "텍스트"
@@ -1281,6 +1333,9 @@ status = "draft — needs native review"
 "This server is open to the public: no key needed." = "이 서버는 누구에게나 열려 있음: 키가 필요 없음."
 "This server needs its key: add ?key=… to the address (`figcraft-server key` prints it on the server's machine)." = "이 서버는 키가 필요함: 주소에 ?key=…를 추가하세요(서버 컴퓨터에서 `figcraft-server key`로 확인)."
 "This server takes files only with its key: see Advanced." = "이 서버는 키가 있어야만 파일을 받음: 고급을 참고하세요."
+"Thumbs up" = "좋아요"
+"This version can't be read." = "이 버전을 읽을 수 없습니다."
+"This version doesn't have it: all of it is new." = "이 버전에는 없습니다. 모두 새 항목입니다."
 "Tidy up" = "정돈"
 "Tile" = "타일"
 "Tile type" = "타일 유형"
@@ -1297,6 +1352,7 @@ status = "draft — needs native review"
 "Top left radius" = "왼쪽 위 반경"
 "Top right radius" = "오른쪽 위 반경"
 "Transform" = "변형"
+"Triangle" = "삼각형"
 "Triangle arrow" = "삼각 화살표"
 "Trigger" = "트리거"
 "True" = "참"
@@ -1319,7 +1375,7 @@ status = "draft — needs native review"
 "Unread" = "읽지 않음"
 "Unresolve" = "미해결로 되돌리기"
 "Unsaved changes" = "저장되지 않은 변경 사항"
-"Unsaved changes in {names}. Close the window and lose them?" = "{names}에 저장되지 않은 변경 사항이 있음. 창을 닫고 변경 사항을 버릴까요?"
+"Unsaved changes in {names}. Save them before closing?" = "{names}에 저장되지 않은 변경 사항이 있음. 닫기 전에 저장할까요?"
 "Unsaved changes: save first ({save}), or close the tab with {alt}-click to discard" = "저장되지 않은 변경 사항: 먼저 저장({save})하거나 {alt}-클릭으로 탭을 닫아 버리세요"
 "Unsaved changes: save first, or close again with {key} to discard" = "저장되지 않은 변경 사항: 먼저 저장하거나 {key}로 다시 닫아 버리세요"
 "Up" = "위"
@@ -1338,6 +1394,7 @@ status = "draft — needs native review"
 "Use as mask" = "마스크로 사용"
 "Use auto layout" = "자동 레이아웃 사용"
 "Use number keys for opacity" = "숫자 키로 불투명도 변경"
+"Use the .figcraft or .fig extension." = ".figcraft 또는 .fig 확장자를 사용하세요."
 "Use the layer's fill" = "레이어의 채우기 사용"
 "Used in {files} · {instances}" = "{files}에서 사용 · {instances}"
 "Username" = "사용자 이름"
@@ -1381,10 +1438,12 @@ status = "draft — needs native review"
 "WebSocket URL copied" = "WebSocket URL 복사됨"
 "Wedge" = "쐐기"
 "Weight" = "굵기"
+"What changed since a saved version" = "저장된 버전 이후 변경된 내용"
 "What changed since it was marked ready for dev" = "개발 준비 완료로 표시된 뒤 변경된 내용"
 "What is wrong with this file? The server's operator gets your report." = "이 파일에 어떤 문제가 있나요? 신고는 서버 운영자에게 전달됨."
 "What it's for" = "용도"
 "What this changed from isn't known: it changed before FigCraft kept a copy of ready-for-dev frames. Resolve the change (or mark it ready again) to compare from now on." = "무엇에서 바뀌었는지 알 수 없음: FigCraft가 개발 준비 완료 프레임의 사본을 보관하기 전에 변경됨. 변경을 해결(또는 다시 준비 완료로 표시)하면 이후부터 비교함."
+"When marked ready" = "준비 완료로 표시한 시점"
 "While hovering" = "마우스를 올린 동안"
 "While pressing" = "누르는 동안"
 "White" = "흰색"
@@ -1426,25 +1485,118 @@ status = "draft — needs native review"
 "call any command its access allows" = "접근 권한이 허용하는 모든 명령 호출"
 "call only: {commands}" = "다음 명령만 호출: {commands}"
 "can edit the document" = "문서를 편집할 수 있음"
+"conditional prototype actions nested too deeply were skipped" = "너무 깊게 중첩된 조건부 프로토타입 액션을 건너뜀"
+"conditional prototype actions with conditions that can't be evaluated were skipped" = "평가할 수 없는 조건이 있는 조건부 프로토타입 액션을 건너뜀"
+"connector label background was skipped: style data is missing" = "커넥터 레이블 배경을 건너뜀: 스타일 데이터가 없음"
+"connector label was skipped: background bounds are invalid" = "커넥터 레이블을 건너뜀: 배경 경계가 잘못됨"
+"connector label was skipped: background transform is invalid" = "커넥터 레이블을 건너뜀: 배경 변형이 잘못됨"
+"connector label was skipped: composed text transform is invalid" = "커넥터 레이블을 건너뜀: 합성된 텍스트 변형이 잘못됨"
+"connector label was skipped: derived background bounds are missing" = "커넥터 레이블을 건너뜀: 계산된 배경 경계가 없음"
+"connector label was skipped: derived text bounds are missing" = "커넥터 레이블을 건너뜀: 계산된 텍스트 경계가 없음"
+"connector label was skipped: text bounds are invalid" = "커넥터 레이블을 건너뜀: 텍스트 경계가 잘못됨"
+"connector label was skipped: text style data is missing" = "커넥터 레이블을 건너뜀: 텍스트 스타일 데이터가 없음"
+"connector label was skipped: text transform is invalid" = "커넥터 레이블을 건너뜀: 텍스트 변형이 잘못됨"
+"connector labels were skipped" = "커넥터 레이블을 건너뜀"
+"connector layers import as static frame/vector snapshots with labels when present; live endpoint bindings are not retained" = "커넥터 레이어는 정적인 프레임/벡터 스냅샷으로 가져오며 레이블이 있으면 함께 가져옴. 끝점의 동적 바인딩은 유지되지 않음"
+"connector snapshot vector data is missing; connector was left empty" = "커넥터 스냅샷의 벡터 데이터가 없어 커넥터를 비워 둠"
+"connectors whose ends can't be placed are empty" = "끝점을 배치할 수 없는 커넥터는 비어 있음"
 "crop marks" = "재단선 표시"
+"damaged vector geometry was skipped" = "손상된 벡터 지오메트리를 건너뜀"
+"damaged vector networks import as outlines" = "손상된 벡터 네트워크는 윤곽선으로 가져옴"
 "development: {path}" = "개발: {path}"
+"document children other than pages were skipped" = "페이지가 아닌 문서 하위 항목을 건너뜀"
+"duplicate grid track sizing entries use equal tracks" = "중복된 그리드 트랙 크기 항목은 균등한 트랙을 사용함"
 "e.g. count + 1" = "예: count + 1"
 "e.g. count >= 3 and not done" = "예: count >= 3 and not done"
+"elbowed and curved connectors without a saved path import as straight lines" = "저장된 경로가 없는 꺾인 커넥터와 곡선 커넥터는 직선으로 가져옴"
+"entries without a node type were skipped" = "노드 유형이 없는 항목을 건너뜀"
 "figcraft:// links from a browser, chat or email open this app and join the session." = "브라우저, 채팅, 이메일의 figcraft:// 링크로 이 앱을 열고 세션에 참여함."
+"filled areas of a vector with their own fill use the layer's fill" = "자체 채우기가 있는 벡터의 채워진 영역은 레이어의 채우기를 사용함"
 "from {server}" = "{server}에서"
+"gamepad triggers without exactly one known controller button were skipped" = "알려진 컨트롤러 버튼이 정확히 하나가 아닌 게임패드 트리거를 건너뜀"
+"grid track list exceeds 1000 entries; the tracks use the default equal sizing" = "그리드 트랙 목록이 1000개 항목을 넘어 트랙은 기본 균등 크기를 사용함"
+"grid track sizing is unsupported or malformed; affected tracks use equal sizing" = "그리드 트랙 크기가 지원되지 않거나 잘못되어 해당 트랙은 균등 크기를 사용함"
+"grid track sizing list exceeds 1000 entries; the tracks use the default equal sizing" = "그리드 트랙 크기 목록이 1000개 항목을 넘어 트랙은 기본 균등 크기를 사용함"
 "hidden" = "숨김"
 "iOS" = "iOS"
+"image filters are ambiguous because both filter containers are present; filter conversion was skipped" = "필터 컨테이너가 둘 다 있어 이미지 필터가 모호하므로 필터 변환을 건너뜀"
+"image filters use FigCraft's approximate renderer" = "이미지 필터는 FigCraft의 근사 렌더링을 사용함"
+"instance swap properties whose default component isn't in the file were skipped" = "기본 컴포넌트가 파일에 없는 인스턴스 교체 속성을 건너뜀"
+"instances inside their own main component were imported as frames" = "자체 메인 컴포넌트 안에 있는 인스턴스는 프레임으로 가져옴"
+"instances of components that aren't in the file show no layers" = "파일에 없는 컴포넌트의 인스턴스에는 레이어가 표시되지 않음"
+"instances of components that aren't in the file were imported as frames" = "파일에 없는 컴포넌트의 인스턴스는 프레임으로 가져옴"
+"instances that would nest a component inside itself were imported as frames" = "컴포넌트를 자기 안에 중첩하게 되는 인스턴스는 프레임으로 가져옴"
+"instances without a main component were imported as empty frames" = "메인 컴포넌트가 없는 인스턴스는 빈 프레임으로 가져옴"
+"invalid internal .fig text path data was ignored" = "잘못된 .fig 내부 패스 위 텍스트 데이터를 무시함"
+"invalid or oversized vector networks import as outlines" = "잘못되었거나 너무 큰 벡터 네트워크는 윤곽선으로 가져옴"
+"invalid or oversized vector path data was skipped" = "잘못되었거나 너무 큰 벡터 경로 데이터를 건너뜀"
+"key triggers without a supported key were skipped" = "지원되는 키가 없는 키 트리거를 건너뜀"
+"key up triggers import as key presses" = "키를 뗄 때 트리거는 키 누름으로 가져옴"
+"layers without a position were placed at their parent's origin" = "위치가 없는 레이어는 상위 요소의 원점에 배치됨"
+"layers without a type were skipped" = "유형이 없는 레이어를 건너뜀"
+"legacy image filter container is unsupported; filter conversion was skipped" = "레거시 이미지 필터 컨테이너는 지원되지 않아 필터 변환을 건너뜀"
 "locked" = "잠김"
+"malformed image filters container was skipped" = "잘못된 형식의 이미지 필터 컨테이너를 건너뜀"
+"malformed image paintFilter container was skipped" = "잘못된 형식의 이미지 paintFilter 컨테이너를 건너뜀"
+"malformed slot content assignment was skipped" = "잘못된 형식의 슬롯 콘텐츠 할당을 건너뜀"
 "no bleed" = "도련 없음"
 "nobody else here yet" = "아직 다른 사람이 없음"
+"non-default slot settings are not represented and were skipped" = "기본값이 아닌 슬롯 설정은 표현할 수 없어 건너뜀"
 "now" = "방금"
 "or" = "또는"
+"point stroke joins were preserved; dashed or variable-width strokes render with the layer join" = "점별 선 연결을 유지함. 파선이나 가변 너비 선은 레이어의 선 연결로 그려짐"
+"preferred slot component keys cannot be resolved to file nodes and were skipped" = "슬롯의 기본 설정 컴포넌트 키를 파일의 레이어로 확인할 수 없어 건너뜀"
+"prototype actions of unknown types were skipped" = "알 수 없는 유형의 프로토타입 액션을 건너뜀"
+"prototype actions without a destination in the file were skipped" = "파일에 대상이 없는 프로토타입 액션을 건너뜀"
+"prototype expressions on variables that aren't in the variables JSON were skipped" = "변수 JSON에 없는 변수에 대한 프로토타입 수식을 건너뜀"
+"prototype expressions with unsupported functions were skipped" = "지원되지 않는 함수가 있는 프로토타입 수식을 건너뜀"
+"prototype interactions without supported actions were skipped" = "지원되는 액션이 없는 프로토타입 인터랙션을 건너뜀"
+"prototype navigations of unknown types were skipped" = "알 수 없는 유형의 프로토타입 탐색을 건너뜀"
+"prototype transitions of unknown types play instantly" = "알 수 없는 유형의 프로토타입 전환은 즉시 재생됨"
+"prototype triggers of unknown types were skipped" = "알 수 없는 유형의 프로토타입 트리거를 건너뜀"
 "put a widget on the canvas" = "캔버스에 위젯 배치"
 "read and edit the document" = "문서 읽기 및 편집"
 "read the document" = "문서 읽기"
 "reads the document" = "문서를 읽음"
+"set-variable actions on variables that aren't in the variables JSON were skipped" = "변수 JSON에 없는 변수에 대한 변수 설정 액션을 건너뜀"
+"set-variable actions with values that can't be evaluated were skipped" = "평가할 수 없는 값이 있는 변수 설정 액션을 건너뜀"
+"set-variable actions with values that don't fit the variable were skipped" = "변수에 맞지 않는 값이 있는 변수 설정 액션을 건너뜀"
+"set-variable actions without a value were skipped" = "값이 없는 변수 설정 액션을 건너뜀"
+"set-variable-mode actions on collections or modes that aren't in the variables JSON were skipped" = "변수 JSON에 없는 컬렉션이나 모드에 대한 변수 모드 설정 액션을 건너뜀"
+"slot content assignment target is missing or is not slot content" = "슬롯 콘텐츠 할당 대상이 없거나 슬롯 콘텐츠가 아님"
+"slot content assignment uses the empty GUID sentinel and was skipped" = "슬롯 콘텐츠 할당이 빈 GUID를 센티넬 값으로 사용하여 건너뜀"
+"some vector points refer to point settings missing from the file; they use the layer's joins and plain corners" = "일부 벡터 점이 파일에 없는 점 설정을 참조함. 해당 점은 레이어의 선 연결과 둥글리지 않은 모서리를 사용함"
+"some vector segments refer to style settings missing from the file; they use the layer's stroke" = "일부 벡터 세그먼트가 파일에 없는 스타일 설정을 참조함. 해당 세그먼트는 레이어의 선을 사용함"
+"stale or invalid grid track sizing entries were ignored" = "오래되었거나 잘못된 그리드 트랙 크기 항목을 무시함"
+"stars and polygons without point counts or geometry use the default point count" = "점 개수나 지오메트리가 없는 별과 다각형은 기본 점 개수를 사용함"
+"style settings of some vector segments aren't supported; those segments use the layer's stroke" = "일부 벡터 세그먼트의 스타일 설정은 지원되지 않음. 해당 세그먼트는 레이어의 선을 사용함"
+"text path underline or strikethrough decoration is not rendered" = "패스 위 텍스트의 밑줄 또는 취소선은 그려지지 않음"
+"text style overrides refer to missing table entries" = "텍스트 스타일 재정의가 없는 테이블 항목을 참조함"
+"the file has no pages" = "파일에 페이지가 없음"
 "the plugin" = "이 플러그인"
+"the variables JSON has no `variableCollections` (expected the local variables response) and was ignored" = "변수 JSON에 `variableCollections`가 없어(로컬 변수 응답이어야 함) 무시함"
 "this session only" = "이 세션만"
+"unknown component property types were skipped" = "알 수 없는 컴포넌트 속성 유형을 건너뜀"
+"variable aliases to variables that aren't in the variables JSON (or of another type) were skipped" = "변수 JSON에 없거나 유형이 다른 변수에 대한 별칭을 건너뜀"
+"variable bindings to properties the layer doesn't have were skipped" = "레이어에 없는 속성에 대한 변수 바인딩을 건너뜀"
+"variable bindings to variables that aren't in the variables JSON (library variables) were skipped" = "변수 JSON에 없는 변수(라이브러리 변수)에 대한 바인딩을 건너뜀"
+"variable bindings were skipped: the file JSON has no variable definitions (pass the local variables JSON as `variables`, or embed its `meta` next to the file JSON)" = "변수 바인딩을 건너뜀: 파일 JSON에 변수 정의가 없음(로컬 변수 JSON을 `variables`로 전달하거나 파일 JSON 옆에 해당 `meta`를 포함하세요)"
+"variable bindings whose variable type doesn't fit the property were skipped" = "변수 유형이 속성에 맞지 않는 변수 바인딩을 건너뜀"
+"variable collections without modes were skipped" = "모드가 없는 변수 컬렉션을 건너뜀"
+"variable mode lookups in prototype expressions that aren't a variable and one of its modes were skipped" = "변수와 그 모드 중 하나가 아닌, 프로토타입 수식의 변수 모드 조회를 건너뜀"
+"variable modes of collections that aren't in the file were skipped" = "파일에 없는 컬렉션의 변수 모드를 건너뜀"
+"variable modes of collections that aren't in the variables JSON were skipped" = "변수 JSON에 없는 컬렉션의 변수 모드를 건너뜀"
+"variable values that don't match their type (or composed colours) were skipped" = "유형과 맞지 않는 변수 값(또는 합성 색상)을 건너뜀"
+"variables of unknown types were skipped" = "알 수 없는 유형의 변수를 건너뜀"
+"variables whose collection isn't in the variables JSON were skipped" = "컬렉션이 변수 JSON에 없는 변수를 건너뜀"
+"variables without readable values were skipped" = "읽을 수 있는 값이 없는 변수를 건너뜀"
+"vector points with unknown stroke joins use the layer join" = "알 수 없는 선 연결이 있는 벡터 점은 레이어의 선 연결을 사용함"
+"vectors without geometry are empty" = "지오메트리가 없는 벡터는 비어 있음"
+"vectors without geometry are empty (export the file JSON with geometry=paths)" = "지오메트리가 없는 벡터는 비어 있음(geometry=paths로 파일 JSON을 내보내세요)"
+"very long text was cut to 1,048,576 characters" = "매우 긴 텍스트를 1,048,576자로 잘랐음"
+"very long vector paths were skipped" = "매우 긴 벡터 경로를 건너뜀"
+"video actions are not supported and were skipped" = "비디오 액션은 지원되지 않아 건너뜀"
+"video triggers are not supported and were skipped" = "비디오 트리거는 지원되지 않아 건너뜀"
 "{instances} in {files}" = "{files}의 {instances}"
 "{language}: draft translation, waiting for a native speaker's review." = "{language}: 초안 번역, 원어민 검토 대기 중."
 "{length} bleed" = "도련 {length}"
@@ -1459,6 +1611,7 @@ status = "draft — needs native review"
 "{name} is forgotten on this computer; the file stays on {server}" = "{name}의 기록을 이 컴퓨터에서 지움. 파일은 {server}에 남음"
 "{name} is on the server." = "{name}이(가) 서버에 있음."
 "{name} is spotlighting" = "{name} 님이 스포트라이트 중"
+"{name} is too large to open in the browser (over 512 MB)." = "{name}은(는) 너무 커서 브라우저에서 열 수 없습니다(512MB 초과)."
 "{name} was removed from the server" = "{name}을(를) 서버에서 제거함"
 "{name} · deleted on main" = "{name} · 메인에서 삭제됨"
 "{name} · deleted on the branch" = "{name} · 브랜치에서 삭제됨"
@@ -1487,6 +1640,7 @@ status = "draft — needs native review"
 "{n} matches" = { other = "{n}개 일치" }
 "{n} minutes ago" = { other = "{n}분 전" }
 "{n} months ago" = { other = "{n}개월 전" }
+"{n} more notes omitted from this report" = { other = "참고 사항 {n}개가 이 보고서에서 더 생략됨" }
 "{n} of {total}" = "{n} / {total}"
 "{n} people joined" = { other = "{n}명 참여함" }
 "{n} preferred components" = { other = "선호 컴포넌트 {n}개" }
@@ -1546,7 +1700,17 @@ status = "draft — needs native review"
 "arrange.packH" = "가로로 붙이기"
 "arrange.packV" = "세로로 붙이기"
 "arrange.roundToPixels" = "픽셀에 맞춰 반올림"
+"arrange.spacing" = "간격"
 "arrange.tidy" = "정돈"
+"board.connector" = "커넥터"
+"board.ink" = "마커 획"
+"board.label" = "커넥터 레이블"
+"board.nextSticky" = "다음 스티커 메모"
+"board.setColor" = "보드 색상"
+"board.setStyle" = "보드 스타일"
+"board.shape" = "텍스트가 있는 도형"
+"board.stamp" = "스탬프"
+"board.sticky" = "스티커 메모"
 "bool.exclude" = "선택 항목 제외"
 "bool.flatten" = "불리언 평면화"
 "bool.intersect" = "선택 항목 교차"
@@ -1645,6 +1809,7 @@ status = "draft — needs native review"
 "edit.duplicate" = "복제"
 "edit.findReplace" = "찾기 및 바꾸기"
 "edit.paste" = "붙여 넣기"
+"edit.pasteDesignLayers" = "디자인 레이어 붙여 넣기"
 "edit.pasteOver" = "선택 항목 위에 붙여 넣기"
 "edit.pasteProperties" = "속성 붙여 넣기"
 "edit.pasteReplace" = "붙여 넣어 바꾸기"
@@ -1668,7 +1833,9 @@ status = "draft — needs native review"
 "file.exportLayers" = "레이어 내보내기"
 "file.exportSvg" = "선택 항목을 SVG로 내보내기"
 "file.import" = "가져오기"
+"file.moveTab" = "탭 이동"
 "file.new" = "새 디자인 파일"
+"file.newBoard" = "새 보드"
 "file.open" = "열기"
 "file.openRecent" = "최근 파일 열기"
 "file.placeImage" = "이미지 배치"
@@ -1805,6 +1972,7 @@ status = "draft — needs native review"
 "pref.reduceMotion" = "동작 줄이기"
 "pref.renameDuplicates" = "복제한 레이어 이름 바꾸기"
 "pref.showDimensions" = "개체에 치수 표시"
+"pref.startOnHome" = "홈에서 시작"
 "pref.userName" = "댓글에 표시할 이름"
 "proto.action.add" = "프로토타입 액션 추가"
 "proto.action.move" = "프로토타입 액션 순서 변경"
@@ -1848,6 +2016,10 @@ status = "draft — needs native review"
 "select.sameStroke" = "같은 선 선택"
 "select.sameText" = "같은 텍스트 속성 선택"
 "select.set" = "선택"
+"selection.applyColorStyle" = "선택 항목에 색상 스타일 적용"
+"selection.colors" = "선택 항목 색상"
+"selection.selectColor" = "이 색상의 레이어 선택"
+"selection.setPaint" = "선택 항목 색상 변경"
 "shape.arrow" = "화살표"
 "shape.ellipse" = "타원"
 "shape.line" = "선"
@@ -1927,10 +2099,14 @@ status = "draft — needs native review"
 "text.weightUp" = "글꼴 굵기 늘리기"
 "tool.arrow" = "화살표"
 "tool.comment" = "댓글"
+"tool.connector" = "커넥터"
 "tool.ellipse" = "타원"
+"tool.eraser" = "지우개"
 "tool.frame" = "프레임"
 "tool.hand" = "손"
+"tool.highlighter" = "형광펜"
 "tool.line" = "선"
+"tool.marker" = "마커"
 "tool.move" = "이동"
 "tool.pen" = "펜"
 "tool.pencil" = "연필"
@@ -1942,9 +2118,12 @@ status = "draft — needs native review"
 "tool.scaleAnchor" = "배율 기준점"
 "tool.section" = "섹션"
 "tool.set" = "도구 선택"
+"tool.shape" = "도형"
 "tool.shapeBuilder" = "도형 빌더"
 "tool.slice" = "슬라이스"
+"tool.stamp" = "스탬프"
 "tool.star" = "별"
+"tool.sticky" = "스티커 메모"
 "tool.text" = "텍스트"
 "transform.move" = "이동"
 "transform.moveTo" = "위치로 이동"
@@ -2006,11 +2185,13 @@ status = "draft — needs native review"
 "vector.edit.tool" = "벡터 편집 도구"
 "vector.edit.transform" = "점 변형"
 "vector.edit.widthPoint" = "너비 점"
+"vector.fillRule" = "칠 규칙 설정"
 "vector.flatten" = "평면화"
 "vector.join" = "선택 항목 연결"
 "vector.offset" = "패스 오프셋"
 "vector.outlineStroke" = "선 윤곽선 만들기"
 "vector.reverse" = "패스 방향 반전"
+"vector.reverseLoop" = "루프 반전"
 "vector.simplify" = "벡터 단순화"
 "vector.smoothJoin" = "선택 항목 부드럽게 연결"
 "version.autosave" = "자동 저장 버전"
diff --git a/crates/ui-egui/locales/nl.toml b/crates/ui-egui/locales/nl.toml
new file mode 100644
index 000000000..84f13545a
--- /dev/null
+++ b/crates/ui-egui/locales/nl.toml
@@ -0,0 +1,2391 @@
+# FigCraft interface strings: Dutch (Nederlands).
+#
+# Draft — needs native review: machine-drafted from the English catalog. Established tool terms
+# (frame, auto layout, component, variant, prototype, overlay, widget, plugin, branch, constraints)
+# and blend-mode, brush-preset and boolean names stay as they are. See docs/translating.md.
+
+[meta]
+name = "Nederlands"
+status = "draft — needs native review"
+
+[ui]
+
+"% of all commits" = "% van alle commits"
+"(no longer published)" = "(niet langer gepubliceerd)"
+"({n} warnings: some entries were skipped)" = { one = "({n} waarschuwing: sommige items zijn overgeslagen)", other = "({n} waarschuwingen: sommige items zijn overgeslagen)" }
+"+ Create variable" = "+ Variabele maken"
+".fig (experimental)" = ".fig (experimental)"
+"1…9, 0" = "1…9, 0"
+"@{login}: {prs} PRs, {commits} commits, +{added} / −{deleted} lines (Δ {delta}), +{bin_added} / −{bin_deleted} binary assets, {first} – {last}" = "@{login}: {prs} PRs, {commits} commits, +{added} / −{deleted} regels (Δ {delta}), +{bin_added} / −{bin_deleted} binaire assets, {first} – {last}"
+"A .figcraft file with this name already exists. Choose its full name to confirm replacement." = "Er bestaat al een .figcraft-bestand met deze naam. Kies de volledige naam om de vervanging te bevestigen."
+"A collection of this file with these modes and variables: override their values per mode and add variables of its own" = "Een verzameling van dit bestand met deze modi en variabelen: overschrijf hun waarden per modus en voeg er eigen variabelen toe"
+"A layer on its own aligns to its frame: select more layers, or one in a frame" = "Een losse laag wordt uitgelijnd op zijn frame: selecteer meer lagen, of één in een frame"
+"A responsive product page: hero, features, figures, a quote and a footer" = "Een responsive productpagina: hero, features, afbeeldingen, een citaat en een footer"
+"A spring plays until it settles: its mass, stiffness and damping set how long" = "Een veer speelt tot hij tot rust komt: zijn massa, stijfheid en demping bepalen hoe lang"
+"A title, an agenda, a big figure, a chart and a closing slide" = "Een titel, een agenda, een grote afbeelding, een grafiek en een afsluitende dia"
+"A to Z" = "A tot Z"
+"About" = "Over"
+"About FigCraft" = "Over FigCraft"
+"About this server" = "Over deze server"
+"Action" = "Actie"
+"Actions" = "Acties"
+"Actions for {name}" = "Acties voor {name}"
+"Actions…" = "Acties…"
+"Active" = "Actief"
+"Actual size (100%)" = "Werkelijke grootte (100%)"
+"Add a category" = "Categorie toevoegen"
+"Add a comment" = "Reactie toevoegen"
+"Add a description" = "Beschrijving toevoegen"
+"Add a frame (F) or a shape (R) to get started" = "Voeg een frame (F) of een vorm (R) toe om te beginnen"
+"Add a layer or component to tile first" = "Voeg eerst een laag of component toe om als tegel te gebruiken"
+"Add a note for developers" = "Notitie voor ontwikkelaars toevoegen"
+"Add action" = "Actie toevoegen"
+"Add actions for when no condition holds" = "Voeg acties toe voor het geval geen enkele voorwaarde geldt"
+"Add an annotation for developers" = "Annotatie voor developers toevoegen"
+"Add another condition" = "Nog een voorwaarde toevoegen"
+"Add auto layout" = "Auto layout toevoegen"
+"Add background behind overlay" = "Achtergrond achter overlay toevoegen"
+"Add content to this slot" = "Voeg inhoud toe aan dit slot"
+"Add dev resource" = "Dev-resource toevoegen"
+"Add effect" = "Effect toevoegen"
+"Add export setting" = "Exportinstelling toevoegen"
+"Add fill" = "Vulling toevoegen"
+"Add interaction" = "Interactie toevoegen"
+"Add layout grid" = "Layoutraster toevoegen"
+"Add library" = "Bibliotheek toevoegen"
+"Add library file…" = "Bibliotheekbestand toevoegen…"
+"Add max height" = "Maximale hoogte toevoegen"
+"Add max width" = "Maximale breedte toevoegen"
+"Add min height" = "Minimale hoogte toevoegen"
+"Add min width" = "Minimale breedte toevoegen"
+"Add mode" = "Modus toevoegen"
+"Add new page" = "Nieuwe pagina toevoegen"
+"Add or update collections from a variables JSON" = "Voeg verzamelingen toe of werk ze bij vanuit een variables-JSON"
+"Add properties to make instances configurable" = "Voeg eigenschappen toe om instances configureerbaar te maken"
+"Add reaction" = "Reactie toevoegen"
+"Add starting point" = "Startpunt toevoegen"
+"Add stroke" = "Lijn toevoegen"
+"Add variant" = "Variant toevoegen"
+"Add variant with a new value" = "Variant met een nieuwe waarde toevoegen"
+"Added" = "Toegevoegd"
+"Added the library \"{name}\"" = "Bibliotheek \"{name}\" toegevoegd"
+"Adding to {name}" = "Toevoegen aan {name}"
+"Adjust" = "Aanpassen"
+"Adjustment presets" = "Aanpassingspresets"
+"Advanced" = "Geavanceerd"
+"Advanced stroke" = "Geavanceerde lijn"
+"After delay" = "Na vertraging"
+"After delay {ms}ms" = "Na {ms}ms vertraging"
+"Align" = "Uitlijnen"
+"Align bottom" = "Onderaan uitlijnen"
+"Align center" = "Midden uitlijnen"
+"Align horizontal centers" = "Horizontale middens uitlijnen"
+"Align left" = "Links uitlijnen"
+"Align middle" = "Midden uitlijnen"
+"Align right" = "Rechts uitlijnen"
+"Align text baselines" = "Tekstbasislijnen uitlijnen"
+"Align top" = "Bovenaan uitlijnen"
+"Align vertical centers" = "Verticale middens uitlijnen"
+"Alignment" = "Uitlijning"
+"All" = "Alle"
+"All categories" = "Alle categorieën"
+"All comments" = "Alle reacties"
+"All components" = "Alle components"
+"All fonts" = "Alle lettertypen"
+"All supported properties" = "Alle ondersteunde eigenschappen"
+"All the fonts this file uses are installed" = "Alle lettertypen die dit bestand gebruikt zijn geïnstalleerd"
+"All variables" = "Alle variabelen"
+"Alpha" = "Alpha"
+"Alphabetical" = "Alfabetisch"
+"Alt+drag" = "Alt+drag"
+"An analytics screen on a grid: figures, charts drawn from vectors and a table" = "Een analysescherm op een raster: cijfers, diagrammen getekend met vectoren en een tabel"
+"An invite link that opens FigCraft and joins" = "Een uitnodigingslink die FigCraft opent en waarmee je deelneemt"
+"Anchor" = "Anker"
+"Android" = "Android"
+"Angular" = "Angular"
+"Animation" = "Animatie"
+"Annotations" = "Annotaties"
+"Annotations shown on the canvas" = "Annotaties die op het canvas worden weergegeven"
+"Another server, or one that needs its key. The usual server is set in Preferences." = "Een andere server, of een server waarvoor je een sleutel nodig hebt. De gebruikelijke server stel je in bij Voorkeuren."
+"Any status" = "Alle statussen"
+"Anyone on your network with this code can edit the file, while this app stays open." = "Iedereen in je netwerk met deze code kan het bestand bewerken, zolang deze app open blijft."
+"Anyone with the edit link can change the file; the view link only lets people look. The links carry their secrets: share them like passwords. `figcraft-server links` makes more and revokes them." = "Iedereen met de bewerklink kan het bestand wijzigen; de weergavelink laat mensen alleen kijken. De links bevatten geheimen: deel ze alsof het wachtwoorden zijn. Met `figcraft-server links` maak je er meer en trek je ze in."
+"Anyone with this code can edit the file." = "Iedereen met deze code kan het bestand bewerken."
+"Anyone with this code can look at the file, not change it." = "Iedereen met deze code kan het bestand bekijken, maar niet wijzigen."
+"Appearance" = "Weergave"
+"Apply a component property" = "Een componenteigenschap toepassen"
+"Apply variable" = "Variabele toepassen"
+"Apply variable to text" = "Variabele toepassen op tekst"
+"Apply variable to visibility" = "Variabele toepassen op zichtbaarheid"
+"Apps" = "Apps"
+"Apr" = "apr."
+"Arc" = "Boog"
+"Arc ratio" = "Boogverhouding"
+"Arc start" = "Start van de boog"
+"Arc sweep" = "Boogdoorloop"
+"Archive" = "Archiveren"
+"Archived" = "Gearchiveerd"
+"Arrange" = "Schikken"
+"Arrow" = "Pijl"
+"Arrow at the end" = "Pijl aan het eind"
+"As typed" = "Zoals getypt"
+"Asking the server…" = "Bezig met vragen aan de server…"
+"Assets" = "Assets"
+"Aug" = "aug."
+"Auto" = "Auto"
+"Auto (space around)" = "Auto (ruimte eromheen)"
+"Auto (space between)" = "Auto (afstand ertussen)"
+"Auto (space evenly)" = "Auto (gelijkmatig verdelen)"
+"Auto ({mode})" = "Auto ({mode})"
+"Auto columns" = "Automatische kolommen"
+"Auto gap" = "Automatische afstand"
+"Auto height" = "Automatische hoogte"
+"Auto layout" = "Auto layout"
+"Auto rows" = "Automatische rijen"
+"Auto width" = "Automatische breedte"
+"Back" = "Terug"
+"Back to Ready for dev" = "Terug naar Ready for dev"
+"Back to Ready for dev: the next change compares with how it is now" = "Terug naar Gereed voor dev: de volgende wijziging wordt vergeleken met hoe het nu is"
+"Back to assets" = "Terug naar assets"
+"Back to current" = "Terug naar huidige"
+"Back to styles" = "Terug naar stijlen"
+"Back to the FigCraft server" = "Terug naar de FigCraft-server"
+"Back to the canvas from a focused region" = "Terug naar het canvas vanuit een focusgebied"
+"Back to the current version" = "Terug naar de huidige versie"
+"Back to the font's value" = "Terug naar de waarde van het lettertype"
+"Back to the values the font style implies" = "Terug naar de waarden die bij de lettertypestijl horen"
+"Background" = "Achtergrond"
+"Background blur" = "Achtergrondvervaging"
+"Basics" = "Basis"
+"Before" = "Voor"
+"Bend" = "Buiging"
+"Bevel" = "Afgeschuind"
+"Binary assets added" = "Binaire assets toegevoegd"
+"Binary assets removed" = "Verwijderde binaire assets"
+"Black & white" = "Black & white"
+"Bleed" = "Afloop"
+"Bleed marks" = "Aansnijmarkeringen"
+"Bleed marks need a bleed" = "Aansnijtekens vereisen een aansnijrand"
+"Blend" = "Mengmodus"
+"Blend mode" = "Blendmodus"
+"Blue" = "Blauw"
+"Blur" = "Vervaging"
+"Boolean" = "Boolean"
+"Boolean groups" = "Booleaanse groepen"
+"Both directions" = "Beide richtingen"
+"Bottom" = "Onder"
+"Bottom left radius" = "Radius linksonder"
+"Bottom right radius" = "Radius rechtsonder"
+"Bound to {name}. Click to detach the variable." = "Gekoppeld aan {name}. Klik om de variabele los te koppelen."
+"Branch" = "Branch"
+"Branch archived" = "Branch gearchiveerd"
+"Branch merged" = "Branch samengevoegd"
+"Branch name" = "Branchnaam"
+"Branch of {file}" = "Branch van {file}"
+"Branch of {file} · merged or archived" = "Branch van {file} · samengevoegd of gearchiveerd"
+"Branch updated from main" = "Branch bijgewerkt vanaf main"
+"Branch {name}" = "Branch {name}"
+"Branches" = "Branches"
+"Bring forward" = "Naar voren brengen"
+"Bring the main file's changes into the branch" = "De wijzigingen uit het hoofdbestand in de branch brengen"
+"Bring to front" = "Op de voorgrond plaatsen"
+"Bristle" = "Bristle"
+"Browse" = "Bladeren"
+"Brush" = "Penseel"
+"Brush rotation jitter" = "Penseelrotatiejitter"
+"Brush scatter" = "Penseelverstrooiing"
+"Brush size jitter" = "Penseelgrootte-jitter"
+"Brush spacing" = "Penseelafstand"
+"Bulleted list" = "Lijst met opsommingstekens"
+"C or Shift+C" = "C of Shift+C"
+"C or ⇧C" = "C of ⇧C"
+"CMYK colour" = "CMYK-kleur"
+"CSS custom properties…" = "CSS-variabelen…"
+"Can edit" = "Kan bewerken"
+"Can view" = "Kan bekijken"
+"Can't read this library: {e}" = "Kan deze bibliotheek niet lezen: {e}"
+"Cancel" = "Annuleren"
+"Canvas" = "Canvas"
+"Canvas stacking" = "Stapeling op canvas"
+"Cap height to baseline" = "Hoofdletterhoogte tot basislijn"
+"Case" = "Hoofdlettergebruik"
+"Case-sensitive forms" = "Hoofdlettergevoelige vormen"
+"Categories" = "Categorieën"
+"Center" = "Midden"
+"Change alias" = "Alias wijzigen"
+"Change resolved" = "Wijziging opgelost"
+"Change style" = "Stijl wijzigen"
+"Change to" = "Wijzigen naar"
+"Change to needs a layer inside a variant" = "Wijzigen naar vereist een laag binnen een variant"
+"Changed" = "Gewijzigd"
+"Changed on both sides: keep one" = "Aan beide kanten gewijzigd: één behouden"
+"Changes on main" = "Wijzigingen op main"
+"Changes on the branch" = "Wijzigingen op de branch"
+"Changes unknown" = "Onbekende wijzigingen"
+"Check" = "Vinkje"
+"Checking the fonts installed on this computer…" = "De lettertypen op deze computer worden gecontroleerd…"
+"Checking the server…" = "Server controleren…"
+"Chevron" = "Punthaak"
+"Choose React, Leptos, SwiftUI or Compose above to connect this component to its code." = "Kies hierboven React, Leptos, SwiftUI of Compose om dit component aan zijn code te koppelen."
+"Choose another profile to change it." = "Kies een ander profiel om dit te wijzigen."
+"Choose collection" = "Kies een verzameling"
+"Choose image" = "Afbeelding kiezen"
+"Choose mode" = "Modus kiezen"
+"Choose variable" = "Variabele kiezen"
+"Circle" = "Cirkel"
+"Clear from this list" = "Verwijderen uit deze lijst"
+"Clear recent" = "Recenten wissen"
+"Click + to replace mixed content" = "Klik op + om gemengde inhoud te vervangen"
+"Click anywhere on the canvas to leave one." = "Klik ergens op het canvas om er een achter te laten."
+"Click or drag to merge · {alt} removes" = "Klik of sleep om samen te voegen · {alt} verwijdert"
+"Click or drag to remove · {alt} merges" = "Klik of sleep om te verwijderen · {alt} voegt samen"
+"Click to record a key" = "Klik om een toets op te nemen"
+"Clip content" = "Inhoud bijsnijden"
+"Clip to shape" = "Bijsnijden op vorm"
+"Close" = "Sluiten"
+"Close overlay" = "Overlay sluiten"
+"Close preview" = "Voorvertoning sluiten"
+"Close tab" = "Tabblad sluiten"
+"Close version history" = "Versiegeschiedenis sluiten"
+"Close when clicking outside" = "Sluiten bij klikken erbuiten"
+"Code" = "Code"
+"Code or invite link" = "Code of uitnodigingslink"
+"Code syntax" = "Code-syntaxis"
+"Collapse" = "Inklappen"
+"Collapse panel" = "Paneel samenvouwen"
+"Collection" = "Verzameling"
+"Collections" = "Verzamelingen"
+"Color" = "Kleur"
+"Color burn" = "Color burn"
+"Color dodge" = "Color dodge"
+"Color format" = "Kleurnotatie"
+"Color profile" = "Kleurprofiel"
+"Color profile: {name}" = "Kleurprofiel: {name}"
+"Color styles" = "Kleurstijlen"
+"Color values in this file are in this color space." = "Kleurwaarden in dit bestand gebruiken deze kleurruimte."
+"Color variables" = "Kleurvariabelen"
+"Colour" = "Kleur"
+"Colour and text styles, Light and Dark variables, buttons, inputs and cards" = "Kleur- en tekststijlen, lichte en donkere variabelen, knoppen, invoervelden en kaarten"
+"Column" = "Kolom"
+"Column gap" = "Kolomafstand"
+"Column sizes" = "Kolomgroottes"
+"Column span" = "Kolomspan"
+"Columns" = "Kolommen"
+"Columns {count}" = "Kolommen {count}"
+"Comment" = "Reactie"
+"Comments" = "Reacties"
+"Commits" = "Commits"
+"Company" = "Bedrijf"
+"Compare changes" = "Wijzigingen vergelijken"
+"Compatibility notes" = "Compatibiliteitsopmerkingen"
+"Completed" = "Voltooid"
+"Component" = "Component"
+"Component name" = "Componentnaam"
+"Component property" = "Componenteigenschap"
+"Component set" = "Componentenset"
+"Component sets" = "Componentensets"
+"Components" = "Components"
+"Conditional" = "Voorwaardelijk"
+"Confetti" = "Confetti"
+"Conflicts" = "Conflicten"
+"Connect to code" = "Verbinden met code"
+"Connected" = "Verbonden"
+"Connected to code: {from}" = "Verbonden met code: {from}"
+"Connection lost, reconnecting (attempt {attempt})…" = "Verbinding verbroken, opnieuw verbinden (poging {attempt})…"
+"Connector" = "Verbinding"
+"Constrain proportions" = "Verhoudingen vergrendelen"
+"Constraints" = "Constraints"
+"Content" = "Inhoud"
+"Contents hidden" = "Inhoud verborgen"
+"Contents only" = "Alleen de inhoud"
+"Contextual alternates" = "Contextuele alternatieven"
+"Contrast" = "Contrast"
+"Contributors" = "Bijdragers"
+"Contributors: {people} · Commits: {commits}" = "Bijdragers: {people} · Commits: {commits}"
+"Controller" = "Controller"
+"Convert to frame" = "Converteren naar frame"
+"Convert to section" = "Converteren naar sectie"
+"Cool" = "Cool"
+"Copied as CSS" = "Gekopieerd als CSS"
+"Copied as PNG" = "Gekopieerd als PNG"
+"Copied as SVG" = "Gekopieerd als SVG"
+"Copied as text" = "Gekopieerd als tekst"
+"Copied {value}" = "{value} gekopieerd"
+"Copy" = "Kopiëren"
+"Copy as" = "Kopiëren als"
+"Copy as CSS" = "Kopiëren als CSS"
+"Copy as PNG" = "Kopiëren als PNG"
+"Copy as SVG" = "Kopiëren als SVG"
+"Copy code" = "Code kopiëren"
+"Copy link" = "Link kopiëren"
+"Copy the {label}" = "Kopieer de {label}"
+"Copy {value}" = "{value} kopiëren"
+"Corner radius" = "Hoekradius"
+"Corner smoothing" = "Hoekafvlakking"
+"Couldn't download the variables" = "De variabelen konden niet worden gedownload"
+"Couldn't reach {server}: showing what this computer remembers." = "Kon {server} niet bereiken: toont wat deze computer onthoudt."
+"Couldn't read {name}." = "Kon {name} niet lezen."
+"Couldn't save automatically: {error}" = "Kan niet automatisch opslaan: {error}"
+"Count" = "Aantal"
+"Create" = "Maken"
+"Create a variable collection first" = "Maak eerst een variabeleverzameling"
+"Create a variable first" = "Maak eerst een variabele"
+"Create alias" = "Alias maken"
+"Create branch" = "Branch aanmaken"
+"Create collection" = "Verzameling maken"
+"Create component" = "Component maken"
+"Create component property" = "Componenteigenschap maken"
+"Create components, styles or variables to publish them as a library." = "Maak componenten, stijlen of variabelen om ze als bibliotheek te publiceren."
+"Create property…" = "Eigenschap maken…"
+"Create style" = "Stijl maken"
+"Create style from the selected text" = "Stijl maken van de geselecteerde tekst"
+"Created" = "Gemaakt"
+"Crop" = "Bijsnijden"
+"Crop marks" = "Snijtekens"
+"Ctrl+arrows" = "Ctrl+pijltjes"
+"Ctrl+click" = "Ctrl+click"
+"Ctrl+scroll" = "Ctrl+scroll"
+"Current name" = "Huidige naam"
+"Current version" = "Huidige versie"
+"Cursor chat" = "Cursorchat"
+"Custom" = "Aangepast"
+"Custom size" = "Aangepaste grootte"
+"Cut" = "Knippen"
+"Dark" = "Donker"
+"Darken" = "Darken"
+"Dash" = "Streep"
+"Dashboard" = "Dashboard"
+"Date created" = "Aanmaakdatum"
+"Dec" = "dec."
+"Decoration" = "Decoratie"
+"Decoration style" = "Decoratiestijl"
+"Deep select" = "Diep selecteren"
+"Default" = "Standaard"
+"Default content" = "Standaardinhoud"
+"Default value (the top-left variant)" = "Standaardwaarde (de variant linksboven)"
+"Delay" = "Vertraging"
+"Delete" = "Verwijderen"
+"Delete category (its annotations stay)" = "Categorie verwijderen (de annotaties blijven staan)"
+"Delete collection" = "Verzameling verwijderen"
+"Delete group" = "Groep verwijderen"
+"Delete mode" = "Modus verwijderen"
+"Delete page" = "Pagina verwijderen"
+"Delete preset" = "Preset verwijderen"
+"Delete property" = "Eigenschap verwijderen"
+"Delete the style (layers keep their values)" = "Verwijdert de stijl (lagen behouden hun waarden)"
+"Delete thread" = "Gesprek verwijderen"
+"Delete variable" = "Variabele verwijderen"
+"Delete “{name}”? This can't be undone." = "“{name}” verwijderen? Dit kan niet ongedaan worden gemaakt."
+"Density" = "Dichtheid"
+"Depth" = "Diepte"
+"Describe how and when to use this component" = "Beschrijf hoe en wanneer je dit component gebruikt"
+"Describe what changed" = "Beschrijf wat er is gewijzigd"
+"Description" = "Beschrijving"
+"Description (optional)" = "Beschrijving (optioneel)"
+"Design" = "Design"
+"Design panel" = "Ontwerppaneel"
+"Design system starter" = "Designsysteem-starter"
+"Desktop" = "Desktop"
+"Destination" = "Bestemming"
+"Detach alias" = "Alias loskoppelen"
+"Detach instance" = "Instance loskoppelen"
+"Detach property" = "Eigenschap loskoppelen"
+"Detach style" = "Stijl loskoppelen"
+"Detach styles" = "Stijlen loskoppelen"
+"Detach variable" = "Variabele loskoppelen"
+"Details" = "Details"
+"Dev Mode" = "Dev Mode"
+"Dev resources" = "Dev-bronnen"
+"Development" = "Ontwikkeling"
+"Device" = "Apparaat"
+"Device at 100%" = "Apparaat op 100%"
+"Diamond" = "Ruit"
+"Difference" = "Difference"
+"Dimensions" = "Afmetingen"
+"Direction" = "Richting"
+"Disconnect from code" = "Loskoppelen van code"
+"Dispersion" = "Dispersie"
+"Display name" = "Weergavenaam"
+"Dissolve" = "Dissolve"
+"Distribute and tidy" = "Verdelen en opruimen"
+"Distribute horizontal spacing" = "Horizontale afstand verdelen"
+"Distribute vertical spacing" = "Verticale afstand verdelen"
+"Divider" = "Scheidslijn"
+"Don't Save" = "Niet opslaan"
+"Don't truncate" = "Niet afkappen"
+"Done" = "Klaar"
+"Done editing" = "Klaar met bewerken"
+"Dots" = "Dots"
+"Dotted" = "Gestippeld"
+"Down" = "Onder"
+"Drafts" = "Concepten"
+"Drag the stroke to add a width point" = "Sleep de lijn om een breedtepunt toe te voegen"
+"Draw" = "Tekenen"
+"Draw a frame" = "Teken een frame"
+"Drawing tools" = "Tekengereedschap"
+"Drop a .figcraft, .fig, .json, .svg or image file." = "Laat een .figcraft-, .fig-, .json-, .svg- of afbeeldingsbestand los."
+"Drop shadow" = "Slagschaduw"
+"Drop to import" = "Loslaten om te importeren"
+"Drop to open" = "Loslaten om te openen"
+"Dual-licensed MIT OR Apache-2.0. Made by the ArtCraft team and community." = "Dual-licensed MIT OR Apache-2.0. Made by the ArtCraft team and community."
+"Duo" = "Duo"
+"Duplicate" = "Dupliceren"
+"Duplicate by dragging" = "Dupliceren door te slepen"
+"Duplicate mode" = "Modus dupliceren"
+"Duplicate page" = "Pagina dupliceren"
+"Edit" = "Bewerken"
+"Edit as an expression" = "Bewerken als expressie"
+"Edit colour" = "Kleur bewerken"
+"Edit comment" = "Reactie bewerken"
+"Edit dev resource" = "Dev-resource bewerken"
+"Edit link" = "Link bewerken"
+"Edit link copied" = "Link om te bewerken gekopieerd"
+"Edit style" = "Stijl bewerken"
+"Edit variable" = "Variabele bewerken"
+"Edit with the builder" = "Bewerken met de builder"
+"Edited {when}" = "Bewerkt {when}"
+"Effect settings" = "Effectinstellingen"
+"Effect styles" = "Effectstijlen"
+"Effects" = "Effecten"
+"Elbow" = "Haaks"
+"Ellipse" = "Ellips"
+"Ellipses" = "Ellipsen"
+"Else" = "Anders"
+"Else if" = "Anders als"
+"Embedded profile" = "Ingebed profiel"
+"Empty" = "Leeg"
+"End" = "End"
+"End point" = "Eindpunt"
+"Ends the session; everyone keeps their copy" = "Beëindigt de sessie; iedereen houdt zijn eigen kopie"
+"Enter" = "Enter"
+"Enter the address of a figcraft-server and press Browse to see the plugins it offers." = "Voer het adres van een figcraft-server in en druk op Bladeren om te zien welke plugins het aanbiedt."
+"Enter to save · Esc to cancel" = "Enter om op te slaan · Esc om te annuleren"
+"Eraser" = "Gum"
+"Esc" = "Esc"
+"Essential" = "Essentieel"
+"Every conflict has a choice." = "Elk conflict heeft een keuze."
+"Every top-level frame already starts a flow" = "Elk frame op het hoogste niveau begint al een flow"
+"Exact opacity (4 then 5: 45%)" = "Exacte dekking (4 dan 5: 45%)"
+"Exclude" = "Exclude"
+"Excluded" = "Uitgesloten"
+"Excluded from layout" = "Uitgesloten van de layout"
+"Excludes" = "Sluit uit"
+"Exclusion" = "Exclusion"
+"Exit focus view (Esc)" = "Focusweergave afsluiten (Esc)"
+"Expand" = "Uitvouwen"
+"Export" = "Exporteren"
+"Export all" = "Alles exporteren"
+"Export frames and layers as PNG, JPG, SVG or PDF" = "Frames en lagen exporteren als PNG, JPG, SVG of PDF"
+"Export page as PNG" = "Pagina exporteren als PNG"
+"Export settings" = "Exportinstellingen"
+"Export variables" = "Variabelen exporteren"
+"Export {name}" = "{name} exporteren"
+"Export {n} layers" = { one = "{n} laag exporteren", other = "{n} lagen exporteren" }
+"Exported {file}" = "{file} geëxporteerd"
+"Exported {name}" = "{name} geëxporteerd"
+"Exported {name}; {n} kinds of content were left out" = { one = "{name} geëxporteerd; {n} soort content is niet meegenomen", other = "{name} geëxporteerd; {n} soorten content zijn niet meegenomen" }
+"Exported {n} files" = { one = "{n} bestand geëxporteerd", other = "{n} bestanden geëxporteerd" }
+"Export…" = "Exporteren…"
+"Expose properties to instances" = "Eigenschappen beschikbaar maken voor instances"
+"Exposure" = "Belichting"
+"Expression" = "Expressie"
+"Extend collection" = "Verzameling uitbreiden"
+"Extends \"{name}\": overridden values are marked" = "Erft van “{name}”: overschreven waarden zijn gemarkeerd"
+"Eye" = "Oog"
+"F" = "F"
+"Fade" = "Fade"
+"False" = "Onwaar"
+"Feb" = "feb."
+"Fetching from the server…" = "Bezig met ophalen van de server…"
+"FigCraft couldn't open its window: {error}" = "FigCraft kon zijn venster niet openen: {error}"
+"FigCraft doesn't support every feature of these files yet. The notes list what was left out or changed in the imported copy; the original file is unchanged." = "FigCraft ondersteunt nog niet elke functie van deze bestanden. De notities vermelden wat er in de geïmporteerde kopie is weggelaten of gewijzigd; het originele bestand is ongewijzigd."
+"File" = "Bestand"
+"File name" = "Bestandsnaam"
+"File not found" = "Bestand niet gevonden"
+"File published" = "Bestand gepubliceerd"
+"Files aren't end-to-end encrypted: the server's operator can read them." = "Bestanden zijn niet end-to-end versleuteld: de beheerder van de server kan ze lezen."
+"Files nobody opens for {n} days are deleted." = { one = "Na {n} dag zonder openen wordt een bestand verwijderd.", other = "Na {n} dagen zonder openen wordt een bestand verwijderd." }
+"Fill" = "Vulling"
+"Fill (fr)" = "Vullen (fr)"
+"Fill container" = "Container vullen"
+"Fill window" = "Venster vullen"
+"Fills" = "Vullingen"
+"Fill|sizing" = "Vullen"
+"Filter and sort" = "Filteren en sorteren"
+"Find" = "Zoeken"
+"Find and replace" = "Zoeken en vervangen"
+"Find layers" = "Lagen zoeken"
+"First" = "Eerste"
+"First commit" = "Eerste commit"
+"First on top" = "Eerste bovenaan"
+"Fit" = "Inpassen"
+"Fit device to window" = "Apparaat inpassen in het venster"
+"Fit to contents" = "Aanpassen aan inhoud"
+"Fit to window" = "Inpassen in venster"
+"Fit width" = "Breedte inpassen"
+"Fixed" = "Vast"
+"Fixed gap" = "Vaste afstand"
+"Fixed size" = "Vaste grootte"
+"Flatten" = "Samenvoegen tot vector"
+"Flip" = "Spiegelen"
+"Flip horizontal" = "Horizontaal spiegelen"
+"Flip text to the other side" = "Tekst naar de andere kant spiegelen"
+"Flip vertical" = "Verticaal spiegelen"
+"Flip width profile" = "Breedteprofiel spiegelen"
+"Flow starting point" = "Flow-startpunt"
+"Flow starting points" = "Flow-startpunten"
+"Flows" = "Flows"
+"Focus view" = "Focusweergave"
+"Fold autosaves" = "Automatisch opgeslagen versies inklappen"
+"Folder: click to collapse" = "Map: klik om samen te vouwen"
+"Folder: click to expand" = "Map: klik om uit te klappen"
+"Follow" = "Volgen"
+"Follow {name}" = "{name} volgen"
+"Following" = "Volgend"
+"Following {name} · {key} to stop" = "Volgt {name} · {key} om te stoppen"
+"Font" = "Lettertype"
+"Font not installed" = "Lettertype niet geïnstalleerd"
+"Font size" = "Lettertypegrootte"
+"Font style" = "Lettertypestijl"
+"Forget on this computer" = "Vergeten op deze computer"
+"Four screens of a trail app with components and a prototype flow" = "Vier schermen van een wandelroute-app met componenten en een prototype-flow"
+"Fractions" = "Breuken"
+"Frame" = "Frame"
+"Frame selection" = "Selectie in frame plaatsen"
+"Frame tools" = "Frame-hulpmiddelen"
+"Frames" = "Frames"
+"From the library \"{name}\": read-only" = "Uit de bibliotheek \"{name}\": alleen-lezen"
+"From {name}" = "Van {name}"
+"From {server}" = "Van {server}"
+"Frost" = "Frost"
+"Gap" = "Afstand"
+"Gap between columns" = "Afstand tussen kolommen"
+"Gap between items" = "Afstand tussen items"
+"Gap between rows" = "Afstand tussen rijen"
+"Getting started" = "Aan de slag"
+"Give the address of a server open to the public, or a server's address with its key (`figcraft-server key` prints it)." = "Geef het adres van een server die openbaar bereikbaar is, of het adres van een server met bijbehorende key (`figcraft-server key` toont die)."
+"Glass" = "Glass"
+"Go to main component" = "Naar hoofdcomponent gaan"
+"Go to {name}" = "Ga naar {name}"
+"Grab bag" = "Grab bag"
+"Gradient" = "Verloop"
+"Gray" = "Grijs"
+"Green" = "Groen"
+"Greyscale components and two example screens to sketch a flow with" = "Grijswaardencomponenten en twee voorbeeldschermen om een flow mee te schetsen"
+"Grid" = "Raster"
+"Grid ({size})" = "Raster ({size})"
+"Grid styles" = "Rasterstijlen"
+"Grid {size}" = "Raster {size}"
+"Group" = "Groep"
+"Group selection" = "Selectie groeperen"
+"Groups" = "Groepen"
+"Gutter" = "Tussenruimte"
+"Hand tool" = "Handgereedschap"
+"Hanging list" = "Lijst met hangende inspringing"
+"Hanging punctuation" = "Uithangende leestekens"
+"Hard light" = "Hard light"
+"Heart" = "Hart"
+"Height" = "Hoogte"
+"Help" = "Help"
+"Help and resources" = "Help en bronnen"
+"Help page" = "Helppagina"
+"Here: {names}" = "Hier: {names}"
+"Hidden" = "Verborgen"
+"Hide contents" = "Inhoud verbergen"
+"Hide from publishing" = "Verbergen bij publiceren"
+"Hide section contents" = "Sectie-inhoud verbergen"
+"Hide these tips (Getting started in the Help menu shows them again)" = "Deze tips verbergen (Aan de slag in het menu Help toont ze opnieuw)"
+"Hide when publishing" = "Verbergen bij publiceren"
+"Highlight layers on hover" = "Lagen uitlichten bij aanwijzen"
+"Highlighter" = "Markeerstift"
+"Highlights" = "Hooglichten"
+"Hold Alt" = "Houd Alt ingedrukt"
+"Hold Alt+Z" = "Houd Alt+Z ingedrukt"
+"Hold Ctrl" = "Ctrl ingedrukt houden"
+"Hold Z" = "Houd Z ingedrukt"
+"Hold ⌃ or ⌘" = "Houd ⌃ of ⌘ ingedrukt"
+"Hold ⌥" = "Houd ⌥ ingedrukt"
+"Hold ⌥Z" = "Houd ⌥Z ingedrukt"
+"Home" = "Home"
+"Horizontal" = "Horizontaal"
+"Horizontal align" = "Horizontaal uitlijnen"
+"Horizontal hex" = "Horizontaal hex"
+"Horizontal padding" = "Horizontale padding"
+"Horizontal spacing" = "Horizontale afstand"
+"Hosted by {operator}" = "Gehost door {operator}"
+"Hover a layer to see its properties" = "Houd de muis boven een laag om de eigenschappen te zien"
+"Hover other layers to measure the distance" = "Beweeg over andere lagen om de afstand te meten"
+"Hue" = "Hue"
+"Hug" = "Hug"
+"Hug contents" = "Aangepast aan inhoud"
+"Icon components on a 24 px grid with keylines and a size preview" = "Iconcomponents op een raster van 24 px met keylines en een voorvertoning van de grootte"
+"Icon set starter" = "Iconenset-starter"
+"If" = "Als"
+"If it keeps happening, please report it at {link} with this message." = "Als dit blijft gebeuren, meld het dan op {link} met dit bericht."
+"If {condition}" = "Als {condition}"
+"Ignore auto layout (absolute position)" = "Auto layout negeren (absolute positie)"
+"Image" = "Afbeelding"
+"Images" = "Afbeeldingen"
+"Import" = "Importeren"
+"Import path" = "Importpad"
+"Import plugin from manifest" = "Plugin importeren vanuit een manifest"
+"Import plugin from manifest…" = "Plugin importeren vanuit manifest…"
+"Import report" = "Importrapport"
+"Import variables" = "Variabelen importeren"
+"Imported document" = "Geïmporteerd document"
+"Imported {name}" = "{name} geïmporteerd"
+"Imported {n} new variables, updated {updated}" = { one = "{n} nieuwe variabele geïmporteerd, {updated} bijgewerkt", other = "{n} nieuwe variabelen geïmporteerd, {updated} bijgewerkt" }
+"Import…" = "Importeren…"
+"In an instance, this comes from the main component" = "In een instance komt dit uit de hoofdcomponent"
+"In the browser you can join sessions the desktop app hosts and files on a FigCraft server. A page opened over https reaches other computers only through wss:// links (a server behind TLS)." = "In de browser kun je deelnemen aan sessies die de desktop-app host en aan bestanden die op een FigCraft-server staan. Een pagina die via https is geopend, bereikt andere computers alleen via wss://-links (een server achter TLS)."
+"Include bounding box" = "Bounding box meenemen"
+"Include id attribute" = "id-attribuut opnemen"
+"Included" = "Inbegrepen"
+"Included in layout" = "Inbegrepen in de layout"
+"Individual corners" = "Individuele hoeken"
+"Individual strokes" = "Afzonderlijke lijnen"
+"Ink" = "Ink"
+"Inner shadow" = "Binnenschaduw"
+"Inside" = "Binnen"
+"Inspect" = "Inspecteren"
+"Inspect the layer under the pointer: size, colours, typography" = "Inspecteer de laag onder de muisaanwijzer: grootte, kleuren, typografie"
+"Install" = "Installeren"
+"Install plugin" = "Plugin installeren"
+"Installed" = "Geïnstalleerd"
+"Installed {name}" = "{name} geïnstalleerd"
+"Installing…" = "Installeren…"
+"Instance" = "Instance"
+"Instance properties" = "Instance-eigenschappen"
+"Instance swap" = "Instance verwisselen"
+"Instance swap (no other component)" = "Instance verwisselen (geen andere component)"
+"Instances" = "Instances"
+"Instant" = "Direct"
+"Intensity" = "Intensiteit"
+"Interaction" = "Interactie"
+"Interactions" = "Interacties"
+"Interface design and prototyping. A free, open-source, clean-room design tool written from scratch in Rust, part of the ArtCraft Crafting Apps." = "Interface-ontwerp en prototyping. Een gratis, open-source, clean-room ontwerptool, helemaal van nul geschreven in Rust, onderdeel van de ArtCraft Crafting Apps."
+"Intersect" = "Intersect"
+"Intersects" = "Overlapt"
+"Invalid color" = "Ongeldige kleur"
+"Invite link" = "Uitnodigingslink"
+"Invite link copied" = "Uitnodigingslink gekopieerd"
+"It asks permission to:" = "Het vraagt toestemming om:"
+"Jan" = "jan."
+"Join" = "Deelnemen"
+"Join code copied" = "Toegangscode gekopieerd"
+"Join code or invite link" = "Deelnamecode of uitnodigingslink"
+"Join live session" = "Deelnemen aan live-sessie"
+"Join us on Discord" = "Chat met ons op Discord"
+"Join with a code" = "Deelnemen met een code"
+"Joined" = "Erbij gekomen"
+"Joined {file}" = "Deelgenomen aan {file}"
+"Joining…" = "Bezig met deelnemen…"
+"Join|stroke" = "Hoek"
+"Jul" = "jul."
+"Jun" = "jun."
+"Just now" = "Zojuist"
+"Justify" = "Uitvullen"
+"Keep appearance" = "Uiterlijk behouden"
+"Keep appearance converts every color value to {profile} so colors look the same. Keep values leaves the numbers as they are, so colors shift." = "Kleur behouden converteert elke kleurwaarde naar {profile}, zodat kleuren er hetzelfde uitzien. Waarden behouden laat de getallen staan, waardoor kleuren verschuiven."
+"Keep tool selected after use" = "Tool na gebruik geselecteerd houden"
+"Keep values" = "Waarden behouden"
+"Key/Gamepad" = "Toets/Gamepad"
+"Key/Gamepad {key}" = "Toets/Gamepad {key}"
+"Keyboard shortcuts" = "Sneltoetsen"
+"Kits" = "Kits"
+"Landing page" = "Landingspagina"
+"Language" = "Taal"
+"Lasso" = "Lasso"
+"Last" = "Laatst"
+"Last change: {note}" = "Laatste wijziging: {note}"
+"Last commit" = "Laatste commit"
+"Last modified" = "Laatst gewijzigd"
+"Last on top" = "Laatste bovenaan"
+"Layer blur" = "Laagvervaging"
+"Layer name" = "Laagnaam"
+"Layers" = "Lagen"
+"Layers in an instance take their position from the main component" = "Lagen in een instance nemen hun positie over van de hoofdcomponent"
+"Layout" = "Layout"
+"Layout grid" = "Layoutraster"
+"Layout grid settings" = "Instellingen voor layoutraster"
+"Layout grids" = "Layout-rasters"
+"Leave session" = "Sessie verlaten"
+"Leaves" = "Leaves"
+"Left" = "Links"
+"Left & right" = "Links en rechts"
+"Left side" = "Linkerkant"
+"Left side width" = "Breedte linkerkant"
+"Letter case" = "Letterkast"
+"Letter spacing" = "Letterafstand"
+"Libraries" = "Bibliotheken"
+"Libraries in this file" = "Bibliotheken in dit bestand"
+"Library updates available" = "Bibliotheekupdates beschikbaar"
+"Library: click to collapse" = "Bibliotheek: klik om samen te vouwen"
+"Library: click to expand" = "Bibliotheek: klik om uit te klappen"
+"Library: its variables are read-only here; edit them in the library file and publish it" = "Bibliotheek: de variabelen zijn hier alleen-lezen; bewerk ze in het bibliotheekbestand en publiceer dat"
+"Light" = "Licht"
+"Lighten" = "Lighten"
+"Light|glass" = "Light"
+"Line" = "Lijn"
+"Line arrow" = "Lijnpijl"
+"Line delta" = "Regeldelta"
+"Line height" = "Regelafstand"
+"Linear" = "Lineair"
+"Lines" = "Lijnen"
+"Lines +/−" = "Regels +/−"
+"Lines added" = "Toegevoegde regels"
+"Lines deleted" = "Regels verwijderd"
+"Link" = "Koppeling"
+"Link copied" = "Link gekopieerd"
+"Link docs, code or tickets for developers." = "Koppel documentatie, code of tickets voor ontwikkelaars."
+"Link frames on the Prototype tab, then present the flow" = "Koppel frames op het Prototype-tabblad en presenteer daarna de flow"
+"Link this component to its code component: instances then show your real snippet with their values." = "Koppel deze component aan zijn codecomponent: instances laten dan je echte snippet zien met hun waarden."
+"List spacing" = "Lijstafstand"
+"List style" = "Lijststijl"
+"Live session" = "Live sessie"
+"Live · {people}" = "Live · {people}"
+"Local components" = "Lokale componenten"
+"Local network" = "Lokaal netwerk"
+"Local styles" = "Lokale stijlen"
+"Local variables" = "Lokale variabelen"
+"Lock/Unlock" = "Vergrendelen/ontgrendelen"
+"Locked" = "Vergrendeld"
+"Lowercase" = "Kleine letters"
+"Luminance" = "Luminantie"
+"Luminosity" = "Luminosity"
+"Main" = "Main"
+"Main component deleted" = "Hoofdcomponent verwijderd"
+"Main menu" = "Hoofdmenu"
+"Make a component" = "Maak een component"
+"Make slot" = "Slot maken"
+"Mar" = "mrt."
+"Margin" = "Marge"
+"Mark all as read" = "Markeer alles als gelezen"
+"Mark as resolved" = "Markeren als opgelost"
+"Mark as unread" = "Markeren als ongelezen"
+"Mark as unresolved" = "Markeren als onopgelost"
+"Marker" = "Stift"
+"Mask" = "Masker"
+"Mass · Stiffness · Damping" = "Massa · Stijfheid · Demping"
+"Match (empty: the whole name)" = "Overeenkomst (leeg: de hele naam)"
+"Max H" = "Max H"
+"Max W" = "Max B"
+"Max lines" = "Max. regels"
+"Maximize" = "Maximaliseren"
+"May" = "mei"
+"Measure to the selection" = "Meten tot de selectie"
+"Merge into main" = "Samenvoegen in main"
+"Merge regions" = "Gebieden samenvoegen"
+"Merge the branch into the main file (one undo step) and archive it" = "Voeg de branch samen met het hoofdbestand (één keer ongedaan maken) en archiveer hem"
+"Merged" = "Samengevoegd"
+"Merged PRs" = "Samengevoegde PRs"
+"Min H" = "Min H"
+"Min W" = "Min. B"
+"Minimize" = "Minimaliseren"
+"Mirror angle" = "Hoek spiegelen"
+"Mirror angle and length" = "Spiegel hoek en lengte"
+"Mirroring" = "Spiegeling"
+"Missing" = "Ontbreekt"
+"Missing fonts" = "Ontbrekende lettertypen"
+"Missing layer" = "Ontbrekende laag"
+"Missing style" = "Ontbrekende stijl"
+"Missing variable" = "Ontbrekende variabele"
+"Miter" = "Punt"
+"Miter angle" = "Verstekhoek"
+"Mixed" = "Gemengd"
+"Mixed fonts" = "Gemengde lettertypen"
+"Mixed interactions: click + to replace them" = "Gemengde interacties: klik op + om ze te vervangen"
+"Mobile app" = "Mobiele app"
+"Mode" = "Modus"
+"Model" = "Model"
+"Models" = "Modellen"
+"Mono" = "Mono"
+"More" = "Meer"
+"More instance actions" = "Meer instance-acties"
+"Mouse down" = "Muisknop ingedrukt"
+"Mouse enter" = "Muis erover"
+"Mouse leave" = "Muis verlaat"
+"Mouse up" = "Muis loslaten"
+"Move" = "Verplaatsen"
+"Move along the toolbar or the layer rows" = "Beweeg langs de werkbalk of de rijen met lagen"
+"Move column left" = "Kolom naar links verplaatsen"
+"Move column right" = "Kolom naar rechts verplaatsen"
+"Move down" = "Omlaag verplaatsen"
+"Move in" = "Naar binnen bewegen"
+"Move out" = "Naar buiten verplaatsen"
+"Move tools" = "Verplaatsgereedschap"
+"Move up" = "Omhoog verplaatsen"
+"Moved to {name}" = "Verplaatst naar {name}"
+"Multi" = "Multi"
+"Multiply" = "Multiply"
+"Muted" = "Muted"
+"Name" = "Naam"
+"Name (A–Z)" = "Naam (A–Z)"
+"Named instance" = "Benoemde instance"
+"Navigate to" = "Ga naar"
+"Nested instance" = "Geneste instance"
+"New board" = "Nieuw whiteboard"
+"New design file" = "Nieuw ontwerpbestand"
+"Newest first" = "Nieuwste eerst"
+"Next frame" = "Volgend frame"
+"Next or previous control in the focused region" = "Volgende of vorige bedieningselement in het gebied met focus"
+"Next ready for dev" = "Volgende klaar voor dev"
+"Next size option" = "Volgende grootteoptie"
+"No assets: no export settings, icons or images. Add export settings in the Design tab." = "Geen assets: geen exportinstellingen, pictogrammen of afbeeldingen. Voeg exportinstellingen toe op het Design-tabblad."
+"No boolean variables fit here." = "Er passen hier geen booleaanse variabelen."
+"No boolean variables yet. Create them in Local variables." = "Nog geen booleaanse variabelen. Maak ze in Lokale variabelen."
+"No branches. A branch is a copy of the file to try changes in, then review and merge." = "Geen branches. Een branch is een kopie van het bestand om wijzigingen in uit te proberen, daarna te beoordelen en samen te voegen."
+"No category" = "Geen categorie"
+"No changes" = "Geen wijzigingen"
+"No color styles" = "Geen kleurstijlen"
+"No colour variables fit here." = "Hier passen geen kleurvariabelen."
+"No colour variables yet. Create them in Local variables." = "Nog geen kleurvariabelen. Maak ze in Lokale variabelen."
+"No comments yet" = "Nog geen reacties"
+"No compatibility warnings reported" = "Geen compatibiliteitswaarschuwingen gerapporteerd"
+"No components yet. Select layers and press {keys}." = "Nog geen components. Selecteer lagen en druk op {keys}."
+"No conflicts." = "Geen conflicten."
+"No contributor data was built into this copy." = "In deze kopie zijn geen bijdragersgegevens ingebouwd."
+"No device" = "Geen apparaat"
+"No files or templates match your search" = "Geen bestanden of sjablonen komen overeen met je zoekopdracht"
+"No fonts match" = "Geen lettertypen gevonden"
+"No join code here (the server is older than join codes, or this address can't be put in one): share the link instead." = "Hier is geen toegangscode (de server is ouder dan toegangscodes, of dit adres past niet in een code): deel in plaats daarvan de link."
+"No layer changes to show." = "Geen lagenwijzigingen om te tonen."
+"No libraries yet. Add a .figcraft file that was published as a library, or paste a team library's link." = "Nog geen bibliotheken. Voeg een .figcraft-bestand toe dat als bibliotheek is gepubliceerd, of plak de link van een teambibliotheek."
+"No list" = "Geen lijst"
+"No matching comments" = "Geen overeenkomende reacties"
+"No matching components" = "Geen overeenkomende components"
+"No matching layers" = "Geen bijpassende lagen"
+"No matching styles" = "Geen bijpassende stijlen"
+"No matching variables" = "Geen passende variabelen"
+"No mirroring" = "Geen spiegeling"
+"No model credits were built into this copy." = "Er zijn geen modelcredits in deze kopie ingebouwd."
+"No number variables fit here." = "Hier passen geen getalvariabelen."
+"No number variables yet. Create them in Local variables." = "Nog geen getalvariabelen. Maak ze in Lokale variabelen."
+"No other pages" = "Geen andere pagina's"
+"No paints" = "Geen vullingen"
+"No plugins on {server}." = "Geen plugins op {server}."
+"No plugins yet. Import a development plugin from its figcraft-plugin.json." = "Nog geen plugins. Importeer een development-plugin via zijn figcraft-plugin.json."
+"No preferred components" = "Geen voorkeurscomponenten"
+"No preset" = "Geen preset"
+"No saved versions yet. Save a version to mark a point in your work you can come back to." = "Nog geen opgeslagen versies. Sla een versie op om een moment in je werk vast te leggen waar je later naartoe kunt terugkeren."
+"No scrolling" = "Geen scrollen"
+"No shortcuts match" = "Er komen geen sneltoetsen overeen"
+"No status" = "Geen status"
+"No string variables fit here." = "Er passen hier geen string-variabelen."
+"No string variables yet. Create them in Local variables." = "Nog geen tekenreeksvariabelen. Maak ze aan in Lokale variabelen."
+"No styles yet." = "Nog geen stijlen."
+"No styles yet. Click + to create one from the selection." = "Nog geen stijlen. Klik op + om er een te maken vanuit de selectie."
+"No templates match your search" = "Geen sjablonen gevonden voor je zoekopdracht"
+"No text styles yet. Click + to create one from the selected text." = "Nog geen tekststijlen. Klik op + om er een te maken vanuit de geselecteerde tekst."
+"No variables fit here." = "Er passen hier geen variabelen."
+"No variables yet. Create them in Local variables." = "Nog geen variabelen. Maak ze in Lokale variabelen."
+"Nobody else is here yet" = "Er is nog niemand anders hier"
+"Noise" = "Ruis"
+"None" = "Geen"
+"None." = "Geen."
+"Normal" = "Normal"
+"Not bound" = "Niet gekoppeld"
+"Not in a live session" = "Niet in een live sessie"
+"Not in this font" = "Niet in dit lettertype"
+"Not properties, kept as written: {names}" = "Geen eigenschappen, ongewijzigd overgenomen: {names}"
+"Not read yet" = "Nog niet gelezen"
+"Not shared" = "Niet gedeeld"
+"Note {n}" = "Notitie {n}"
+"Nothing changed since this was marked ready for dev." = "Er is niets gewijzigd sinds dit was gemarkeerd als ready for dev."
+"Nothing here yet. Set a frame's status to list it." = "Nog niets hier. Stel de status van een frame in om het hier te tonen."
+"Nothing online yet. Use Share on a file to put it online and it is listed here." = "Er staat nog niets online. Gebruik Delen bij een bestand om het online te zetten, dan wordt het hier vermeld."
+"Nothing to export" = "Niets te exporteren"
+"Nov" = "nov."
+"Now" = "Nu"
+"Nudge (Shift: big nudge)" = "Verschuiven (Shift: grote stap)"
+"Nudge amount" = "Stapafstand"
+"Number" = "Getal"
+"Number ↑" = "Getal ↑"
+"Number ↓" = "Nummer ↓"
+"Numbered list" = "Genummerde lijst"
+"Object" = "Object"
+"Oct" = "okt."
+"Off" = "Uit"
+"Offered first when filling the slot (any content is allowed)" = "Wordt het eerst aangeboden bij het vullen van de slot (elke inhoud is toegestaan)"
+"Offered first when swapping the instance (any component is allowed)" = "Wordt als eerste aangeboden bij het verwisselen van de instance (elk component is toegestaan)"
+"Offset" = "Verschuiving"
+"Oldest first" = "Oudste eerst"
+"On click" = "Bij klik"
+"On drag" = "Bij slepen"
+"On this page" = "Op deze pagina"
+"One announcement in five common sizes: square, portrait, story, link and banner" = "Eén aankondiging in vijf gangbare formaten: vierkant, staand, story, link en banner"
+"Online" = "Online"
+"Online files" = "Online bestanden"
+"Online sharing is off: files are shared on the local network only." = "Online delen staat uit: bestanden worden alleen op het lokale netwerk gedeeld."
+"Only the first changed layers are listed." = "Alleen de eerste gewijzigde lagen worden weergegeven."
+"Only the first {n} changed layers are listed." = "Er worden alleen de eerste {n} gewijzigde lagen weergegeven."
+"Only your threads" = "Alleen jouw gesprekken"
+"Opacity" = "Dekking"
+"Opacity & blend" = "Dekking & blend"
+"Opacity 10%…90%, 0: 100%" = "Dekking 10%…90%, 0: 100%"
+"Open" = "Openen"
+"Open .figcraft, .svg or images" = "Open .figcraft, .svg of afbeeldingen"
+"Open branch" = "Branch openen"
+"Open file" = "Bestand openen"
+"Open files" = "Geopende bestanden"
+"Open presentations" = "Geopende presentaties"
+"Open in focus view" = "Openen in focusweergave"
+"Open in new window" = "Openen in een nieuw venster"
+"Open invite links in FigCraft" = "Uitnodigingslinks openen in FigCraft"
+"Open link" = "Link openen"
+"Open link {url}" = "Link {url} openen"
+"Open overlay" = "Overlay openen"
+"Open prototype preview" = "Voorvertoning van prototype openen"
+"Open variables ({count})" = "Variabelen openen ({count})"
+"Opened as a new document" = "Geopend als nieuw document"
+"Opened “{name}” in a new tab" = "“{name}” geopend in een nieuw tabblad"
+"Opening the file…" = "Bestand openen…"
+"Opening {n} files as new files" = { one = "Openen als nieuw bestand", other = "{n} bestanden openen als nieuwe bestanden" }
+"Open|comments" = "Open"
+"Options" = "Opties"
+"Orange" = "Oranje"
+"Order" = "Volgorde"
+"Other" = "Overige"
+"Other apps may not open every .fig file exported here." = "Het kan zijn dat andere apps niet elk .fig-bestand openen dat hier wordt geëxporteerd."
+"Others lose access and keep their copy; the file stays on the server for you" = "Anderen verliezen de toegang en behouden hun kopie; het bestand blijft voor jou op de server"
+"Others type this under Share ▸ Join with a code" = "Anderen typen dit onder Delen ▸ Deelnemen met een code"
+"Outline stroke" = "Lijn omzetten naar contour"
+"Outline text" = "Tekst omzetten in outlines"
+"Outlines" = "Contouren"
+"Outside" = "Buiten"
+"Overflow" = "Overloop"
+"Overlay" = "Overlay"
+"Overlay position" = "Overlaypositie"
+"Overridden here (the collection it extends has another value)" = "Hier overschreven (de verzameling die het uitbreidt heeft een andere waarde)"
+"Overrides" = "Overschrijvingen"
+"Owner token" = "Eigenaartoken"
+"Owner token copied" = "Eigenaartoken gekopieerd"
+"PDF print options" = "PDF-afdrukopties"
+"PDF print settings" = "PDF-afdrukinstellingen"
+"Padding" = "Padding"
+"Page" = "Pagina"
+"Page deleted" = "Pagina verwijderd"
+"Pages" = "Pagina's"
+"Pages added to the document" = "Pagina's toegevoegd aan het document"
+"Pages: {pages}" = "Pagina's: {pages}"
+"Paint bucket" = "Vulemmertje"
+"Pan the canvas" = "Verschuif het canvas"
+"Pan with nothing selected (Shift: farther)" = "Verschuiven zonder selectie (Shift: verder)"
+"Panels" = "Panelen"
+"Paper" = "Paper"
+"Paragraph indent" = "Alinea-inspringen"
+"Paragraph indent applies to left-aligned text" = "Alineainspringing geldt voor links uitgelijnde tekst"
+"Paragraph spacing" = "Alinea-afstand"
+"Pass through" = "Pass through"
+"Paste a link (https://…)" = "Plak een link (https://…)"
+"Paste a team library link (a view link)" = "Plak een link naar een teambibliotheek (een weergavelink)"
+"Paste here" = "Hier plakken"
+"Paste to replace" = "Plakken om te vervangen"
+"Pasted design layers; {n} kinds of content were left out" = { one = "Ontwerplagen geplakt; {n} soort inhoud is weggelaten", other = "Ontwerplagen geplakt; {n} soorten inhoud zijn weggelaten" }
+"Pattern" = "Patroon"
+"Pattern alignment" = "Patroonuitlijning"
+"Pattern scale" = "Patroonschaal"
+"Pattern source" = "Patroonbron"
+"Pen" = "Pen"
+"Pencil" = "Potlood"
+"People in this file" = "Personen in dit bestand"
+"People join from anywhere with a code. The file is kept on {server} while you share it." = "Mensen kunnen met een code van overal deelnemen. Het bestand blijft op {server} staan zolang je het deelt."
+"People on your network join with a code. Nothing goes through a server." = "Mensen op je netwerk nemen deel met een code. Er gaat niets via een server."
+"Phone" = "Telefoon"
+"Pick color" = "Kleur opnemen"
+"Pick color (I)" = "Kleur kiezen (I)"
+"Pick one font family first" = "Kies eerst één lettertypefamilie"
+"Pick the Frame tool, then drag on the canvas or choose a device size" = "Kies de Frame-tool en sleep daarna op het canvas of kies een apparaatgrootte"
+"Pin a property" = "Eigenschap vastspelden"
+"Pinch" = "Pinch"
+"Pink" = "Roze"
+"Pixel grid" = "Pixelraster"
+"Pixel preview 1x" = "Pixelvoorvertoning 1x"
+"Pixel preview 2x" = "Pixelvoorvertoning 2x"
+"Place a shape or frame (its tool chosen)" = "Plaats een vorm of frame (het bijbehorende gereedschap is gekozen)"
+"Place automatically" = "Automatisch plaatsen"
+"Place image" = "Afbeelding plaatsen"
+"Placed on the current page" = "Geplaatst op de huidige pagina"
+"Playground" = "Playground"
+"Plugin" = "Plugin"
+"Plugins" = "Plugins"
+"Plugins & widgets" = "Plugins & widgets"
+"Plugins run in FigCraft's sandbox, without files, network or clock. Install only plugins you trust." = "Plugins draaien in de sandbox van FigCraft, zonder bestanden, netwerk of klok. Installeer alleen plugins die je vertrouwt."
+"Plus darker" = "Plus darker"
+"Plus lighter" = "Plus lighter"
+"Plus one" = "Plus één"
+"Point" = "Punt"
+"Points" = "Punten"
+"Polygon" = "Veelhoek"
+"Polygons" = "Veelhoeken"
+"Port" = "Poort"
+"Position" = "Positie"
+"Post" = "Plaatsen"
+"Preferences" = "Voorkeuren"
+"Preferred" = "Voorkeur"
+"Present" = "Presenteren"
+"Present or preview" = "Presenteren of voorvertonen"
+"Present this flow" = "Deze flow presenteren"
+"Presentation" = "Presentatie"
+"Presentation slides" = "Presentatiedia's"
+"Presenting: comments" = "Presenteren: reacties"
+"Presenting: cycle the size options" = "Presenteren: door de grootteopties bladeren"
+"Presenting: full screen" = "Presenteren: volledig scherm"
+"Presenting: next frame" = "Presenteren: volgende frame"
+"Presenting: previous frame" = "Presenteren: vorig frame"
+"Presenting: restart" = "Presenteren: opnieuw starten"
+"Preserve scroll position" = "Scrollpositie behouden"
+"Presets" = "Presets"
+"Press a key…" = "Druk op een toets…"
+"Preview" = "Voorvertoning"
+"Preview this flow" = "Voorvertoning van deze flow"
+"Preview this frame" = "Dit frame voorvertonen"
+"Previous frame" = "Vorige frame"
+"Previous ready for dev" = "Vorige klaar voor developers"
+"Progressive" = "Progressive"
+"Properties" = "Eigenschappen"
+"Prototype" = "Prototype"
+"Prototype preview" = "Prototypevoorvertoning"
+"Prototype settings" = "Prototype-instellingen"
+"Publish" = "Publiceren"
+"Publish changes" = "Wijzigingen publiceren"
+"Publish to another server…" = "Publiceren op een andere server…"
+"Publish to server" = "Publiceren naar de server"
+"Published version {v}" = "Gepubliceerde versie {v}"
+"Published version {v} to the server" = "Versie {v} naar de server gepubliceerd"
+"Published version {v}: save the file so other files can use it" = "Gepubliceerde versie {v}: sla het bestand op zodat andere bestanden het kunnen gebruiken"
+"Published · {people}" = "Gepubliceerd · {people}"
+"Publishing to a server needs the desktop app; in the browser you can join a server's files" = "Publiceren naar een server vraagt om de desktop-app; in de browser kun je deelnemen aan de bestanden van een server"
+"Publishing with the server's key." = "Publiceren met de sleutel van de server."
+"Publishing…" = "Bezig met publiceren…"
+"Push" = "Pushen"
+"Push changes to main component" = "Wijzigingen naar hoofdcomponent doorvoeren"
+"Put text on path" = "Tekst op pad plaatsen"
+"Question" = "Vraag"
+"R" = "R"
+"Radial" = "Radiaal"
+"Radius" = "Radius"
+"Ratio" = "Verhouding"
+"Reading the library…" = "Bibliotheek wordt gelezen…"
+"Ready for dev" = "Klaar voor dev"
+"Real name" = "Echte naam"
+"Recent" = "Onlangs geopend"
+"Recent files" = "Onlangs geopende bestanden"
+"Recents" = "Onlangs geopend"
+"Recovered {n} unsaved files after the app quit unexpectedly: save them to keep them" = { one = "Na een onverwachte afsluiting van de app is één niet-opgeslagen bestand hersteld: sla het op om het te bewaren", other = "Na een onverwachte afsluiting van de app zijn {n} niet-opgeslagen bestanden hersteld: sla ze op om ze te bewaren" }
+"Rectangle" = "Rechthoek"
+"Rectangles" = "Rechthoeken"
+"Red" = "Rood"
+"Reduce motion" = "Beweging verminderen"
+"Refraction" = "Breking"
+"Regular expression" = "Reguliere expressie"
+"Remove" = "Verwijderen"
+"Remove all" = "Alles verwijderen"
+"Remove annotation" = "Annotatie verwijderen"
+"Remove auto layout" = "Auto layout verwijderen"
+"Remove dev resource" = "Dev-resource verwijderen"
+"Remove export setting" = "Exportinstelling verwijderen"
+"Remove from recents" = "Verwijderen uit onlangs geopend"
+"Remove from server" = "Van de server verwijderen"
+"Remove from server…" = "Van server verwijderen…"
+"Remove guide" = "Hulplijn verwijderen"
+"Remove interaction" = "Interactie verwijderen"
+"Remove library from this file" = "Bibliotheek uit dit bestand verwijderen"
+"Remove min and max" = "Min en max verwijderen"
+"Remove min and max height" = "Minimale en maximale hoogte verwijderen"
+"Remove min and max width" = "Minimale en maximale breedte verwijderen"
+"Remove regions" = "Gebieden verwijderen"
+"Remove slot" = "Vak verwijderen"
+"Remove starting point" = "Startpunt verwijderen"
+"Remove stop" = "Stop verwijderen"
+"Remove text from path" = "Tekst losmaken van pad"
+"Remove the else and its actions" = "De else en de bijbehorende acties verwijderen"
+"Remove this condition and its actions" = "Deze voorwaarde en de bijbehorende acties verwijderen"
+"Remove this file from the server? It can't be shared or opened from there again. Your copy stays open here." = "Dit bestand van de server verwijderen? Het kan daarna niet meer worden gedeeld of geopend vanaf de server. Jouw kopie blijft hier open."
+"Remove {name} from session" = "{name} verwijderen uit de sessie"
+"Remove {name} from {server}?" = "{name} van {server} verwijderen?"
+"Removed" = "Verwijderd"
+"Removed from the server" = "Van de server verwijderd"
+"Removed since it was marked" = "Verwijderd sinds het was gemarkeerd"
+"Rename" = "Hernoemen"
+"Rename duplicated layers" = "Gedupliceerde lagen hernoemen"
+"Rename folder" = "Map hernoemen"
+"Rename group" = "Groep hernoemen"
+"Rename layers" = "Lagen hernoemen"
+"Rename mode" = "Modus hernoemen"
+"Rename on the server" = "Hernoemen op de server"
+"Rename on the server…" = "Hernoemen op de server…"
+"Rename page" = "Pagina hernoemen"
+"Rename to" = "Hernoemen naar"
+"Replace all" = "Alles vervangen"
+"Replace mixed export settings" = "Gemengde exportinstellingen vervangen"
+"Replace with" = "Vervangen door"
+"Replace with a new interaction" = "Vervangen door een nieuwe interactie"
+"Reply" = "Antwoorden"
+"Report" = "Melden"
+"Report this file…" = "Dit bestand melden…"
+"Reset" = "Herstellen"
+"Reset adjustments" = "Aanpassingen herstellen"
+"Reset all changes" = "Alle wijzigingen terugdraaien"
+"Reset all overrides on this layer" = "Alle overschrijvingen op deze laag herstellen"
+"Reset overrides" = "Overschrijvingen terugzetten"
+"Reset slot" = "Slot terugzetten"
+"Reset this override" = "Deze overschrijving terugzetten"
+"Reset to style" = "Terugzetten naar stijl"
+"Reset to the inherited value" = "Terugzetten naar de overgeërfde waarde"
+"Resize by the nudge amount" = "Formaat wijzigen met de stapafstand"
+"Resize frames to the device's screen (or the window without a device): their constraints and auto layout respond" = "Pas het formaat van frames aan naar het scherm van het apparaat (of het venster zonder apparaat): hun constraints en auto layout reageren"
+"Resize to fit" = "Formaat aanpassen aan inhoud"
+"Resizing" = "Formaat wijzigen"
+"Resolve" = "Oplossen"
+"Resolve change" = "Wijziging oplossen"
+"Resolved" = "Opgelost"
+"Resources" = "Bronnen"
+"Responsive" = "Responsive"
+"Restart" = "Opnieuw starten"
+"Restore" = "Terugzetten"
+"Restore main component" = "Hoofdcomponent terugzetten"
+"Restore this version" = "Deze versie terugzetten"
+"Restored “{name}”" = "“{name}” teruggezet"
+"Reverse the order" = "Volgorde omdraaien"
+"Reversed triangle" = "Omgekeerde driehoek"
+"Review and merge" = "Controleren en samenvoegen"
+"Ribbon" = "Ribbon"
+"Right" = "Rechts"
+"Right side" = "Rechterkant"
+"Right side width" = "Breedte rechterkant"
+"Rotate 90°" = "90° draaien"
+"Rotate 90° right" = "90° naar rechts draaien"
+"Rotate to landscape" = "Draai naar liggend"
+"Rotate to portrait" = "Draaien naar staand"
+"Rotation" = "Rotatie"
+"Rotation jitter" = "Verspreide rotatie"
+"Round" = "Rond"
+"Rounded" = "Rounded"
+"Rounded rectangle" = "Afgeronde rechthoek"
+"Row" = "Rij"
+"Row gap" = "Rijafstand"
+"Row sizes" = "Rijgroottes"
+"Row span" = "Rijbereik"
+"Rows" = "Rijen"
+"Rows {count}" = "Rijen {count}"
+"Rulers" = "Linialen"
+"Run" = "Uitvoeren"
+"Run {label}" = "{label} uitvoeren"
+"SHA-256: {sha}…" = "SHA-256: {sha}…"
+"Same as layer" = "Zoals de laag"
+"Saturation" = "Verzadiging"
+"Save" = "Opslaan"
+"Save as" = "Opslaan als"
+"Save as preset…" = "Opslaan als preset…"
+"Save files automatically" = "Bestanden automatisch opslaan"
+"Save version  {key}" = "Versie opslaan  {key}"
+"Saved" = "Opgeslagen"
+"Saved {name}" = "{name} opgeslagen"
+"Say something" = "Zeg iets"
+"Scale" = "Schalen"
+"Scatter" = "Scatter"
+"Scoping: where pickers offer it" = "Bereik: waar keuzeschermen hem aanbieden"
+"Screen" = "Screen"
+"Scroll behavior" = "Scrollgedrag"
+"Scroll to" = "Scrollen naar"
+"Scroll to layer" = "Naar laag scrollen"
+"Scroll with parent" = "Scrollen met bovenliggend"
+"Search" = "Zoeken"
+"Search actions, layers and tools" = "Zoek naar acties, lagen en tools"
+"Search assets" = "Zoek assets"
+"Search comments" = "Zoeken in reacties"
+"Search files and templates" = "Bestanden en sjablonen zoeken"
+"Search fonts" = "Lettertypen zoeken"
+"Search layers" = "Lagen doorzoeken"
+"Search plugins" = "Zoeken naar plugins"
+"Search results" = "Zoekresultaten"
+"Search shortcuts" = "Sneltoetsen zoeken"
+"Search templates" = "Sjablonen zoeken"
+"Section" = "Sectie"
+"Section color" = "Sectiekleur"
+"Sections" = "Secties"
+"See all templates" = "Alle sjablonen bekijken"
+"Select a frame and add a starting point to present it as a flow." = "Selecteer een frame en voeg een startpunt toe om het als flow te presenteren."
+"Select a frame to preview it" = "Kies een frame voor een voorvertoning"
+"Select a layer to see its properties and code" = "Selecteer een laag om de eigenschappen en de code te zien"
+"Select all" = "Alles selecteren"
+"Select all with same" = "Alles met hetzelfde selecteren"
+"Select layer" = "Laag selecteren"
+"Select layers and they space themselves as their content changes" = "Selecteer lagen en ze passen hun afstand automatisch aan als de inhoud verandert"
+"Select layers to apply the style to" = "Selecteer lagen om de stijl op toe te passen"
+"Select layers with this color" = "Lagen met deze kleur selecteren"
+"Select overlapping shapes" = "Overlappende vormen selecteren"
+"Select points to edit their position, radius and mirroring" = "Selecteer punten om hun positie, radius en spiegeling te bewerken"
+"Select slot" = "Kies een slot"
+"Selection" = "Selectie"
+"Selection box, {w} by {h} at {x}, {y}: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "Selectiekader, {w} bij {h} op {x}, {y}: pijlen verplaatsen het, Shift+pijlen of {cmd}+pijlen wijzigen het formaat, Enter selecteert, Escape annuleert"
+"Selection box: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "Selectiekader: pijltjes verplaatsen het, Shift+pijltjes of {cmd}+pijltjes vergroten of verkleinen het, Enter selecteert, Escape annuleert"
+"Selection colors" = "Kleuren in selectie"
+"Send backward" = "Naar achteren sturen"
+"Send report" = "Rapport verzenden"
+"Send to back" = "Naar achterste brengen"
+"Sep" = "sep."
+"Server address" = "Serveradres"
+"Server address (ws://host:47900/)" = "Serveradres (ws://host:47900/)"
+"Server for online sharing" = "Server voor online delen"
+"Set as default" = "Als standaard instellen"
+"Set variable" = "Variabele instellen"
+"Set variable mode" = "Variabelemodus instellen"
+"Set variable {name}" = "Variabele {name} instellen"
+"Set {name} to {value}" = "{name} instellen op {value}"
+"Shadows" = "Schaduwen"
+"Shape" = "Vorm"
+"Shape builder" = "Shape builder"
+"Shape tools" = "Vormgereedschap"
+"Shapes" = "Vormen"
+"Share" = "Delen"
+"Share this file" = "Dit bestand delen"
+"Share with a code" = "Delen met een code"
+"Share: live session, export" = "Delen: live-sessie, exporteren"
+"Shared" = "Gedeeld"
+"Shared: copy its code from the file's menu" = "Gedeeld: kopieer de code uit het menu van het bestand"
+"Sharing a file needs the desktop app; here you can join one." = "Een bestand delen vereist de desktop-app; hier kun je aan één deelnemen."
+"Sharing on the local network (online sharing is off: no server is set in Preferences)." = "Delen op het lokale netwerk (online delen staat uit: er is geen server ingesteld in Voorkeuren)."
+"Sharing on your network · {people}" = "Delen via je netwerk · {people}"
+"Sharing online · {people}" = "Delen online · {people}"
+"Sharing stopped: the file stays on the server, open only to you" = "Delen gestopt: het bestand blijft op de server staan, alleen voor jou toegankelijk"
+"Show" = "Weergeven"
+"Show all templates" = "Alle sjablonen tonen"
+"Show as grid" = "Als raster weergeven"
+"Show as list" = "Weergeven als lijst"
+"Show autosaves" = "Automatisch opgeslagen versies tonen"
+"Show behind transparent areas" = "Weergeven achter transparante gebieden"
+"Show comments (Shift+C)" = "Reacties tonen (Shift+C)"
+"Show device frame" = "Apparaatframe weergeven"
+"Show dimensions on objects" = "Toon afmetingen op objecten"
+"Show hotspot hints" = "Hints voor hotspots tonen"
+"Show in Explorer" = "Weergeven in Verkenner"
+"Show in Finder" = "In Finder weergeven"
+"Show in folder" = "In map tonen"
+"Show only this on the canvas" = "Alleen dit op het canvas weergeven"
+"Show open" = "Openstaande tonen"
+"Show section contents" = "Sectie-inhoud weergeven"
+"Show this layer" = "Deze laag tonen"
+"Show usage" = "Gebruik weergeven"
+"Show/Hide" = "Tonen/Verbergen"
+"Show/Hide UI" = "UI tonen/verbergen"
+"Side by side" = "Naast elkaar"
+"Sidebar" = "Zijbalk"
+"Simplify stroke" = "Lijn vereenvoudigen"
+"Size" = "Grootte"
+"Size jitter" = "Groottevariatie"
+"Skip ink" = "Skip ink"
+"Slashed zero" = "Nul met schuine streep"
+"Slice" = "Slice"
+"Slices" = "Slices"
+"Slide in" = "Inschuiven"
+"Slide out" = "Uitschuiven"
+"Slot" = "Slot"
+"Slot content" = "Slotinhoud"
+"Small capitals" = "Kapitelen"
+"Small caps" = "Kleine kapitalen"
+"Smart animate" = "Smart animate"
+"Snap to pixel grid" = "Uitlijnen op pixelraster"
+"Social and slides" = "Sociale media en dia's"
+"Social media" = "Sociale media"
+"Social post sizes" = "Maten voor sociale posts"
+"Soft light" = "Soft light"
+"Solid" = "Effen"
+"Some variants have the same property values: give each one a unique combination" = "Sommige varianten hebben dezelfde eigenschapswaarden: geef elke variant een unieke combinatie"
+"Sort" = "Sorteren"
+"Sort by" = "Sorteren op"
+"Sort by date" = "Op datum sorteren"
+"Sort by page" = "Sorteren op pagina"
+"Sort by {column}" = "Sorteren op {column}"
+"Space around" = "Ruimte rondom"
+"Space between" = "Ruimte ertussen"
+"Space drag" = "Slepen met de spatiebalk"
+"Space evenly" = "Gelijkmatig verdelen"
+"Space+drag" = "Space+drag"
+"Spacing" = "Afstand"
+"Spam, stolen work, abuse…" = "Spam, gestolen werk, misbruik…"
+"Speech bubble" = "Tekstballon"
+"Splay" = "Splay"
+"Spotlight me" = "Spotlight mij"
+"Spread" = "Spread"
+"Square" = "Vierkant"
+"Stamp" = "Stempel"
+"Stamps" = "Stempels"
+"Standard" = "Standaard"
+"Standard ligatures" = "Standaardligaturen"
+"Star" = "Ster"
+"Stars" = "Stars"
+"Start" = "Start"
+"Start ascending from / stop descending at" = "Begin oplopend vanaf / stop aflopend bij"
+"Start from a blank canvas" = "Begin vanaf een leeg canvas"
+"Start from a template" = "Begin met een sjabloon"
+"Start on path" = "Begin op het pad"
+"Start on the Home screen" = "Starten op Home"
+"Start point" = "Startpunt"
+"Start sharing" = "Delen starten"
+"Start sharing with the Share button, then pass on the code it gives" = "Begin met delen via de knop Delen en geef daarna de code door die je krijgt"
+"Starting to share…" = "Bezig met delen…"
+"Status" = "Status"
+"Sticky" = "Sticky"
+"Sticky note" = "Plakbriefje"
+"Sticky note colors" = "Kleuren van plakbriefjes"
+"Sticky notes, shapes and connectors" = "Plakbriefjes, vormen en verbindingen"
+"Stop" = "Stoppen"
+"Stop following {name}" = "Stop met {name} te volgen"
+"Stop session" = "Sessie stoppen"
+"Stop sharing" = "Stoppen met delen"
+"Stop spotlighting" = "Stop met uitlichten"
+"Stop {n}  {hex}" = "Stop {n}  {hex}"
+"Straight" = "Recht"
+"Stretch" = "Uitrekken"
+"Strikethrough" = "Doorstrepen"
+"String" = "Tekenreeks"
+"Stroke" = "Lijn"
+"Stroke style" = "Lijnstijl"
+"Stroke weight" = "Lijndikte"
+"Strokes" = "Lijnen"
+"Style" = "Stijl"
+"Styles" = "Stijlen"
+"Stylistic set 1" = "Stilistische set 1"
+"Stylistic set 2" = "Stylistische set 2"
+"Stylistic set 3" = "Stylistische set 3"
+"Stylistic set 4" = "Stilistische set 4"
+"Stylistic set 5" = "Stilistische set 5"
+"Subtract" = "Subtract"
+"Subtracts" = "Trekt af"
+"Suffix" = "Achtervoegsel"
+"Suspend snapping while dragging" = "Uitlijning opschorten tijdens het slepen"
+"Swap instance" = "Instance verwisselen"
+"Swap library: use another library's assets of the same names" = "Bibliotheek verwisselen: assets met dezelfde namen uit een andere bibliotheek gebruiken"
+"Swap orientation" = "Oriëntatie verwisselen"
+"Swap overlay" = "Overlay verwisselen"
+"Swap to {name}" = "Wisselen naar {name}"
+"Swap width and height" = "Breedte en hoogte omwisselen"
+"Swapped instance" = "Verwisselde instance"
+"Swapped {n} assets" = { one = "{n} asset verwisseld", other = "{n} assets verwisseld" }
+"Swapped {n} assets; {missed} had no match and still use the old library" = { one = "{n} asset verwisseld; {missed} had geen overeenkomst en gebruikt nog de oude bibliotheek", other = "{n} assets verwisseld; {missed} hadden geen overeenkomst en gebruiken nog de oude bibliotheek" }
+"Sweep" = "Sweep"
+"System" = "Systeem"
+"Tab / Shift+Tab" = "Tab / Shift+Tab"
+"Table" = "Tabel"
+"Tablet" = "Tablet"
+"Tabular numbers" = "Tabulaire cijfers"
+"Take the values from the first selected layer" = "Waarden van de eerste geselecteerde laag overnemen"
+"Taper" = "Taper"
+"Taper both ends" = "Beide uiteinden versmallen"
+"Tell the server's operator what is wrong with it" = "Vertel de beheerder van de server wat er mis mee is"
+"Temperature" = "Temperatuur"
+"Template" = "Sjabloon"
+"Templates" = "Sjablonen"
+"Terms" = "Voorwaarden"
+"Text" = "Tekst"
+"Text align" = "Tekstuitlijning"
+"Text content" = "Tekstinhoud"
+"Text size" = "Tekstgrootte"
+"Text style" = "Tekststijl"
+"Text styles" = "Tekststijlen"
+"Texts" = "Teksten"
+"Texture" = "Texture"
+"The canvas previews colors in sRGB; exported PNG, JPG and WebP files are tagged Display P3." = "Het canvas toont de kleuren als voorvertoning in sRGB; geëxporteerde PNG-, JPG- en WebP-bestanden worden gelabeld als Display P3."
+"The destination document is unavailable. Nothing was imported." = "Het doeldocument is niet beschikbaar. Er is niets geïmporteerd."
+"The destination document was closed. Nothing was imported." = "Het doeldocument is gesloten. Er is niets geïmporteerd."
+"The destination page was removed. Nothing was imported." = "De doelpagina is verwijderd. Er is niets geïmporteerd."
+"The file is deleted from the server: nobody can open or join it from there again, and this can't be undone. Copies that are open stay with whoever has them." = "Het bestand wordt van de server verwijderd: niemand kan het daar nog openen of eraan deelnemen, en dit kan niet ongedaan worden gemaakt. Kopieën die open zijn, blijven bij wie ze heeft."
+"The file now holds another library" = "Het bestand bevat nu een andere bibliotheek"
+"The file now holds another library (\"{name}\")" = "Het bestand bevat nu een andere bibliotheek (\"{name}\")"
+"The files you shared or published online from this computer. They stay on their server until you remove them." = "De bestanden die je vanaf deze computer online hebt gedeeld of gepubliceerd. Ze blijven op hun server totdat je ze verwijdert."
+"The link carries the session's secret: share it only with people you invite." = "De link bevat het geheim van de sessie: deel hem alleen met mensen die je uitnodigt."
+"The name in your online files and on the server. The document inside keeps its own name." = "De naam in je online bestanden en op de server. Het document erin behoudt zijn eigen naam."
+"The selection uses several text styles: click to apply one" = "De selectie gebruikt meerdere tekststijlen: klik om er een toe te passen"
+"The server deletes this file if nobody opens it before {date}." = "De server verwijdert dit bestand als niemand het vóór {date} opent."
+"The whole file" = "Het hele bestand"
+"Theme" = "Thema"
+"There's no destination for that action" = "Er is geen doel voor die actie"
+"Thickness" = "Dikte"
+"This branch can't be reviewed: {e}" = "Deze branch kan niet worden beoordeeld: {e}"
+"This branch was merged or archived." = "Deze branch is samengevoegd of gearchiveerd."
+"This computer only" = "Alleen op deze computer"
+"This computer remembers the owner token, so the file can be managed from the home screen's Online list. Copy it to manage the file from somewhere else: it is a password for this file and won't be shown again." = "Deze computer onthoudt het eigenaartoken, zodat het bestand beheerd kan worden vanuit de Online-lijst op het beginscherm. Kopieer het om het bestand vanaf een andere plek te beheren: het is het wachtwoord voor dit bestand en wordt niet opnieuw weergegeven."
+"This condition is edited as an expression" = "Deze voorwaarde wordt als expressie bewerkt"
+"This file" = "Dit bestand"
+"This file has unsaved changes" = "Dit bestand heeft niet-opgeslagen wijzigingen"
+"This file is on {server}, open only to you. Share it to let others in with a new code." = "Dit bestand staat op {server}, alleen toegankelijk voor jou. Deel het om anderen binnen te laten met een nieuwe code."
+"This file uses fonts that aren't installed on this computer. Their text is drawn in a fallback font until you install them." = "Dit bestand gebruikt lettertypen die niet op deze computer zijn geïnstalleerd. Hun tekst wordt in een vervangend lettertype getoond tot je ze installeert."
+"This frame is new on the branch." = "Dit frame is nieuw op de branch."
+"This frame isn't on the branch." = "Dit frame staat niet op de branch."
+"This server is open to the public: no key needed." = "Deze server is voor iedereen toegankelijk: geen sleutel nodig."
+"This server needs its key: add ?key=… to the address (`figcraft-server key` prints it on the server's machine)." = "Deze server heeft een sleutel nodig: voeg ?key=… toe aan het adres (`figcraft-server key` toont die op de computer van de server)."
+"This server takes files only with its key: see Advanced." = "Deze server accepteert bestanden alleen met de bijbehorende sleutel: zie Geavanceerd."
+"Thumbs up" = "Duim omhoog"
+"Tidy up" = "Opruimen"
+"Tile" = "Tegelen"
+"Tile type" = "Tegeltype"
+"Tint" = "Tint"
+"Title" = "Titel"
+"Title case" = "Hoofdletter per woord"
+"To share this library with your team, publish the file to a server (Share ▸ Publish to server…), then publish the library there." = "Om deze bibliotheek met je team te delen, publiceer het bestand naar een server (Delen ▸ Publiceren naar server…), publiceer daarna de bibliotheek."
+"Toggle" = "Omschakelen"
+"Toggle light/dark theme" = "Wisselen tussen licht/donker thema"
+"Toggle visibility" = "Zichtbaarheid omschakelen"
+"Tools" = "Gereedschappen"
+"Top" = "Boven"
+"Top & bottom" = "Boven & onder"
+"Top left radius" = "Radius linksboven"
+"Top right radius" = "Hoekradius rechtsboven"
+"Transform" = "Transformeren"
+"Triangle" = "Driehoek"
+"Triangle arrow" = "Driehoekspijl"
+"Trigger" = "Trigger"
+"True" = "Waar"
+"Truncate text" = "Tekst afkappen"
+"Truncate with an ellipsis" = "Afkappen met een beletselteken"
+"Try again" = "Probeer het opnieuw"
+"Try another search or filter." = "Probeer een andere zoekopdracht of filter."
+"Try another search, or browse templates." = "Probeer een andere zoekopdracht of bekijk de sjablonen."
+"Try another word, or look at every kind." = "Probeer een ander woord, of bekijk alle soorten."
+"Turn a layer into a component, reuse it, and change every copy at once" = "Maak van een laag een component, hergebruik die en verander alle kopieën tegelijk"
+"Two digits" = "Twee cijfers"
+"Type" = "Type"
+"Type settings" = "Tekstinstellingen"
+"Type the join code you were given, or paste an invite link." = "Typ de toegangscode die je hebt gekregen, of plak een uitnodigingslink."
+"Typography" = "Typografie"
+"Underline" = "Onderstrepen"
+"Undo takes back only your own changes; what others changed since stays." = "Ongedaan maken zet alleen je eigen wijzigingen terug; wat anderen sindsdien hebben gewijzigd, blijft staan."
+"Ungroup" = "Groep opheffen"
+"Uniform" = "Gelijkmatig"
+"Union" = "Union"
+"Unions" = "Unies"
+"Unknown — treated as sRGB" = "Onbekend — behandeld als sRGB"
+"Unread" = "Ongelezen"
+"Unresolve" = "Oplossing ongedaan maken"
+"Unsaved changes" = "Niet-opgeslagen wijzigingen"
+"Unsaved changes in {names}. Save them before closing?" = "Niet-opgeslagen wijzigingen in {names}. Opslaan voor het sluiten?"
+"Unsaved changes: save first ({save}), or close the tab with {alt}-click to discard" = "Niet-opgeslagen wijzigingen: sla eerst op ({save}), of sluit het tabblad met {alt}-klik om ze te verwerpen"
+"Unsaved changes: save first, or close again with {key} to discard" = "Niet-opgeslagen wijzigingen: sla eerst op, of sluit nogmaals met {key} om te verwerpen"
+"Up" = "Omhoog"
+"Update" = "Bijwerken"
+"Update from main" = "Bijwerken vanaf main"
+"Update from selection" = "Bijwerken vanuit de selectie"
+"Update plugin" = "Plugin bijwerken"
+"Updated {components} and {styles}" = "{components} en {styles} bijgewerkt"
+"Updated {name}" = "{name} bijgewerkt"
+"Updating the graphics driver often helps. To use OpenGL only, start FigCraft from a Command Prompt with:" = "Het bijwerken van de grafische driver helpt vaak. Om alleen OpenGL te gebruiken, start je FigCraft vanaf de Opdrachtprompt met:"
+"Updating the graphics driver often helps. WGPU_BACKEND (vulkan, gl, metal) names another graphics API to try." = "Het bijwerken van de grafische driver helpt vaak. WGPU_BACKEND (vulkan, gl, metal) noemt een andere grafische API om te proberen."
+"Uploads this file to a FigCraft server and keeps this tab in sync with it. You get a link to edit and a link to view." = "Uploadt dit bestand naar een FigCraft-server en houdt dit tabblad daarmee gesynchroniseerd. Je krijgt een link om te bewerken en een link om te bekijken."
+"Uppercase" = "Hoofdletters"
+"Use a fixed value" = "Gebruik een vaste waarde"
+"Use an expression, e.g. count + 1" = "Gebruik een expressie, bijv. count + 1"
+"Use as mask" = "Gebruiken als masker"
+"Use auto layout" = "Auto layout gebruiken"
+"Use number keys for opacity" = "Gebruik cijfertoetsen voor dekking"
+"Use the .figcraft or .fig extension." = "Gebruik de extensie .figcraft of .fig."
+"Use the layer's fill" = "De vulling van de laag gebruiken"
+"Used in {files} · {instances}" = "Gebruikt in {files} · {instances}"
+"Username" = "Gebruikersnaam"
+"Uses variables: each layer shows them in its own mode" = "Gebruikt variabelen: elke laag toont ze in zijn eigen modus"
+"Value" = "Waarde"
+"Variable" = "Variabele"
+"Variable collections" = "Verzamelingen van variabelen"
+"Variable modes" = "Variabelemodi"
+"Variable width" = "Variabele breedte"
+"Variables" = "Variabelen"
+"Variables JSON…" = "Variabelen-JSON…"
+"Variables store reusable values (colours, numbers, strings, booleans) with modes such as Light and Dark." = "Variabelen slaan herbruikbare waarden (kleuren, getallen, tekenreeksen, booleans) op met modi zoals Light en Dark."
+"Variant" = "Variant"
+"Vector" = "Vector"
+"Vectors" = "Vectoren"
+"Version" = "Versie"
+"Version history" = "Versiegeschiedenis"
+"Version {version}" = "Versie {version}"
+"Version {v} · {components} · {styles} · {variables}" = "Versie {v} · {components} · {styles} · {variables}"
+"Vertical" = "Verticaal"
+"Vertical align" = "Verticaal uitlijnen"
+"Vertical hex" = "Verticale hex"
+"Vertical padding" = "Verticale padding"
+"Vertical spacing" = "Verticale afstand"
+"Vertical trim" = "Verticaal bijsnijden"
+"View" = "Weergave"
+"View link" = "Weergavelink"
+"View link copied" = "Weergavelink gekopieerd"
+"View only" = "Alleen weergeven"
+"View only: you see every change as it happens but can't edit. Leave to keep a copy you can edit." = "Alleen weergeven: je ziet elke wijziging live terwijl die plaatsvindt, maar je kunt niet bewerken. Verlaat de sessie om een kopie te bewaren die je kunt bewerken."
+"Viewing “{name}”" = "“{name}” bekijken"
+"Violet" = "Violet"
+"Visibility" = "Zichtbaarheid"
+"Visible" = "Zichtbaar"
+"Vivid" = "Vivid"
+"WGPU_BACKEND is set and names the graphics API to use; unsetting it lets FigCraft choose." = "WGPU_BACKEND is ingesteld en geeft de te gebruiken grafische API aan; als je het uitzet, kiest FigCraft zelf."
+"Warm" = "Warm"
+"Watch" = "Watch"
+"Wavy" = "Golvend"
+"Web" = "Web"
+"WebSocket URL" = "WebSocket-URL"
+"WebSocket URL copied" = "WebSocket-URL gekopieerd"
+"Websites" = "Websites"
+"Wedge" = "Wedge"
+"Weight" = "Dikte"
+"What changed since it was marked ready for dev" = "Wat er veranderd is sinds het is gemarkeerd als klaar voor Dev Mode"
+"What is wrong with this file? The server's operator gets your report." = "Wat klopt er niet aan dit bestand? Je melding gaat naar de beheerder van de server."
+"What it's for" = "Waarvoor het dient"
+"What this changed from isn't known: it changed before FigCraft kept a copy of ready-for-dev frames. Resolve the change (or mark it ready again) to compare from now on." = "Vanwaar dit is veranderd, is niet bekend: het veranderde voordat FigCraft een kopie bewaarde van dev-klare frames. Los de wijziging op (of markeer het weer als te vergelijken) om vanaf nu te kunnen vergelijken."
+"What you try here changes this preview and the code below, not the file" = "Wat je hier probeert, wijzigt deze voorvertoning en de code hieronder, niet het bestand"
+"While hovering" = "Tijdens het aanwijzen"
+"While pressing" = "Tijdens het indrukken"
+"White" = "Wit"
+"Who runs it, its terms and how long it keeps files" = "Wie het beheert, de voorwaarden en hoelang het bestanden bewaart"
+"Why it changed" = "Waarom het is veranderd"
+"Widget" = "Widget"
+"Widgets" = "Widgets"
+"Width" = "Breedte"
+"Width point" = "Breedtepunt"
+"Width profile" = "Breedteprofiel"
+"Wireframe kit" = "Wireframekit"
+"With the layers' export settings" = "Met de exportinstellingen van de lagen"
+"Wrap" = "Omloop"
+"Wrap in new section" = "Inpakken in een nieuwe sectie"
+"Yellow" = "Geel"
+"Yesterday" = "Gisteren"
+"You" = "Jij"
+"You'll get the shared file as a new tab and edit it together." = "Je krijgt het gedeelde bestand als nieuw tabblad en bewerkt het samen."
+"You're spotlighting: everyone follows your view" = "Je bent in de spotlight: iedereen volgt jouw weergave"
+"Your copy of the file stays open" = "Je kopie van het bestand blijft open"
+"Your copy stays open; the file stays on the server" = "Jouw kopie blijft open; het bestand blijft op de server"
+"Your name" = "Jouw naam"
+"Your name in comments" = "Je naam in reacties"
+"Your system asks for reduced motion: animations stay off." = "Jouw systeem vraagt om minder beweging: animaties blijven uit."
+"Z" = "Z"
+"Z to A" = "Z tot A"
+"Zoom" = "Zoom"
+"Zoom around the pointer" = "Inzoomen rond de aanwijzer"
+"Zoom device to fill window" = "Apparaat inzoomen om het venster te vullen"
+"Zoom in" = "Inzoomen"
+"Zoom out" = "Uitzoomen"
+"Zoom to 100%" = "Zoomen naar 100%"
+"Zoom to 200%" = "Inzoomen op 200%"
+"Zoom to 50%" = "Zoomen naar 50%"
+"Zoom to fit" = "Inpassen"
+"Zoom to selection" = "Inzoomen op selectie"
+"Zoom tool: click to zoom in, drag an area" = "Zoomgereedschap: klik om in te zoomen, sleep om een gebied te selecteren"
+"Zoom tool: zoom out" = "Zoomgereedschap: uitzoomen"
+"and {n} more" = { one = "en {n} meer", other = "en {n} meer" }
+"bleed marks" = "afloopmarkeringen"
+"by {author}" = "door {author}"
+"call any command its access allows" = "elke opdracht aanroepen die diens toegang toestaat"
+"call only: {commands}" = "alleen aanroepbaar: {commands}"
+"can edit the document" = "kan het document bewerken"
+"conditional prototype actions nested too deeply were skipped" = "Voorwaardelijke prototype-acties die te diep genest zijn, zijn overgeslagen"
+"conditional prototype actions with conditions that can't be evaluated were skipped" = "voorwaardelijke prototypeacties met voorwaarden die niet konden worden geëvalueerd zijn overgeslagen"
+"connector label background was skipped: style data is missing" = "achtergrond van connectorlabel overgeslagen: stijldata ontbreekt"
+"connector label was skipped: background bounds are invalid" = "connectorlabel is overgeslagen: achtergrondgrenzen zijn ongeldig"
+"connector label was skipped: background transform is invalid" = "connector labels overgeslagen: achtergrondtransformatie is ongeldig"
+"connector label was skipped: composed text transform is invalid" = "connectorlabel is overgeslagen: samengestelde teksttransformatie is ongeldig"
+"connector label was skipped: derived background bounds are missing" = "connectorlabel is overgeslagen: afgeleide achtergrondgrenzen ontbreken"
+"connector label was skipped: derived text bounds are missing" = "connectorlabel is overgeslagen: afgeleide tekstgrenzen ontbreken"
+"connector label was skipped: text bounds are invalid" = "connectorlabel overgeslagen: de tekstafmetingen zijn ongeldig"
+"connector label was skipped: text style data is missing" = "connectorlabel is overgeslagen: tekststijlgegevens ontbreken"
+"connector label was skipped: text transform is invalid" = "Het label van de verbinding is overgeslagen: de teksttransformatie is ongeldig"
+"connector labels were skipped" = "labels van connectoren zijn overgeslagen"
+"connector layers import as static frame/vector snapshots with labels when present; live endpoint bindings are not retained" = "connectorlagen worden geïmporteerd als statische frame-/vectormomentopnames met labels indien aanwezig; live eindpuntkoppelingen worden niet behouden"
+"connector snapshot vector data is missing; connector was left empty" = "vectordata in de connector-snapshot ontbreekt; connector is leeggelaten"
+"connectors whose ends can't be placed are empty" = "connectors waarvan de uiteinden niet geplaatst kunnen worden zijn leeg"
+"crop marks" = "snijmarkeringen"
+"damaged vector geometry was skipped" = "beschadigde vectorgeometrie is overgeslagen"
+"damaged vector networks import as outlines" = "beschadigde vectornetwerken worden geïmporteerd als outlines"
+"development: {path}" = "ontwikkeling: {path}"
+"document children other than pages were skipped" = "documentkinderen anders dan pagina's zijn overgeslagen"
+"duplicate grid track sizing entries use equal tracks" = "Dubbele vermeldingen voor trackgroottes gebruiken gelijke tracks"
+"e.g. count + 1" = "bijv. count + 1"
+"e.g. count >= 3 and not done" = "bijv. aantal >= 3 en niet klaar"
+"elbowed and curved connectors without a saved path import as straight lines" = "haakse en gebogen connectors zonder opgeslagen pad worden geïmporteerd als rechte lijnen"
+"entries without a node type were skipped" = "items zonder node-type zijn overgeslagen"
+"figcraft:// links from a browser, chat or email open this app and join the session." = "figcraft://-links uit een browser, chat of e-mail openen deze app en laten je deelnemen aan de sessie."
+"filled areas of a vector with their own fill use the layer's fill" = "gevulde gebieden van een vector met een eigen vulling gebruiken de vulling van de laag"
+"from {server}" = "van {server}"
+"gamepad triggers without exactly one known controller button were skipped" = "gamepad-triggers zonder precies één bekende controllerknop zijn overgeslagen"
+"grid track list exceeds 1000 entries; the tracks use the default equal sizing" = "de lijst met rastertracks overschrijdt 1000 items; de tracks gebruiken de standaard gelijke grootte"
+"grid track sizing is unsupported or malformed; affected tracks use equal sizing" = "Trackgrootte wordt niet ondersteund of is ongeldig opgemaakt; de betreffende tracks gebruiken gelijke groottes"
+"grid track sizing list exceeds 1000 entries; the tracks use the default equal sizing" = "de lijst met maten voor rastertracks bevat meer dan 1000 items; de tracks gebruiken de standaard gelijke maat"
+"hidden" = "verborgen"
+"iOS" = "iOS"
+"image filters are ambiguous because both filter containers are present; filter conversion was skipped" = "afbeeldingsfilters zijn dubbelzinnig omdat beide filtercontainers aanwezig zijn; filterconversie is overgeslagen"
+"image filters use FigCraft's approximate renderer" = "afbeeldingsfilters gebruiken de benaderende renderer van FigCraft"
+"instance swap properties whose default component isn't in the file were skipped" = "instance-swap-eigenschappen waarvan de standaardcomponent niet in het bestand zit, zijn overgeslagen"
+"instances inside their own main component were imported as frames" = "instances in hun eigen hoofdcomponent zijn geïmporteerd als frames"
+"instances of components that aren't in the file show no layers" = "instances van components die niet in het bestand staan, tonen geen lagen"
+"instances of components that aren't in the file were imported as frames" = "instances van componenten die het bestand niet bevat zijn als frames geïmporteerd"
+"instances that would nest a component inside itself were imported as frames" = "Instanties die een component in zichzelf zouden nesten, zijn als frames geïmporteerd"
+"instances without a main component were imported as empty frames" = "instances zonder hoofdcomponent zijn geïmporteerd als lege frames"
+"invalid internal .fig text path data was ignored" = "ongeldige padgegevens van interne .fig-tekst zijn genegeerd"
+"invalid or oversized vector networks import as outlines" = "ongeldige of te grote vectornetwerken worden geïmporteerd als contouren"
+"invalid or oversized vector path data was skipped" = "ongeldige of te grote vectorpadgegevens zijn overgeslagen"
+"just now" = "zojuist"
+"key triggers without a supported key were skipped" = "key-triggers zonder een ondersteunde toets zijn overgeslagen"
+"key up triggers import as key presses" = "key-up-triggers worden geïmporteerd als toetsaanslagen"
+"layers without a position were placed at their parent's origin" = "lagen zonder positie zijn op de oorsprong van het bovenliggende element geplaatst"
+"layers without a type were skipped" = "lagen zonder type zijn overgeslagen"
+"legacy image filter container is unsupported; filter conversion was skipped" = "Verouderde container voor beeldfilters wordt niet ondersteund; filterconversie is overgeslagen"
+"locked" = "vergrendeld"
+"malformed image filters container was skipped" = "misvormde container met afbeeldingsfilters is overgeslagen"
+"malformed image paintFilter container was skipped" = "onjuist gevormde image paintFilter-container is overgeslagen"
+"malformed slot content assignment was skipped" = "onjuiste toewijzing van slot-inhoud is overgeslagen"
+"no bleed" = "geen afloop"
+"nobody else here yet" = "nog niemand anders hier"
+"non-default slot settings are not represented and were skipped" = "niet-standaard slot-instellingen zijn niet overgenomen en zijn overgeslagen"
+"now" = "nu"
+"only in a text style or variable" = "alleen in een tekststijl of variabele"
+"or" = "of"
+"point stroke joins were preserved; dashed or variable-width strokes render with the layer join" = "Lijnverbindingen op punten zijn behouden; gestreepte lijnen of lijnen met variabele breedte worden weergegeven met de verbinding van de laag"
+"preferred slot component keys cannot be resolved to file nodes and were skipped" = "voorkeurssleutels van slotcomponenten konden niet naar bestandsknooppunten worden herleid en zijn overgeslagen"
+"prototype actions of unknown types were skipped" = "prototypeacties van onbekende typen zijn overgeslagen"
+"prototype actions without a destination in the file were skipped" = "prototype-acties zonder bestemming in het bestand zijn overgeslagen"
+"prototype expressions on variables that aren't in the variables JSON were skipped" = "prototype-expressies over variabelen die niet in de variables-JSON staan zijn overgeslagen"
+"prototype expressions with unsupported functions were skipped" = "prototype-expressies met niet-ondersteunde functies zijn overgeslagen"
+"prototype interactions without supported actions were skipped" = "prototype-interacties zonder ondersteunde acties zijn overgeslagen"
+"prototype navigations of unknown types were skipped" = "prototype-navigaties van onbekende typen zijn overgeslagen"
+"prototype transitions of unknown types play instantly" = "prototype-overgangen van onbekende typen worden direct afgespeeld"
+"prototype triggers of unknown types were skipped" = "prototype-triggers van onbekende typen zijn overgeslagen"
+"put a widget on the canvas" = "een widget op het canvas zetten"
+"read and edit the document" = "het document lezen en bewerken"
+"read the document" = "lees het document"
+"reads the document" = "leest het document"
+"set-variable actions on variables that aren't in the variables JSON were skipped" = "set-variable-acties op variabelen die niet in de variables-JSON staan zijn overgeslagen"
+"set-variable actions with values that can't be evaluated were skipped" = "set-variable-acties met waarden die niet kunnen worden geëvalueerd zijn overgeslagen"
+"set-variable actions with values that don't fit the variable were skipped" = "set-variable-acties met waarden die niet in de variabele passen, zijn overgeslagen"
+"set-variable actions without a value were skipped" = "set-variable-acties zonder waarde zijn overgeslagen"
+"set-variable-mode actions on collections or modes that aren't in the variables JSON were skipped" = "set-variable-mode-acties op verzamelingen of modi die niet in de variables JSON staan, zijn overgeslagen"
+"slot content assignment target is missing or is not slot content" = "het toewijzingsdoel van slotcontent ontbreekt of is geen slotcontent"
+"slot content assignment uses the empty GUID sentinel and was skipped" = "Toewijzing van slot-inhoud gebruikt de lege GUID-sentinelwaarde en is overgeslagen"
+"some vector points refer to point settings missing from the file; they use the layer's joins and plain corners" = "sommige vectorpunten verwijzen naar puntinstellingen die ontbreken in het bestand; ze gebruiken de verbindingen van de laag en gewone hoeken"
+"some vector segments refer to style settings missing from the file; they use the layer's stroke" = "sommige vectorsegmenten verwijzen naar stijlinstellingen die in het bestand ontbreken; ze gebruiken de lijn van de laag"
+"stale or invalid grid track sizing entries were ignored" = "verouderde of ongeldige items voor de trackgroottes van het raster zijn genegeerd"
+"stars and polygons without point counts or geometry use the default point count" = "sterren en veelhoeken zonder puntaantallen of geometrie gebruiken het standaardpuntaantal"
+"style settings of some vector segments aren't supported; those segments use the layer's stroke" = "stijlinstellingen van sommige vectorsegmenten worden niet ondersteund; die segmenten gebruiken de lijn van de laag"
+"text path underline or strikethrough decoration is not rendered" = "onderstreep- of doorhaaldecoratie op een tekstpad wordt niet weergegeven"
+"text style overrides refer to missing table entries" = "tekststijl-overschrijvingen verwijzen naar ontbrekende tabelitems"
+"the file has no pages" = "het bestand heeft geen pagina's"
+"the plugin" = "de plugin"
+"the variables JSON has no `variableCollections` (expected the local variables response) and was ignored" = "De variabelen-JSON bevat geen `variableCollections` (de respons van lokale variabelen was verwacht) en is genegeerd"
+"this session only" = "alleen voor deze sessie"
+"unknown component property types were skipped" = "componenteigenschappen van onbekende typen zijn overgeslagen"
+"variable aliases to variables that aren't in the variables JSON (or of another type) were skipped" = "variabele-aliassen naar variabelen die niet in de variables JSON zitten (of van een ander type zijn) zijn overgeslagen"
+"variable bindings to properties the layer doesn't have were skipped" = "variabelekoppelingen naar eigenschappen die de laag niet heeft zijn overgeslagen"
+"variable bindings to variables that aren't in the variables JSON (library variables) were skipped" = "variabelekoppelingen naar variabelen die niet in de variabelen-JSON zitten (bibliotheekvariabelen) zijn overgeslagen"
+"variable bindings were skipped: the file JSON has no variable definitions (pass the local variables JSON as `variables`, or embed its `meta` next to the file JSON)" = "variabelekoppelingen zijn overgeslagen: de bestands-JSON bevat geen variabelendefinities (geef de JSON van lokale variabelen mee als `variables`, of voeg de `meta` ervan naast de bestands-JSON in)"
+"variable bindings whose variable type doesn't fit the property were skipped" = "variabelekoppelingen waarvan het variabeletype niet bij de eigenschap past zijn overgeslagen"
+"variable collections without modes were skipped" = "variabeleverzamelingen zonder modi zijn overgeslagen"
+"variable mode lookups in prototype expressions that aren't a variable and one of its modes were skipped" = "opzoekingen in prototype-expressies naar andere combinaties dan een variabele en een van zijn modi zijn overgeslagen"
+"variable modes of collections that aren't in the file were skipped" = "Variabelemodi van verzamelingen die niet in het bestand staan, zijn overgeslagen"
+"variable modes of collections that aren't in the variables JSON were skipped" = "variabelemodi van verzamelingen die niet in de variables-JSON staan zijn overgeslagen"
+"variable values that don't match their type (or composed colours) were skipped" = "waarden van variabelen die niet bij hun type passen (of samengestelde kleuren) zijn overgeslagen"
+"variables of unknown types were skipped" = "variabelen van onbekende typen zijn overgeslagen"
+"variables whose collection isn't in the variables JSON were skipped" = "variabelen waarvan de verzameling niet in de variables-JSON zit zijn overgeslagen"
+"variables without readable values were skipped" = "variabelen zonder leesbare waarde zijn overgeslagen"
+"vector points with unknown stroke joins use the layer join" = "vectorpunten met onbekende lijnverbindingen gebruiken de verbinding van de laag"
+"vectors without geometry are empty" = "vectoren zonder geometrie zijn leeg"
+"vectors without geometry are empty (export the file JSON with geometry=paths)" = "vectoren zonder geometrie zijn leeg (exporteer de bestands-JSON met geometry=paths)"
+"very long text was cut to 1,048,576 characters" = "zeer lange tekst is ingekort tot 1.048.576 tekens"
+"very long vector paths were skipped" = "Zeer lange vectorpaden zijn overgeslagen"
+"video actions are not supported and were skipped" = "videoacties worden niet ondersteund en zijn overgeslagen"
+"video triggers are not supported and were skipped" = "videotriggers worden niet ondersteund en zijn overgeslagen"
+"yesterday" = "gisteren"
+"{instances} in {files}" = "{instances} in {files}"
+"{language}: draft translation, waiting for a native speaker's review." = "{language}: voorlopige vertaling, wacht op controle door een moedertaalspreker."
+"{length} bleed" = "{length} afloop"
+"{month} {day}, {year}" = "{day} {month} {year}"
+"{name} (from {library})" = "{name} (uit {library})"
+"{name} (you)" = "{name} (jij)"
+"{name} ({layers} layers)" = "{name} ({layers} lagen)"
+"{name} ({tag}): {min} – {max}, default {default}. Double-click the slider to go back to the style's value; Escape while dragging cancels." = "{name} ({tag}): {min} – {max}, standaard {default}. Dubbelklik op de schuifregelaar om terug te gaan naar de waarde van de stijl; Escape tijdens het slepen annuleert."
+"{name} cleared from the list" = "{name} uit de lijst verwijderd"
+"{name} from {path}" = "{name} uit {path}"
+"{name} is forgotten on this computer; the file stays on {server}" = "{name} is op deze computer vergeten; het bestand blijft op {server}"
+"{name} is on the server." = "{name} staat op de server."
+"{name} is spotlighting" = "{name} staat in de spotlight"
+"{name} is too large to open in the browser (over 512 MB)." = "{name} is te groot om in de browser te openen (meer dan 512 MB)."
+"{name} was removed from the server" = "{name} is van de server verwijderd"
+"{name} · deleted on main" = "{name} · verwijderd op main"
+"{name} · deleted on the branch" = "{name} · verwijderd op de branch"
+"{name} · not published" = "{name} · niet gepubliceerd"
+"{name} · on a server" = "{name} · op een server"
+"{name} · published version {v}" = "{name} · gepubliceerde versie {v}"
+"{name} · version {v} on the server" = "{name} · versie {v} op de server"
+"{name}, in a live session" = "{name}, in een live sessie"
+"{name}, online, open only to you" = "{name}, online, alleen voor jou toegankelijk"
+"{name}, {kind}, {w} by {h}, selected" = "{name}, {kind}, {w} bij {h}, geselecteerd"
+"{name}\nClick to apply to the selection" = "{name}\nKlik om op de selectie toe te passen"
+"{name}\nDrag onto the canvas, or click to place in the middle of the view.\nHold Alt (Option) while dropping onto an instance to swap it." = "{name}\nSleep naar het canvas, of klik om in het midden van de weergave te plaatsen.\nHoud Alt (Option) ingedrukt terwijl je op een instance loslaat om die te verwisselen."
+"{n} added" = { one = "{n} toegevoegd", other = "{n} toegevoegd" }
+"{n} autosave versions" = { one = "{n} automatisch opgeslagen versie", other = "{n} automatisch opgeslagen versies" }
+"{n} changed" = { one = "{n} gewijzigd", other = "{n} gewijzigd" }
+"{n} columns" = { one = "{n} kolom", other = "{n} kolommen" }
+"{n} components" = { one = "{n} component", other = "{n} componenten" }
+"{n} components and styles have newer versions" = { one = "{n} component of stijl heeft een nieuwere versie", other = "{n} components en stijlen hebben nieuwere versies" }
+"{n} conflicts to resolve" = { one = "{n} conflict om op te lossen", other = "{n} conflicten om op te lossen" }
+"{n} days ago" = { one = "{n} dag geleden", other = "{n} dagen geleden" }
+"{n} files" = { one = "{n} bestand", other = "{n} bestanden" }
+"{n} hours ago" = { one = "{n} uur geleden", other = "{n} uur geleden" }
+"{n} instances" = { one = "{n} instance", other = "{n} instances" }
+"{n} layers" = { one = "{n} laag", other = "{n} lagen" }
+"{n} layers as one file" = { one = "{n} laag als één bestand", other = "{n} lagen als één bestand" }
+"{n} layers selected" = { one = "{n} laag geselecteerd", other = "{n} lagen geselecteerd" }
+"{n} layers · {parts}" = { one = "{n} laag · {parts}", other = "{n} lagen · {parts}" }
+"{n} matches" = { one = "{n} overeenkomst", other = "{n} overeenkomsten" }
+"{n} minutes ago" = { one = "{n} minuut geleden", other = "{n} minuten geleden" }
+"{n} months ago" = { one = "{n} maand geleden", other = "{n} maanden geleden" }
+"{n} more notes omitted from this report" = { one = "{n} extra notitie weggelaten uit dit rapport", other = "{n} extra notities weggelaten uit dit rapport" }
+"{n} of {total}" = "{n} van {total}"
+"{n} people joined" = { one = "{n} persoon is erbij gekomen", other = "{n} personen zijn erbij gekomen" }
+"{n} preferred components" = { one = "{n} voorkeurscomponent", other = "{n} voorkeurscomponenten" }
+"{n} ready" = { one = "{n} klaar", other = "{n} klaar" }
+"{n} removed" = { one = "{n} verwijderd", other = "{n} verwijderd" }
+"{n} replies" = { one = "{n} antwoord", other = "{n} antwoorden" }
+"{n} rows" = { one = "{n} rij", other = "{n} rijen" }
+"{n} styles" = { one = "{n} stijl", other = "{n} stijlen" }
+"{n} text layers" = { one = "{n} tekstlaag", other = "{n} tekstlagen" }
+"{n} variables" = { one = "{n} variabele", other = "{n} variabelen" }
+"{n} weeks ago" = { one = "{n} week geleden", other = "{n} weken geleden" }
+"{n} years ago" = { one = "{n} jaar geleden", other = "{n} jaar geleden" }
+"{n}d" = "{n}d"
+"{n}h" = "{n}h"
+"{n}m" = "{n}m"
+"{n}w" = "{n}w"
+"{page}, nothing selected" = "{page}, niets geselecteerd"
+"{profile} (current)" = "{profile} (huidig)"
+"{property} is its value; {property ? \"a\" : \"b\"} picks a string. Other {…} stays as written." = "{property} is de waarde ervan; {property ? \"a\" : \"b\"} kiest een string. Andere {…} blijven letterlijk staan."
+"{server} can't say what became of your files (it is older than this app)." = "{server} kan niet zeggen wat er met je bestanden is gebeurd (deze is ouder dan deze app)."
+"{server} · No longer on the server" = "{server} · Niet meer op de server"
+"{server} · {shared} · Opened {date}" = "{server} · {shared} · Geopend op {date}"
+"{tool}  hold {key}" = "{tool}  {key} ingedrukt houden"
+"{value} isn't a colour" = "{value} is geen kleur"
+"{when} · edited" = "{when} · bewerkt"
+"←" = "←"
+"← ↑ → ↓" = "← ↑ → ↓"
+"← → ↑ ↓" = "← → ↑ ↓"
+"→, Space or N" = "→, Spatie of N"
+"↵" = "↵"
+"⇥ / ⇧⇥" = "⇥ / ⇧⇥"
+"⌘ arrows" = "⌘ arrows"
+"⌘ click" = "⌘ click"
+"⌘ scroll" = "⌘ scroll"
+"⌥ drag" = "⌥ drag"
+
+[commands]
+"align.bottom" = "Onder uitlijnen"
+"align.hcenter" = "Horizontale middens uitlijnen"
+"align.left" = "Links uitlijnen"
+"align.right" = "Rechts uitlijnen"
+"align.top" = "Boven uitlijnen"
+"align.vcenter" = "Verticale middens uitlijnen"
+"annotation.add" = "Annotatie toevoegen"
+"annotation.addCategory" = "Annotatiecategorie toevoegen"
+"annotation.categories" = "Annotatiecategorieën"
+"annotation.edit" = "Annotatie bewerken"
+"annotation.editCategory" = "Annotatiecategorie bewerken"
+"annotation.list" = "Annotaties weergeven"
+"annotation.remove" = "Annotatie verwijderen"
+"annotation.removeCategory" = "Annotatiecategorie verwijderen"
+"app.actions" = "Acties"
+"app.preferences" = "Voorkeuren"
+"arrange.back" = "Achteraan plaatsen"
+"arrange.backward" = "Naar achteren sturen"
+"arrange.forward" = "Naar voren brengen"
+"arrange.front" = "Vooraan plaatsen"
+"arrange.packH" = "Horizontaal samenpakken"
+"arrange.packV" = "Verticaal stapelen"
+"arrange.roundToPixels" = "Afronden op pixels"
+"arrange.spacing" = "Afstand"
+"arrange.tidy" = "Opruimen"
+"board.connector" = "Verbinding"
+"board.ink" = "Stiftlijn"
+"board.label" = "Label van verbinding"
+"board.nextSticky" = "Volgend plakbriefje"
+"board.setColor" = "Whiteboardkleur"
+"board.setStyle" = "Whiteboardstijl"
+"board.shape" = "Vorm met tekst"
+"board.stamp" = "Stempel"
+"board.sticky" = "Plakbriefje"
+"bool.exclude" = "Exclude toepassen op selectie"
+"bool.flatten" = "Boolean afvlakken"
+"bool.intersect" = "Intersect toepassen op selectie"
+"bool.subtract" = "Selectie aftrekken"
+"bool.union" = "Union toepassen op selectie"
+"branch.archive" = "Branch archiveren"
+"branch.create" = "Branch maken"
+"branch.list" = "Branches weergeven"
+"branch.merge" = "Branch samenvoegen"
+"branch.open" = "Branch openen"
+"branch.review" = "Branch beoordelen"
+"branch.updateFromMain" = "Bijwerken vanaf main"
+"codeConnect.export" = "Codeverbindingen exporteren"
+"codeConnect.import" = "Codekoppelingen importeren"
+"codeConnect.remove" = "Koppeling met code verbreken"
+"codeConnect.set" = "Aan code koppelen"
+"collab.cursor" = "Cursor weergeven op"
+"collab.cursorChat" = "Cursorchat"
+"collab.diff" = "Syncwijzigingen weergeven"
+"collab.files" = "Jouw online bestanden"
+"collab.follow" = "Volgen"
+"collab.forgetFile" = "Online bestand vergeten"
+"collab.host" = "Live sessie starten"
+"collab.join" = "Deelnemen aan live sessie"
+"collab.leave" = "Live sessie verlaten"
+"collab.manageFile" = "Gepubliceerd bestand beheren"
+"collab.openFile" = "Online bestand openen"
+"collab.peers" = "Mensen in dit bestand"
+"collab.publish" = "Publiceren op server"
+"collab.recoverFile" = "Online bestand herstellen"
+"collab.registerLinks" = "Uitnodigingslinks openen in FigCraft"
+"collab.removePerson" = "Uit sessie verwijderen"
+"collab.report" = "Bestand melden bij serverbeheerder"
+"collab.serverInfo" = "Serverinformatie"
+"collab.share" = "Delen met een deelnamecode"
+"collab.spotlight" = "Mij in de spotlight zetten"
+"collab.stop" = "Livesessie stoppen"
+"command.batch" = "Meerdere opdrachten uitvoeren"
+"comment.add" = "Reactie toevoegen"
+"comment.delete" = "Reactie verwijderen"
+"comment.edit" = "Reactie bewerken"
+"comment.link" = "Link naar reactie kopiëren"
+"comment.list" = "Reacties weergeven"
+"comment.markRead" = "Reactie als gelezen markeren"
+"comment.move" = "Reactie verplaatsen"
+"comment.next" = "Volgende reactie"
+"comment.open" = "Reactie openen"
+"comment.people" = "Personen in reacties"
+"comment.react" = "Op reactie reageren"
+"comment.reply" = "Op reactie antwoorden"
+"comment.resolve" = "Reactie oplossen"
+"comment.zoom" = "Inzoomen op reacties"
+"component.addProperty" = "Componenteigenschap toevoegen"
+"component.addVariant" = "Variant toevoegen"
+"component.bindProperty" = "Laag aan eigenschap koppelen"
+"component.combineVariants" = "Combineren als varianten"
+"component.create" = "Component maken"
+"component.createMultiple" = "Meerdere componenten maken"
+"component.deleteProperty" = "Componenteigenschap verwijderen"
+"component.detach" = "Instance loskoppelen"
+"component.editProperty" = "Componenteigenschap bewerken"
+"component.exposeInstance" = "Geneste instance zichtbaar maken"
+"component.goToMain" = "Naar hoofdcomponent gaan"
+"component.hideWhenPublishing" = "Verbergen bij publiceren"
+"component.list" = "Componenten weergeven"
+"component.makeSlot" = "Slot maken"
+"component.playground" = "Componentplayground"
+"component.properties" = "Componenteigenschappen"
+"component.pushChanges" = "Wijzigingen naar hoofdcomponent pushen"
+"component.removeSlot" = "Slot verwijderen"
+"component.resetInstance" = "Alle wijzigingen herstellen"
+"component.resetOverride" = "Overschrijving resetten"
+"component.restoreMain" = "Hoofdcomponent terugzetten"
+"dev.compare" = "Wijzigingen vergelijken"
+"dev.focus" = "Focusweergave"
+"dev.resolveChange" = "Wijziging oplossen"
+"dev.unfocus" = "Focusweergave verlaten"
+"devResource.add" = "Dev-resource toevoegen"
+"devResource.edit" = "Dev-resource bewerken"
+"devResource.list" = "Dev-resources weergeven"
+"devResource.remove" = "Dev-resource verwijderen"
+"distribute.horizontal" = "Horizontale afstand verdelen"
+"distribute.vertical" = "Verticale afstand verdelen"
+"doc.home" = "Home"
+"doc.list" = "Documenten weergeven"
+"doc.nextTab" = "Volgend tabblad"
+"doc.previousTab" = "Vorig tabblad"
+"doc.switch" = "Document wisselen"
+"edit.copy" = "Kopiëren"
+"edit.copyAsCss" = "Kopiëren als CSS"
+"edit.copyAsPng" = "Kopiëren als PNG"
+"edit.copyAsSvg" = "Kopiëren als SVG"
+"edit.copyAsText" = "Kopiëren als tekst"
+"edit.copyLink" = "Link naar selectie kopiëren"
+"edit.copyProperties" = "Eigenschappen kopiëren"
+"edit.cut" = "Knippen"
+"edit.delete" = "Verwijderen"
+"edit.duplicate" = "Dupliceren"
+"edit.findReplace" = "Zoeken en vervangen"
+"edit.paste" = "Plakken"
+"edit.pasteDesignLayers" = "Ontwerplagen plakken"
+"edit.pasteOver" = "Plakken over selectie"
+"edit.pasteProperties" = "Eigenschappen plakken"
+"edit.pasteReplace" = "Plakken ter vervanging"
+"edit.pickColor" = "Kleur oppikken"
+"edit.redo" = "Opnieuw"
+"edit.repeat" = "Laatste opdracht herhalen"
+"edit.setDefaultProperties" = "Standaardeigenschappen instellen"
+"edit.undo" = "Ongedaan maken"
+"effect.add" = "Effect toevoegen"
+"effect.move" = "Effect verplaatsen"
+"effect.remove" = "Effect verwijderen"
+"effect.set" = "Effect instellen"
+"export.add" = "Exportinstelling toevoegen"
+"export.remove" = "Exportinstelling verwijderen"
+"export.update" = "Exportinstelling bewerken"
+"file.close" = "Tabblad sluiten"
+"file.colorProfile" = "Kleurprofiel"
+"file.duplicate" = "Bestand dupliceren"
+"file.export" = "Exporteren"
+"file.exportFramesPdf" = "Frames exporteren naar PDF"
+"file.exportLayers" = "Lagen exporteren"
+"file.exportSvg" = "Selectie exporteren als SVG"
+"file.import" = "Importeren"
+"file.moveTab" = "Tabblad verplaatsen"
+"file.new" = "Nieuw ontwerpbestand"
+"file.newBoard" = "Nieuw whiteboard"
+"file.newFromTemplate" = "Nieuw vanuit sjabloon"
+"file.open" = "Openen"
+"file.openRecent" = "Onlangs geopende bestanden"
+"file.placeImage" = "Afbeelding plaatsen"
+"file.recover" = "Bestand herstellen"
+"file.rename" = "Bestand hernoemen"
+"file.revert" = "Terugdraaien naar opgeslagen versie"
+"file.save" = "Opslaan"
+"file.saveAs" = "Opslaan als"
+"file.saveVersion" = "Opslaan in versiegeschiedenis"
+"file.versionHistory" = "Versiegeschiedenis weergeven"
+"fill.add" = "Vulling toevoegen"
+"fill.move" = "Vulling verplaatsen"
+"fill.pattern" = "Patroonvulling"
+"fill.remove" = "Vulling verwijderen"
+"fill.set" = "Vulling instellen"
+"frame.create" = "Frame maken"
+"frame.presets" = "Frame-voorinstellingen weergeven"
+"frame.swapOrientation" = "Oriëntatie omwisselen"
+"grid.add" = "Layoutraster toevoegen"
+"grid.move" = "Layoutraster verplaatsen"
+"grid.remove" = "Layoutraster verwijderen"
+"guide.add" = "Hulplijn toevoegen"
+"guide.clear" = "Alle hulplijnen verwijderen"
+"guide.move" = "Hulplijn verplaatsen"
+"guide.remove" = "Hulplijn verwijderen"
+"guide.select" = "Hulplijn selecteren"
+"help.about" = "Over FigCraft"
+"help.gettingStarted" = "Aan de slag"
+"help.page" = "Helppagina"
+"help.shortcuts" = "Sneltoetsen"
+"image.adjust" = "Afbeelding aanpassen"
+"image.deletePreset" = "Afbeeldingspreset verwijderen"
+"image.place" = "Afbeelding plaatsen"
+"image.presets" = "Afbeeldingsvoorinstellingen"
+"image.savePreset" = "Voorinstelling voor afbeelding opslaan"
+"inspect.assets" = "Assets inspecteren"
+"inspect.code" = "Code voor laag"
+"inspect.componentCode" = "Componentcode"
+"inspect.properties" = "Eigenschappen inspecteren"
+"inspect.readyForDev" = "Ready for dev"
+"instance.create" = "Instance maken"
+"instance.exposed" = "Zichtbare geneste instances"
+"instance.place" = "Instance plaatsen"
+"instance.resetSlot" = "Slot herstellen"
+"instance.setProperties" = "Eigenschappen van instance instellen"
+"instance.slotInsert" = "In slot invoegen"
+"instance.swap" = "Instance verwisselen"
+"instance.swapAt" = "Instance op punt verwisselen"
+"layers.collapseAll" = "Lagen inklappen"
+"layout.add" = "Auto layout toevoegen"
+"layout.remove" = "Auto layout verwijderen"
+"layout.setTrack" = "Grootte van rastertrack instellen"
+"layout.suggest" = "Auto layout voorstellen"
+"libraries.open" = "Bibliotheken"
+"libraries.publish" = "Bibliotheek publiceren…"
+"library.acceptUpdates" = "Bibliotheekupdates accepteren"
+"library.add" = "Bibliotheek toevoegen"
+"library.aliasVariable" = "Alias van bibliotheekvariabele maken"
+"library.applyStyle" = "Bibliotheekstijl toepassen"
+"library.bindVariable" = "Bibliotheekvariabele koppelen"
+"library.extendCollection" = "Bibliotheekverzameling uitbreiden"
+"library.import" = "Bibliotheekcomponent importeren"
+"library.importVariable" = "Bibliotheekvariabele importeren"
+"library.list" = "Bibliotheken weergeven"
+"library.place" = "Bibliotheekcomponent plaatsen"
+"library.publish" = "Bibliotheek publiceren"
+"library.publishToServer" = "Bibliotheek naar server publiceren"
+"library.remove" = "Bibliotheek verwijderen"
+"library.setVariableMode" = "Modus van bibliotheekvariabele instellen"
+"library.swap" = "Bibliotheek verwisselen"
+"library.swapAt" = "Instance verwisselen voor bibliotheekcomponent"
+"library.updates" = "Bibliotheekupdates"
+"library.usage" = "Bibliotheekgebruik"
+"measure.distances" = "Afstanden meten"
+"measure.padding" = "Padding van auto layout meten"
+"node.create" = "Laag maken"
+"node.get" = "Laag ophalen"
+"node.reorder" = "Laag herordenen"
+"node.reparent" = "Laag verplaatsen naar"
+"node.set" = "Eigenschappen instellen"
+"object.batchRename" = "Batch hernoemen"
+"object.convertToFrame" = "Converteren naar frame"
+"object.convertToGroup" = "Converteren naar groep"
+"object.convertToSection" = "Converteren naar sectie"
+"object.flipH" = "Horizontaal spiegelen"
+"object.flipV" = "Verticaal spiegelen"
+"object.frameSelection" = "Selectie framen"
+"object.group" = "Selectie groeperen"
+"object.hideOthers" = "Overige lagen verbergen"
+"object.mask" = "Als masker gebruiken"
+"object.moveToPage" = "Verplaatsen naar pagina"
+"object.opacityKeys" = "Dekking via cijfertoetsen"
+"object.rasterize" = "Selectie rasteriseren"
+"object.releaseMask" = "Masker opheffen"
+"object.removeFill" = "Vulling verwijderen"
+"object.removeFrame" = "Frame verwijderen"
+"object.removeStroke" = "Lijn verwijderen"
+"object.rename" = "Hernoemen"
+"object.resizeToFit" = "Formaat aanpassen aan inhoud"
+"object.rotate180" = "180° draaien"
+"object.rotateLeft" = "90° naar links draaien"
+"object.rotateRight" = "90° naar rechts draaien"
+"object.setThumbnail" = "Instellen als miniatuur"
+"object.swapFillStroke" = "Vulling en lijn omwisselen"
+"object.toggleLock" = "Selectie vergrendelen/ontgrendelen"
+"object.toggleVisible" = "Selectie tonen/verbergen"
+"object.ungroup" = "Selectie ontgroeperen"
+"object.wrapInSection" = "In nieuwe sectie plaatsen"
+"page.add" = "Pagina toevoegen"
+"page.delete" = "Pagina verwijderen"
+"page.duplicate" = "Pagina dupliceren"
+"page.list" = "Pagina's weergeven"
+"page.move" = "Pagina verplaatsen"
+"page.rename" = "Pagina hernoemen"
+"page.select" = "Naar pagina gaan"
+"page.setBackground" = "Pagina-achtergrond"
+"paint.documentColors" = "Documentkleuren"
+"plugin.close" = "Pluginpaneel sluiten"
+"plugin.directory.install" = "Plugin installeren vanuit map"
+"plugin.directory.list" = "Plugincatalogus doorbladeren"
+"plugin.directory.publish" = "Plugin naar catalogus publiceren"
+"plugin.directory.unpublish" = "Publicatie van plugin in catalogus ongedaan maken"
+"plugin.event" = "Bedieningselement in pluginpaneel gebruiken"
+"plugin.import" = "Plugin importeren vanuit manifest…"
+"plugin.list" = "Plugins weergeven"
+"plugin.remove" = "Plugin verwijderen"
+"plugin.run" = "Plugin uitvoeren"
+"plugin.ui" = "Pluginpaneel"
+"plugins.manage" = "Plugins beheren…"
+"plugins.runLast" = "Laatste plugin uitvoeren"
+"pref.autoSave" = "Bestanden automatisch opslaan"
+"pref.highlightHover" = "Lagen markeren bij aanwijzen"
+"pref.keepTool" = "Gereedschap geselecteerd houden na gebruik"
+"pref.language" = "Interfacetaal"
+"pref.nudge" = "Stapafstand"
+"pref.numberKeysOpacity" = "Cijfertoetsen gebruiken voor dekking"
+"pref.publishServer" = "Server voor online delen"
+"pref.reduceMotion" = "Beweging verminderen"
+"pref.renameDuplicates" = "Gedupliceerde lagen hernoemen"
+"pref.showDimensions" = "Afmetingen op objecten tonen"
+"pref.startOnHome" = "Starten op Home"
+"pref.userName" = "Je naam in reacties"
+"proto.action.add" = "Prototypeactie toevoegen"
+"proto.action.move" = "Volgorde van prototypeactie wijzigen"
+"proto.action.remove" = "Prototype-actie verwijderen"
+"proto.action.set" = "Prototype-actie bewerken"
+"proto.closePreview" = "Prototype-voorvertoning sluiten"
+"proto.conditional.addBlock" = "Else if / else toevoegen"
+"proto.conditional.removeBlock" = "if / else if / else verwijderen"
+"proto.conditional.setCondition" = "Voorwaarde bewerken"
+"proto.evaluate" = "Prototype-expressie evalueren"
+"proto.flow.add" = "Startpunt van flow toevoegen"
+"proto.flow.remove" = "Flow verwijderen"
+"proto.flow.rename" = "Flow hernoemen"
+"proto.interaction.add" = "Interactie toevoegen"
+"proto.interaction.clear" = "Alle interacties verwijderen"
+"proto.interaction.remove" = "Interactie verwijderen"
+"proto.interaction.set" = "Interactie bewerken"
+"proto.present" = "Presenteren"
+"proto.presentOptions" = "Presentatieopties"
+"proto.preview" = "Prototypevoorvertoning openen"
+"proto.settings" = "Prototype-instellingen"
+"section.toggleContents" = "Sectie-inhoud verbergen/weergeven"
+"select.add" = "Toevoegen aan selectie"
+"select.all" = "Alles selecteren"
+"select.area" = "Gebied selecteren"
+"select.byName" = "Lagen op naam selecteren"
+"select.children" = "Onderliggende items selecteren"
+"select.inverse" = "Selectie omkeren"
+"select.layersAt" = "Lagen op een punt"
+"select.matching" = "Overeenkomende lagen selecteren"
+"select.next" = "Volgende laag op hetzelfde niveau selecteren"
+"select.none" = "Selectie opheffen"
+"select.parent" = "Bovenliggende selecteren"
+"select.previous" = "Vorige laag op hetzelfde niveau selecteren"
+"select.remove" = "Uit selectie verwijderen"
+"select.sameEffect" = "Zelfde effect selecteren"
+"select.sameFill" = "Dezelfde vulling selecteren"
+"select.sameFont" = "Lagen met hetzelfde lettertype selecteren"
+"select.sameInstance" = "Zelfde instance selecteren"
+"select.sameProperties" = "Dezelfde eigenschappen selecteren"
+"select.sameStroke" = "Lagen met dezelfde lijn selecteren"
+"select.sameText" = "Dezelfde teksteigenschappen selecteren"
+"select.set" = "Selecteren"
+"selection.applyColorStyle" = "Kleurstijl op selectie toepassen"
+"selection.colors" = "Selectiekleuren"
+"selection.selectColor" = "Lagen op kleur selecteren"
+"selection.setPaint" = "Selectiekleur wijzigen"
+"shape.arrow" = "Pijl"
+"shape.ellipse" = "Ellips"
+"shape.line" = "Lijn"
+"shape.polygon" = "Veelhoek"
+"shape.rectangle" = "Rechthoek"
+"shape.star" = "Ster"
+"shapeBuilder.merge" = "Gebieden samenvoegen"
+"shapeBuilder.mode" = "Shape builder-modus"
+"shapeBuilder.regions" = "Shape builder-gebieden"
+"shapeBuilder.remove" = "Gebieden verwijderen"
+"stroke.add" = "Lijn toevoegen"
+"stroke.brush" = "Penseel"
+"stroke.move" = "Lijn verplaatsen"
+"stroke.remove" = "Lijn verwijderen"
+"stroke.set" = "Lijn instellen"
+"stroke.widthProfile" = "Breedteprofiel"
+"style.apply" = "Stijl toepassen"
+"style.bind" = "Variabele aan stijl koppelen"
+"style.create" = "Stijl maken"
+"style.delete" = "Stijl verwijderen"
+"style.detach" = "Stijl loskoppelen"
+"style.duplicate" = "Stijl dupliceren"
+"style.list" = "Stijlen weergeven"
+"style.move" = "Stijlen verplaatsen"
+"style.renameFolder" = "Stijlmap hernoemen"
+"style.update" = "Stijl bewerken"
+"template.list" = "Sjablonen weergeven"
+"text.alignCenter" = "Midden uitlijnen"
+"text.alignJustify" = "Uitvullen"
+"text.alignLeft" = "Links uitlijnen"
+"text.alignRight" = "Rechts uitlijnen"
+"text.bold" = "Vet"
+"text.bulletList" = "Lijst met opsommingstekens"
+"text.case" = "Hoofdlettergebruik"
+"text.caseLower" = "Kleine letters"
+"text.caseOriginal" = "Oorspronkelijk hoofdlettergebruik"
+"text.caseSmallCaps" = "Kleine hoofdletters"
+"text.caseTitle" = "Hoofdletters per woord"
+"text.caseUpper" = "Hoofdletters"
+"text.create" = "Tekst"
+"text.decoration" = "Decoratie"
+"text.edit.begin" = "Tekst bewerken"
+"text.edit.caret" = "Invoegpunt instellen"
+"text.edit.end" = "Tekst bewerken stoppen"
+"text.edit.insert" = "Tekst typen"
+"text.edit.key" = "Tekstoets"
+"text.edit.preedit" = "Tekst samenstellen (IME)"
+"text.edit.selectLine" = "Regel selecteren"
+"text.edit.selectWord" = "Woord selecteren"
+"text.edit.selection" = "Tekstselectie"
+"text.endPreview" = "Tekstvoorvertoning beëindigen"
+"text.fonts" = "Lettertypen weergeven"
+"text.italic" = "Cursief"
+"text.lineHeightDown" = "Regelafstand verkleinen"
+"text.lineHeightUp" = "Regelafstand vergroten"
+"text.link" = "Link maken"
+"text.listIndent" = "Lijst inspringen"
+"text.listOutdent" = "Inspringing lijst verkleinen"
+"text.listStyle" = "Lijststijl"
+"text.maxLines" = "Maximaal aantal regels"
+"text.numberList" = "Genummerde lijst"
+"text.onPath" = "Tekst op pad"
+"text.paragraphIndent" = "Alinea-inspringing"
+"text.paragraphSpacing" = "Alinea-afstand"
+"text.pathOptions" = "Opties voor tekstpad"
+"text.preview" = "Tekstwijziging voorvertonen"
+"text.removeFromPath" = "Tekst van pad verwijderen"
+"text.set" = "Tekst instellen"
+"text.setFeatures" = "OpenType-functies"
+"text.setVariations" = "Assen van variabele lettertypen"
+"text.sizeDown" = "Lettergrootte verkleinen"
+"text.sizeUp" = "Lettertypegrootte vergroten"
+"text.strikethrough" = "Doorstrepen"
+"text.style" = "Tekstbereik opmaken"
+"text.trackingDown" = "Letterafstand verkleinen"
+"text.trackingUp" = "Letterafstand vergroten"
+"text.underline" = "Onderstrepen"
+"text.weightDown" = "Lettertypedikte verkleinen"
+"text.weightUp" = "Letterdikte vergroten"
+"tool.arrow" = "Pijl"
+"tool.comment" = "Reactie"
+"tool.connector" = "Verbinding"
+"tool.ellipse" = "Ellips"
+"tool.eraser" = "Gum"
+"tool.frame" = "Frame"
+"tool.hand" = "Hand"
+"tool.highlighter" = "Markeerstift"
+"tool.line" = "Lijn"
+"tool.marker" = "Stift"
+"tool.move" = "Verplaatsen"
+"tool.pen" = "Pen"
+"tool.pencil" = "Potlood"
+"tool.pencilBrush" = "Potloodpenseel"
+"tool.place" = "Plaatsen met de tool"
+"tool.polygon" = "Veelhoek"
+"tool.rectangle" = "Rechthoek"
+"tool.scale" = "Schalen"
+"tool.scaleAnchor" = "Schaalanker"
+"tool.section" = "Sectie"
+"tool.set" = "Gereedschap kiezen"
+"tool.shape" = "Vormen"
+"tool.shapeBuilder" = "Shape builder"
+"tool.slice" = "Slice"
+"tool.stamp" = "Stempel"
+"tool.star" = "Ster"
+"tool.sticky" = "Plakbriefje"
+"tool.text" = "Tekst"
+"transform.move" = "Verplaatsen"
+"transform.moveTo" = "Verplaatsen naar"
+"transform.nudge" = "Verschuiven"
+"transform.nudgeSize" = "Formaat wijzigen in stappen"
+"transform.resize" = "Formaat wijzigen"
+"transform.rotate" = "Draaien"
+"transform.rotationOrigin" = "Rotatiepunt verplaatsen"
+"transform.scale" = "Schalen"
+"transform.setRotationOrigin" = "Rotatiepunt instellen"
+"variable.addMode" = "Modus toevoegen"
+"variable.bind" = "Variabele koppelen"
+"variable.create" = "Variabele maken"
+"variable.createCollection" = "Variabeleverzameling maken"
+"variable.delete" = "Variabele verwijderen"
+"variable.deleteCollection" = "Verzameling verwijderen"
+"variable.duplicate" = "Variabele dupliceren"
+"variable.export" = "Variabelen exporteren"
+"variable.import" = "Variabelen importeren"
+"variable.list" = "Variabelen weergeven"
+"variable.moveMode" = "Modus verplaatsen"
+"variable.removeMode" = "Modus verwijderen"
+"variable.renameCollection" = "Verzameling hernoemen"
+"variable.renameMode" = "Modus hernoemen"
+"variable.resetOverride" = "Overschrijving van variabele resetten"
+"variable.set" = "Variabelewaarde instellen"
+"variable.setMode" = "Variabelemodus instellen"
+"variable.update" = "Variabele bewerken"
+"vector.create" = "Vector"
+"vector.deleteHeal" = "Selectie verwijderen en herstellen"
+"vector.edit.addVertex" = "Punt toevoegen"
+"vector.edit.begin" = "Vector bewerken"
+"vector.edit.bend" = "Segment buigen"
+"vector.edit.bounds" = "Grenzen van geselecteerde punten"
+"vector.edit.connect" = "Punten verbinden"
+"vector.edit.cornerRadius" = "Hoekradius van punt"
+"vector.edit.cut" = "Pad knippen"
+"vector.edit.delete" = "Punten verwijderen"
+"vector.edit.end" = "Klaar met bewerken"
+"vector.edit.erase" = "Wissen"
+"vector.edit.lasso" = "Met lasso selecteren"
+"vector.edit.mirroring" = "Handgrepen spiegelen"
+"vector.edit.moveHandles" = "Handgrepen verplaatsen"
+"vector.edit.moveVertices" = "Punten verplaatsen"
+"vector.edit.nudge" = "Punten verschuiven"
+"vector.edit.paint" = "Verfemmer"
+"vector.edit.pen" = "Penpunt"
+"vector.edit.penEnd" = "Penpad beëindigen"
+"vector.edit.position" = "Puntpositie"
+"vector.edit.resize" = "Formaat van punten wijzigen"
+"vector.edit.rotate" = "Punten draaien"
+"vector.edit.select" = "Punten selecteren"
+"vector.edit.selectAll" = "Alle punten selecteren"
+"vector.edit.setHandle" = "Handgreep instellen"
+"vector.edit.smooth" = "Punten glad of scherp maken"
+"vector.edit.state" = "Status van vectorbewerking"
+"vector.edit.strokeCap" = "Lijneinde van punt"
+"vector.edit.strokeJoin" = "Lijnaansluiting van punt"
+"vector.edit.tool" = "Tool voor vectorbewerking"
+"vector.edit.transform" = "Punten transformeren"
+"vector.edit.widthPoint" = "Breedtepunt"
+"vector.flatten" = "Afvlakken"
+"vector.join" = "Selectie samenvoegen"
+"vector.offset" = "Pad offsetten"
+"vector.outlineStroke" = "Lijn omzetten naar contouren"
+"vector.reverse" = "Padrichting omkeren"
+"vector.simplify" = "Vector vereenvoudigen"
+"vector.smoothJoin" = "Selectie vloeiend samenvoegen"
+"version.autosave" = "Versie automatisch opslaan"
+"version.delete" = "Versie verwijderen"
+"version.duplicate" = "Versie dupliceren"
+"version.exitPreview" = "Terug naar huidige versie"
+"version.list" = "Versies weergeven"
+"version.preview" = "Versie bekijken"
+"version.rename" = "Versie hernoemen"
+"version.restore" = "Versie terugzetten"
+"view.assets" = "Assetpaneel"
+"view.comments" = "Reacties"
+"view.contextMenu" = "Contextmenu tonen"
+"view.design" = "Ontwerppaneel"
+"view.designPrototype" = "Wisselen tussen Design en Prototype"
+"view.devMode" = "Dev Mode"
+"view.frameOutlines" = "Framecontouren"
+"view.fullscreen" = "Volledig scherm"
+"view.get" = "Weergave ophalen"
+"view.layers" = "Lagenpaneel"
+"view.layoutGrids" = "Layoutrasters"
+"view.leftSidebar" = "Linkerzijbalk tonen/verbergen"
+"view.maskOutlines" = "Maskercontouren"
+"view.multiplayerCursors" = "Multiplayer-cursors"
+"view.nextFrame" = "Inzoomen op volgend frame"
+"view.nextPage" = "Volgende pagina"
+"view.nextRegion" = "Volgend gebied focussen"
+"view.outlines" = "Contouren"
+"view.outlinesHiddenLayers" = "Verborgen lagen opnemen in contouren"
+"view.outlinesObjectBounds" = "Objectgrenzen opnemen in contouren"
+"view.outlinesSelection" = "Contouren voor selectie"
+"view.pan" = "Weergave verschuiven"
+"view.panelWidths" = "Paneelbreedtes herstellen"
+"view.pixelGrid" = "Pixelraster"
+"view.pixelPreview" = "Pixelvoorvertoning"
+"view.prevFrame" = "Inzoomen op vorig frame"
+"view.prevPage" = "Vorige pagina"
+"view.previousRegion" = "Vorige regio focussen"
+"view.proofSrgb" = "sRGB-proefweergave"
+"view.prototype" = "Prototypepaneel"
+"view.rulers" = "Linialen"
+"view.set" = "Weergave instellen"
+"view.slices" = "Slices"
+"view.snapGeometry" = "Uitlijnen op geometrie"
+"view.snapObjects" = "Uitlijnen op objecten"
+"view.snapPixel" = "Uitlijnen op pixelraster"
+"view.themeDark" = "Donker thema"
+"view.themeLight" = "Licht thema"
+"view.themeSystem" = "Systeemthema volgen"
+"view.toggleUi" = "UI tonen/verbergen"
+"view.zoom100" = "Inzoomen op 100%"
+"view.zoom200" = "Zoomen naar 200%"
+"view.zoom50" = "Zoom instellen op 50%"
+"view.zoomAt" = "Zoomgereedschap"
+"view.zoomFit" = "Inpassen"
+"view.zoomIn" = "Inzoomen"
+"view.zoomOut" = "Uitzoomen"
+"view.zoomSelection" = "Inzoomen op selectie"
+"widget.click" = "Op widget klikken"
+"widget.insert" = "Widget invoegen"
+"widget.list" = "Widgets weergeven"
+"window.focus" = "Venster naar voren brengen"
+"window.new" = "Nieuw venster"
+
+[menu]
+"bool.exclude" = "Exclude"
+"bool.flatten" = "Flatten"
+"bool.intersect" = "Intersect"
+"bool.subtract" = "Subtract"
+"bool.union" = "Union"
+"file.duplicate" = "Dupliceren"
+"file.import" = "Importeren uit bestand…"
+"file.rename" = "Hernoemen"
+"libraries.open" = "Bibliotheken openen"
+"select.sameEffect" = "Effect"
+"select.sameFill" = "Vulling"
+"select.sameFont" = "Lettertype"
+"select.sameInstance" = "Instance"
+"select.sameProperties" = "Eigenschappen"
+"select.sameStroke" = "Lijn"
+"select.sameText" = "Teksteigenschappen"
+"text.alignCenter" = "Tekst centreren"
+"text.alignJustify" = "Tekst uitvullen"
+"text.alignLeft" = "Tekst links uitlijnen"
+"text.alignRight" = "Tekst rechts uitlijnen"
+"view.assets" = "Assets"
+"view.design" = "Ontwerp"
+"view.layers" = "Lagen"
+"view.outlines" = "Omtrekken weergeven"
+"view.outlinesHiddenLayers" = "Verborgen lagen meenemen"
+"view.outlinesObjectBounds" = "Objectgrenzen meenemen"
+"view.outlinesSelection" = "Omtrekken van selectie weergeven"
+"view.prototype" = "Prototype"
+"view.themeDark" = "Donker"
+"view.themeLight" = "Licht"
+"view.themeSystem" = "Systeem volgen"
diff --git a/crates/ui-egui/locales/pl.toml b/crates/ui-egui/locales/pl.toml
new file mode 100644
index 000000000..7f301a6ea
--- /dev/null
+++ b/crates/ui-egui/locales/pl.toml
@@ -0,0 +1,2386 @@
+# FigCraft interface strings: Polish.
+#
+# Draft: machine-drafted, waiting for a native speaker's review.
+
+[meta]
+name = "Polski"
+status = "draft — needs native review"
+
+[ui]
+"% of all commits" = "% wszystkich commitów"
+"(no longer published)" = "(już niepublikowane)"
+"({n} warnings: some entries were skipped)" = { one = "({n} ostrzeżenie: niektóre wpisy zostały pominięte)", few = "({n} ostrzeżenia: niektóre wpisy zostały pominięte)", many = "({n} ostrzeżeń: niektóre wpisy zostały pominięte)", other = "({n} ostrzeżeń: niektóre wpisy zostały pominięte)" }
+"+ Create variable" = "+ Utwórz zmienną"
+".fig (experimental)" = ".fig (eksperymentalny)"
+"1…9, 0" = "1…9, 0"
+"@{login}: {prs} PRs, {commits} commits, +{added} / −{deleted} lines (Δ {delta}), +{bin_added} / −{bin_deleted} binary assets, {first} – {last}" = "@{login}: PR: {prs}, commitów: {commits}, +{added} / −{deleted} wierszy (Δ {delta}), +{bin_added} / −{bin_deleted} zasobów binarnych, {first} – {last}"
+"A collection of this file with these modes and variables: override their values per mode and add variables of its own" = "Kolekcja tego pliku z tymi trybami i zmiennymi: nadpisuj ich wartości dla poszczególnych trybów i dodawaj własne zmienne"
+"A .figcraft file with this name already exists. Choose its full name to confirm replacement." = "Plik .figcraft o tej nazwie już istnieje. Wybierz pełną nazwę, aby potwierdzić zastąpienie."
+"A layer on its own aligns to its frame: select more layers, or one in a frame" = "Pojedyncza warstwa wyrównuje się do swojej ramki: zaznacz więcej warstw lub warstwę w ramce"
+"A responsive product page: hero, features, figures, a quote and a footer" = "Responsywna strona produktu: sekcja hero, funkcje, statystyki, cytat i stopka"
+"A spring plays until it settles: its mass, stiffness and damping set how long" = "Animacja sprężynowa trwa do ustabilizowania: jej masa, sztywność i tłumienie określają czas"
+"A title, an agenda, a big figure, a chart and a closing slide" = "Tytuł, agenda, wyróżniona liczba, wykres i slajd końcowy"
+"A to Z" = "Od A do Z"
+"About" = "O programie"
+"About FigCraft" = "O programie FigCraft"
+"About this server" = "O tym serwerze"
+"Action" = "Akcja"
+"Actions" = "Akcje"
+"Actions for {name}" = "Akcje dla: {name}"
+"Actions…" = "Akcje…"
+"Active" = "Aktywny"
+"Actual size (100%)" = "Rozmiar rzeczywisty (100%)"
+"Add a category" = "Dodaj kategorię"
+"Add a comment" = "Dodaj komentarz"
+"Add a description" = "Dodaj opis"
+"Add a frame (F) or a shape (R) to get started" = "Dodaj ramkę (F) lub kształt (R), aby rozpocząć"
+"Add a layer or component to tile first" = "Najpierw dodaj warstwę lub komponent do powielenia"
+"Add a note for developers" = "Dodaj notatkę dla programistów"
+"Add action" = "Dodaj akcję"
+"Add actions for when no condition holds" = "Dodaj akcje wykonywane, gdy żaden warunek nie jest spełniony"
+"Add an annotation for developers" = "Dodaj adnotację dla programistów"
+"Add another condition" = "Dodaj kolejny warunek"
+"Add auto layout" = "Dodaj Auto layout"
+"Add background behind overlay" = "Dodaj tło za nakładką"
+"Add content to this slot" = "Dodaj zawartość do tego gniazda"
+"Add dev resource" = "Dodaj zasób programistyczny"
+"Add effect" = "Dodaj efekt"
+"Add export setting" = "Dodaj ustawienie eksportu"
+"Add fill" = "Dodaj wypełnienie"
+"Add interaction" = "Dodaj interakcję"
+"Add layout grid" = "Dodaj siatkę układu"
+"Add library" = "Dodaj bibliotekę"
+"Add library file…" = "Dodaj plik biblioteki…"
+"Add max height" = "Dodaj maksymalną wysokość"
+"Add max width" = "Dodaj maksymalną szerokość"
+"Add min height" = "Dodaj minimalną wysokość"
+"Add min width" = "Dodaj minimalną szerokość"
+"Add mode" = "Dodaj tryb"
+"Add new page" = "Dodaj nową stronę"
+"Add or update collections from a variables JSON" = "Dodaj lub zaktualizuj kolekcje z pliku JSON ze zmiennymi"
+"Add properties to make instances configurable" = "Dodaj właściwości, aby umożliwić konfigurację instancji"
+"Add reaction" = "Dodaj reakcję"
+"Add starting point" = "Dodaj punkt startowy"
+"Add stroke" = "Dodaj obrys"
+"Add variant" = "Dodaj wariant"
+"Add variant with a new value" = "Dodaj wariant z nową wartością"
+"Added" = "Dodano"
+"Added the library \"{name}\"" = "Dodano bibliotekę „{name}”"
+"Adding to {name}" = "Dodawanie do: {name}"
+"Adjust" = "Dopasowanie"
+"Adjustment presets" = "Presety korekt"
+"Advanced" = "Zaawansowane"
+"Advanced stroke" = "Zaawansowany obrys"
+"After delay" = "Po opóźnieniu"
+"After delay {ms}ms" = "Po opóźnieniu {ms} ms"
+"Align" = "Wyrównaj"
+"Align bottom" = "Wyrównaj do dołu"
+"Align center" = "Wyrównaj do środka"
+"Align horizontal centers" = "Wyrównaj poziomo do środka"
+"Align left" = "Wyrównaj do lewej"
+"Align middle" = "Wyrównaj do środka pionowo"
+"Align right" = "Wyrównaj do prawej"
+"Align text baselines" = "Wyrównaj do linii bazowych tekstu"
+"Align top" = "Wyrównaj do góry"
+"Align vertical centers" = "Wyrównaj pionowo do środka"
+"Alignment" = "Wyrównanie"
+"All" = "Wszystko"
+"All categories" = "Wszystkie kategorie"
+"All comments" = "Wszystkie komentarze"
+"All components" = "Wszystkie komponenty"
+"All fonts" = "Wszystkie czcionki"
+"All supported properties" = "Wszystkie obsługiwane właściwości"
+"All the fonts this file uses are installed" = "Wszystkie czcionki używane w tym pliku są zainstalowane"
+"All variables" = "Wszystkie zmienne"
+"Alpha" = "Alfa"
+"Alphabetical" = "Alfabetycznie"
+"Alt+drag" = "Alt+przeciągnięcie"
+"An analytics screen on a grid: figures, charts drawn from vectors and a table" = "Ekran analityczny na siatce: wykresy wektorowe, liczby i tabela"
+"An invite link that opens FigCraft and joins" = "Link z zaproszeniem otwierający FigCraft i dołączający do sesji"
+"Anchor" = "Punkt zaczepienia"
+"Android" = "Android"
+"Angular" = "Kątowy"
+"Animation" = "Animacja"
+"Annotations" = "Adnotacje"
+"Annotations shown on the canvas" = "Adnotacje widoczne na płótnie"
+"Another server, or one that needs its key. The usual server is set in Preferences." = "Inny serwer lub serwer wymagający klucza. Domyślny serwer konfiguruje się w Preferencjach."
+"Any status" = "Dowolny status"
+"Anyone on your network with this code can edit the file, while this app stays open." = "Każdy w Twojej sieci z tym kodem może edytować plik, dopóki ta aplikacja pozostaje otwarta."
+"Anyone with the edit link can change the file; the view link only lets people look. The links carry their secrets: share them like passwords. `figcraft-server links` makes more and revokes them." = "Każdy z linkiem do edycji może modyfikować plik; link do podglądu pozwala tylko oglądać. Linki zawierają tokeny: traktuj je jak hasła. Polecenie `figcraft-server links` tworzy i unieważnia linki."
+"Anyone with this code can edit the file." = "Każdy z tym kodem może edytować plik."
+"Anyone with this code can look at the file, not change it." = "Każdy z tym kodem może przeglądać plik bez możliwości zmian."
+"Appearance" = "Wygląd"
+"Apply a component property" = "Zastosuj właściwość komponentu"
+"Apply variable" = "Zastosuj zmienną"
+"Apply variable to text" = "Zastosuj zmienną do tekstu"
+"Apply variable to visibility" = "Zastosuj zmienną do widoczności"
+"Apps" = "Aplikacje"
+"Apr" = "Kwi"
+"Arc" = "Łuk"
+"Arc ratio" = "Proporcja łuku"
+"Arc start" = "Początek łuku"
+"Arc sweep" = "Rozpiętość łuku"
+"Archive" = "Zarchiwizuj"
+"Archived" = "Zarchiwizowano"
+"Arrange" = "Ułóż"
+"Arrow" = "Strzałka"
+"Arrow at the end" = "Strzałka na końcu"
+"As typed" = "Zgodnie z wpisanym"
+"Asking the server…" = "Odpytywanie serwera…"
+"Assets" = "Zasoby"
+"Aug" = "Sie"
+"Auto" = "Automatycznie"
+"Auto (space around)" = "Automatycznie (odstęp dookoła)"
+"Auto (space between)" = "Automatycznie (odstęp między)"
+"Auto (space evenly)" = "Automatycznie (równy odstęp)"
+"Auto ({mode})" = "Automatycznie ({mode})"
+"Auto columns" = "Automatyczne kolumny"
+"Auto gap" = "Automatyczny odstęp"
+"Auto height" = "Automatyczna wysokość"
+"Auto layout" = "Automatyczny układ"
+"Auto rows" = "Automatyczne wiersze"
+"Auto width" = "Automatyczna szerokość"
+"Back to the FigCraft server" = "Powrót do serwera FigCraft"
+"Back to the font's value" = "Powrót do wartości czcionki"
+"Back" = "Tył"
+"Back to Ready for dev" = "Powrót do Gotowe do wdrożenia"
+"Back to Ready for dev: the next change compares with how it is now" = "Powrót do Gotowe do wdrożenia: kolejna zmiana zostanie porównana ze stanem obecnym"
+"Back to assets" = "Powrót do zasobów"
+"Back to current" = "Powrót do bieżącej"
+"Back to styles" = "Powrót do stylów"
+"Back to the canvas from a focused region" = "Powrót do płótna z wybranego obszaru"
+"Back to the current version" = "Powrót do bieżącej wersji"
+"Back to the values the font style implies" = "Powrót do wartości wynikających ze stylu czcionki"
+"Background" = "Tło"
+"Background blur" = "Rozmycie tła"
+"Basics" = "Podstawy"
+"Before" = "Przed"
+"Bend" = "Wygnij"
+"Bevel" = "Ścięte"
+"Binary assets added" = "Dodane pliki binarne"
+"Binary assets removed" = "Usunięte pliki binarne"
+"Black & white" = "Czerń i biel"
+"Bleed" = "Spad"
+"Bleed marks" = "Znaczniki spadu"
+"Bleed marks need a bleed" = "Znaczniki spadu wymagają zdefiniowania spadu"
+"Blend" = "Mieszanie"
+"Blend mode" = "Tryb mieszania"
+"Blue" = "Niebieski"
+"Blur" = "Rozmycie"
+"Boolean" = "Wartość logiczna"
+"Boolean groups" = "Grupy logiczne (Boolean)"
+"Both directions" = "W obu kierunkach"
+"Bottom" = "Dół"
+"Bottom left radius" = "Promień lewego dolnego narożnika"
+"Bottom right radius" = "Promień prawego dolnego narożnika"
+"Branch" = "Gałąź"
+"Branch archived" = "Gałąź zarchiwizowana"
+"Branch merged" = "Gałąź scalona"
+"Branch name" = "Nazwa gałęzi"
+"Branch of {file}" = "Gałąź pliku {file}"
+"Branch of {file} · merged or archived" = "Gałąź pliku {file} · scalona lub zarchiwizowana"
+"Branch updated from main" = "Gałąź zaktualizowana z głównej"
+"Branch {name}" = "Gałąź {name}"
+"Branches" = "Gałęzie"
+"Bound to {name}. Click to detach the variable." = "Powiązano z: {name}. Kliknij, aby odłączyć zmienną."
+"Bring forward" = "Przenieś do przodu"
+"Bring the main file's changes into the branch" = "Pobierz zmiany z pliku głównego do gałęzi"
+"Bring to front" = "Przenieś na wierzch"
+"Bristle" = "Włosiankowy"
+"Browse" = "Przeglądaj"
+"Brush" = "Pędzel"
+"Brush rotation jitter" = "Fluktuacja obrotu pędzla"
+"Brush scatter" = "Rozrzut pędzla"
+"Brush size jitter" = "Fluktuacja rozmiaru pędzla"
+"Brush spacing" = "Odstęp pędzla"
+"Bulleted list" = "Lista punktowana"
+"C or Shift+C" = "C lub Shift+C"
+"C or ⇧C" = "C lub ⇧C"
+"CMYK colour" = "Kolor CMYK"
+"Can view" = "Może przeglądać"
+"Check" = "Ptaszek"
+"Checking the fonts installed on this computer…" = "Sprawdzanie czcionek zainstalowanych na tym komputerze…"
+"Checking the server…" = "Sprawdzanie serwera…"
+"Chevron" = "Szewron"
+"Clear from this list" = "Usuń z tej listy"
+"Code or invite link" = "Kod lub link z zaproszeniem"
+"Color profile: {name}" = "Profil kolorów: {name}"
+"Colour and text styles, Light and Dark variables, buttons, inputs and cards" = "Style kolorów i tekstu, zmienne Jasne i Ciemne, przyciski, pola wprowadzania i karty"
+"Connector" = "Łącznik"
+"Convert to frame" = "Konwertuj na ramkę"
+"Convert to section" = "Konwertuj na sekcję"
+"CSS custom properties…" = "Właściwości niestandardowe CSS…"
+"Can edit" = "Może edytować"
+"Can't read this library: {e}" = "Nie można odczytać tej biblioteki: {e}"
+"Cancel" = "Anuluj"
+"Canvas" = "Płótno"
+"Canvas stacking" = "Kolejność na płótnie"
+"Cap height to baseline" = "Wysokość wersalików do linii bazowej"
+"Case" = "Wielkość liter"
+"Case-sensitive forms" = "Formy zależne od wielkości liter"
+"Categories" = "Kategorie"
+"Center" = "Środek"
+"Change alias" = "Zmień alias"
+"Change resolved" = "Zmiana rozwiązana"
+"Change style" = "Zmień styl"
+"Change to" = "Zmień na"
+"Change to needs a layer inside a variant" = "Opcja Zmień na wymaga warstwy wewnątrz wariantu"
+"Changed" = "Zmieniono"
+"Changed on both sides: keep one" = "Zmieniono po obu stronach: zachowaj jedną wersję"
+"Changes on main" = "Zmiany w gałęzi głównej"
+"Changes on the branch" = "Zmiany w gałęzi"
+"Changes unknown" = "Nieznane zmiany"
+"Choose React, Leptos, SwiftUI or Compose above to connect this component to its code." = "Wybierz React, Leptos, SwiftUI lub Compose powyżej, aby połączyć ten komponent z jego kodem."
+"Choose another profile to change it." = "Wybierz inny profil, aby go zmienić."
+"Choose collection" = "Wybierz kolekcję"
+"Choose image" = "Wybierz obraz"
+"Choose mode" = "Wybierz tryb"
+"Choose variable" = "Wybierz zmienną"
+"Circle" = "Koło"
+"Clear recent" = "Wyczyść ostatnie"
+"Click + to replace mixed content" = "Kliknij +, aby zastąpić zawartość mieszaną"
+"Click anywhere on the canvas to leave one." = "Kliknij w dowolnym miejscu na płótnie, aby zostawić komentarz."
+"Click or drag to merge · {alt} removes" = "Kliknij lub przeciągnij, aby scalić · {alt} usuwa"
+"Click or drag to remove · {alt} merges" = "Kliknij lub przeciągnij, aby usunąć · {alt} scala"
+"Click to record a key" = "Kliknij, aby zarejestrować klawisz"
+"Clip content" = "Przycinaj zawartość"
+"Clip to shape" = "Przytnij do kształtu"
+"Close" = "Zamknij"
+"Close overlay" = "Zamknij nakładkę"
+"Close preview" = "Zamknij podgląd"
+"Close tab" = "Zamknij kartę"
+"Close version history" = "Zamknij historię wersji"
+"Close when clicking outside" = "Zamknij przy kliknięciu poza obszarem"
+"Code" = "Kod"
+"Code syntax" = "Składnia kodu"
+"Collapse" = "Zwiń"
+"Collapse panel" = "Zwiń panel"
+"Collection" = "Kolekcja"
+"Collections" = "Kolekcje"
+"Color" = "Kolor"
+"Color burn" = "Ściemnianie"
+"Color dodge" = "Rozjaśnianie"
+"Color format" = "Format koloru"
+"Color profile" = "Profil kolorów"
+"Color styles" = "Style kolorów"
+"Color values in this file are in this color space." = "Wartości kolorów w tym pliku są w tej przestrzeni kolorów."
+"Color variables" = "Zmienne koloru"
+"Colour" = "Kolor"
+"Column" = "Kolumna"
+"Column gap" = "Odstęp kolumn"
+"Column sizes" = "Rozmiary kolumn"
+"Column span" = "Rozpiętość kolumn"
+"Columns" = "Kolumny"
+"Columns {count}" = "Kolumny: {count}"
+"Comment" = "Komentarz"
+"Comments" = "Komentarze"
+"Commits" = "Commity"
+"Company" = "Firma"
+"Compare changes" = "Porównaj zmiany"
+"Compatibility notes" = "Uwagi dotyczące zgodności"
+"Completed" = "Ukończone"
+"Component" = "Komponent"
+"Component name" = "Nazwa komponentu"
+"Component property" = "Właściwość komponentu"
+"Component set" = "Zestaw komponentów"
+"Component sets" = "Zestawy komponentów"
+"Components" = "Komponenty"
+"Conditional" = "Warunek (Conditional)"
+"Confetti" = "Konfetti"
+"Conflicts" = "Konflikty"
+"Connect to code" = "Połącz z kodem"
+"Connected" = "Połączono"
+"Connected to code: {from}" = "Połączono z kodem: {from}"
+"Connection lost, reconnecting (attempt {attempt})…" = "Utracono połączenie, ponowne łączenie (próba {attempt})…"
+"Constrain proportions" = "Zachowaj proporcje"
+"Constraints" = "Więzy"
+"Content" = "Zawartość"
+"Contents hidden" = "Zawartość ukryta"
+"Contents only" = "Tylko zawartość"
+"Contextual alternates" = "Alternatywy kontekstowe"
+"Contrast" = "Kontrast"
+"Contributors" = "Współtwórcy"
+"Contributors: {people} · Commits: {commits}" = "Współtwórcy: {people} · Commity: {commits}"
+"Controller" = "Kontroler"
+"Cool" = "Chłodny"
+"Copied as CSS" = "Skopiowano jako CSS"
+"Copied as PNG" = "Skopiowano jako PNG"
+"Copied as SVG" = "Skopiowano jako SVG"
+"Copied as text" = "Skopiowano jako tekst"
+"Copied {value}" = "Skopiowano {value}"
+"Copy" = "Kopiuj"
+"Copy as" = "Kopiuj jako"
+"Copy as CSS" = "Kopiuj jako CSS"
+"Copy as PNG" = "Kopiuj jako PNG"
+"Copy as SVG" = "Kopiuj jako SVG"
+"Copy code" = "Kopiuj kod"
+"Copy link" = "Kopiuj link"
+"Copy the {label}" = "Kopiuj {label}"
+"Copy {value}" = "Kopiuj {value}"
+"Corner radius" = "Zaokrąglenie rogów"
+"Corner smoothing" = "Wygładzanie narożników (Corner smoothing)"
+"Couldn't download the variables" = "Nie udało się pobrać zmiennych"
+"Couldn't reach {server}: showing what this computer remembers." = "Nie udało się połączyć z {server}: pokazywanie zawartości zapamiętanej przez ten komputer."
+"Couldn't read {name}." = "Nie udało się odczytać pliku {name}."
+"Couldn't save automatically: {error}" = "Nie udało się zapisać automatycznie: {error}"
+"Count" = "Licznik"
+"Create" = "Utwórz"
+"Create a variable collection first" = "Najpierw utwórz kolekcję zmiennych"
+"Create a variable first" = "Najpierw utwórz zmienną"
+"Create alias" = "Utwórz alias"
+"Create branch" = "Utwórz gałąź"
+"Create collection" = "Utwórz kolekcję"
+"Create component" = "Utwórz komponent"
+"Create component property" = "Utwórz właściwość komponentu"
+"Create components, styles or variables to publish them as a library." = "Twórz komponenty, style lub zmienne, aby opublikować je jako bibliotekę."
+"Create property…" = "Utwórz właściwość…"
+"Create style" = "Utwórz styl"
+"Create style from the selected text" = "Utwórz styl z zaznaczonego tekstu"
+"Created" = "Utworzono"
+"Crop" = "Przytnij"
+"Crop marks" = "Znaczniki przycięcia"
+"Ctrl+arrows" = "Ctrl+strzałki"
+"Ctrl+click" = "Ctrl+kliknięcie"
+"Ctrl+scroll" = "Ctrl+przewijanie"
+"Current name" = "Bieżąca nazwa"
+"Current version" = "Bieżąca wersja"
+"Cursor chat" = "Czat kursora"
+"Custom" = "Niestandardowy"
+"Custom size" = "Rozmiar niestandardowy"
+"Cut" = "Wytnij"
+"Dark" = "Ciemny"
+"Darken" = "Ciemniej"
+"Dash" = "Kreska"
+"Dashboard" = "Pulpit"
+"Date created" = "Data utworzenia"
+"Dec" = "Gru"
+"Decoration style" = "Styl dekoracji"
+"Decoration" = "Dekoracja tekstu"
+"Deep select" = "Głębokie zaznaczanie"
+"Default" = "Domyślne"
+"Default content" = "Domyślna zawartość"
+"Default value (the top-left variant)" = "Wartość domyślna (lewy górny wariant)"
+"Delay" = "Opóźnienie"
+"Delete" = "Usuń"
+"Delete category (its annotations stay)" = "Usuń kategorię (jej adnotacje pozostaną)"
+"Delete collection" = "Usuń kolekcję"
+"Delete group" = "Usuń grupę"
+"Delete mode" = "Usuń tryb"
+"Delete page" = "Usuń stronę"
+"Delete preset" = "Usuń ustawienie"
+"Delete property" = "Usuń właściwość"
+"Delete the style (layers keep their values)" = "Usuń styl (warstwy zachowają swoje wartości)"
+"Delete thread" = "Usuń wątek"
+"Delete variable" = "Usuń zmienną"
+"Delete “{name}”? This can't be undone." = "Usunąć „{name}”? Tej operacji nie można cofnąć."
+"Density" = "Gęstość"
+"Depth" = "Głębia"
+"Describe how and when to use this component" = "Opisz sposób i warunki użycia tego komponentu"
+"Describe what changed" = "Opisz wprowadzone zmiany"
+"Description" = "Opis"
+"Description (optional)" = "Opis (opcjonalnie)"
+"Design" = "Projektowanie"
+"Design panel" = "Panel projektu"
+"Design system starter" = "Pakiet startowy systemu projektowego (Design System)"
+"Desktop" = "Pulpit"
+"Destination" = "Miejsce docelowe"
+"Detach alias" = "Odłącz alias"
+"Detach instance" = "Odłącz instancję"
+"Detach property" = "Odłącz właściwość"
+"Detach style" = "Odłącz styl"
+"Detach styles" = "Odłącz style"
+"Detach variable" = "Odłącz zmienną"
+"Details" = "Szczegóły"
+"Dev Mode" = "Tryb deweloperski"
+"Dev resources" = "Zasoby programistyczne"
+"Development" = "Programowanie"
+"Device" = "Urządzenie"
+"Device at 100%" = "Urządzenie w 100%"
+"Diamond" = "Rombowy"
+"Difference" = "Różnica"
+"Dimensions" = "Wymiary"
+"Direction" = "Kierunek"
+"Disconnect from code" = "Odłącz od kodu"
+"Dispersion" = "Dyspersja"
+"Display name" = "Nazwa wyświetlana"
+"Dissolve" = "Rozpuszczanie"
+"Distribute and tidy" = "Rozmieść i uporządkuj"
+"Distribute horizontal spacing" = "Rozmieść poziomo"
+"Distribute vertical spacing" = "Rozmieść pionowo"
+"Divider" = "Rozdzielacz"
+"Don't Save" = "Nie zapisuj"
+"Don't truncate" = "Nie obcinaj tekstu"
+"Done" = "Gotowe"
+"Done editing" = "Zakończ edycję"
+"Dots" = "Kropki"
+"Dotted" = "Kropkowany"
+"Down" = "W dół"
+"Drafts" = "Szkice"
+"Drag the stroke to add a width point" = "Przeciągnij obrys, aby dodać punkt szerokości"
+"Draw" = "Rysuj"
+"Draw a frame" = "Narysuj ramkę"
+"Drawing tools" = "Narzędzia rysowania"
+"Drop a .figcraft, .fig, .json, .svg or image file." = "Upuść plik .figcraft, .fig, .json, .svg lub plik obrazu."
+"Drop to import" = "Upuść, aby zaimportować"
+"Drop to open" = "Upuść, aby otworzyć"
+"Drop shadow" = "Cień"
+"Dual-licensed MIT OR Apache-2.0. Made by the ArtCraft team and community." = "Podwójna licencja MIT LUB Apache-2.0. Stworzone przez zespół ArtCraft i społeczność."
+"Duo" = "Duet"
+"Duplicate" = "Powiel"
+"Duplicate by dragging" = "Powiel przez przeciągnięcie"
+"Duplicate mode" = "Powiel tryb"
+"Duplicate page" = "Powiel stronę"
+"Edit" = "Edycja"
+"Edit as an expression" = "Edytuj jako wyrażenie"
+"Edit colour" = "Edytuj kolor"
+"Edit comment" = "Edytuj komentarz"
+"Edit dev resource" = "Edytuj zasób programistyczny"
+"Edit link" = "Edytuj link"
+"Edit link copied" = "Skopiowano link do edycji"
+"Edit style" = "Edytuj styl"
+"Edit variable" = "Edytuj zmienną"
+"Edit with the builder" = "Edytuj za pomocą kreatora"
+"Edited {when}" = "Edytowano {when}"
+"Effect settings" = "Ustawienia efektów"
+"Effect styles" = "Style efektów"
+"Effects" = "Efekty"
+"Elbow" = "Łamany"
+"Ellipse" = "Elipsa"
+"Ellipses" = "Elipsy"
+"Else" = "W przeciwnym razie"
+"Else if" = "W przeciwnym razie jeśli"
+"Embedded profile" = "Wbudowany profil"
+"Empty" = "Puste"
+"End" = "End"
+"End point" = "Punkt końcowy"
+"Ends the session; everyone keeps their copy" = "Kończy sesję; każdy zachowuje swoją kopię"
+"Enter" = "Enter"
+"Enter the address of a figcraft-server and press Browse to see the plugins it offers." = "Wprowadź adres figcraft-server i kliknij Przeglądaj, aby zobaczyć dostępne wtyczki."
+"Enter to save · Esc to cancel" = "Enter, aby zapisać · Esc, aby anulować"
+"Eraser" = "Gumka"
+"Esc" = "Esc"
+"Essential" = "Podstawowe"
+"Every conflict has a choice." = "Każdy konflikt ma rozwiązanie do wyboru."
+"Every top-level frame already starts a flow" = "Każda ramka najwyższego poziomu rozpoczyna już przepływ"
+"Exact opacity (4 then 5: 45%)" = "Dokładna nieprzezroczystość (4, potem 5: 45%)"
+"Exclude" = "Wyklucz"
+"Excluded" = "Wykluczono"
+"Excluded from layout" = "Wykluczono z układu"
+"Excludes" = "Wyklucza"
+"Exclusion" = "Wykluczenie"
+"Exit focus view (Esc)" = "Wyjdź z widoku skupienia (Esc)"
+"Expand" = "Rozwiń"
+"Export" = "Eksportuj"
+"Export all" = "Eksportuj wszystko"
+"Export frames and layers as PNG, JPG, SVG or PDF" = "Eksportuj ramki i warstwy jako PNG, JPG, SVG lub PDF"
+"Export page as PNG" = "Eksportuj stronę jako PNG"
+"Export settings" = "Ustawienia eksportu"
+"Export variables" = "Eksportuj zmienne"
+"Export {name}" = "Eksportuj {name}"
+"Export {n} layers" = { one = "Eksportuj {n} warstwę", few = "Eksportuj {n} warstwy", many = "Eksportuj {n} warstw", other = "Eksportuj {n} warstw" }
+"Exported {file}" = "Wyeksportowano {file}"
+"Exported {name}" = "Wyeksportowano {name}"
+"Exported {name}; {n} kinds of content were left out" = { one = "Wyeksportowano {name}; pominięto {n} rodzaj zawartości", few = "Wyeksportowano {name}; pominięto {n} rodzaje zawartości", many = "Wyeksportowano {name}; pominięto {n} rodzajów zawartości", other = "Wyeksportowano {name}; pominięto {n} rodzajów zawartości" }
+"Exported {n} files" = { one = "Wyeksportowano {n} plik", few = "Wyeksportowano {n} pliki", many = "Wyeksportowano {n} plików", other = "Wyeksportowano {n} plików" }
+"Export…" = "Eksport…"
+"Expose properties to instances" = "Udostępnij właściwości instancjom"
+"Exposure" = "Czas naświetlania"
+"Expression" = "Wyrażenie"
+"Extend collection" = "Rozszerz kolekcję"
+"Extends \"{name}\": overridden values are marked" = "Rozszerza „{name}”: nadpisane wartości są oznaczone"
+"Eye" = "Oko"
+"F" = "F"
+"Fade" = "Zanikanie"
+"False" = "Fałsz"
+"Feb" = "Lut"
+"Fetching from the server…" = "Pobieranie z serwera…"
+"FigCraft couldn't open its window: {error}" = "FigCraft nie mógł otworzyć okna: {error}"
+"FigCraft doesn't support every feature of these files yet. The notes list what was left out or changed in the imported copy; the original file is unchanged." = "FigCraft nie obsługuje jeszcze wszystkich funkcji tych plików. Uwagi wymieniają elementy pominięte lub zmienione w zaimportowanej kopii; oryginalny plik pozostaje niezmieniony."
+"File" = "Plik"
+"File name" = "Nazwa pliku"
+"File not found" = "Nie znaleziono pliku"
+"File published" = "Plik został opublikowany"
+"Files aren't end-to-end encrypted: the server's operator can read them." = "Pliki nie są szyfrowane end-to-end: administrator serwera może je odczytać."
+"Files nobody opens for {n} days are deleted." = { one = "Pliki, których nikt nie otwiera przez {n} dzień, są usuwane.", few = "Pliki, których nikt nie otwiera przez {n} dni, są usuwane.", many = "Pliki, których nikt nie otwiera przez {n} dni, są usuwane.", other = "Pliki, których nikt nie otwiera przez {n} dni, są usuwane." }
+"Fill" = "Wypełnienie"
+"Fill (fr)" = "Wypełnienie (fr)"
+"Fill container" = "Wypełnij kontener"
+"Fill window" = "Wypełnij okno"
+"Fills" = "Wypełnienia"
+"Fill|sizing" = "Fill|sizing"
+"Filter and sort" = "Filtruj i sortuj"
+"Find" = "Znajdź"
+"Find and replace" = "Znajdź i zamień"
+"Find layers" = "Znajdź warstwy"
+"First" = "Pierwszy"
+"First commit" = "Pierwszy commit"
+"First on top" = "Pierwszy na wierzchu"
+"Fit" = "Dopasuj"
+"Fit device to window" = "Dopasuj urządzenie do okna"
+"Fit to contents" = "Dopasuj do zawartości"
+"Fit to window" = "Dopasuj do okna"
+"Fit width" = "Dopasuj szerokość"
+"Fixed" = "Stałe"
+"Fixed gap" = "Stały odstęp"
+"Fixed size" = "Stały rozmiar"
+"Flatten" = "Spłaszcz"
+"Flip" = "Odbij"
+"Flip horizontal" = "Odbij w poziomie"
+"Flip text to the other side" = "Przerzuć tekst na drugą stronę"
+"Flip vertical" = "Odbij w pionie"
+"Flip width profile" = "Odwróć profil szerokości"
+"Flow starting point" = "Punkt startowy przepływu"
+"Flow starting points" = "Punkty startowe przepływu"
+"Flows" = "Przepływy"
+"Focus view" = "Widok skupienia"
+"Fold autosaves" = "Zwiń automatyczne zapisy"
+"Folder: click to collapse" = "Folder: kliknij, aby zwinąć"
+"Folder: click to expand" = "Folder: kliknij, aby rozwinąć"
+"Follow" = "Obserwuj"
+"Follow {name}" = "Obserwuj: {name}"
+"Following" = "Obserwowanie"
+"Following {name} · {key} to stop" = "Obserwowanie {name} · {key}, aby zatrzymać"
+"Font" = "Czcionka"
+"Font not installed" = "Czcionka niezainstalowana"
+"Font size" = "Rozmiar czcionki"
+"Font style" = "Styl czcionki"
+"Forget on this computer" = "Zapomnij na tym komputerze"
+"Four screens of a trail app with components and a prototype flow" = "Cztery ekrany aplikacji z komponentami i przepływem prototypu"
+"Fractions" = "Ułamki"
+"Frame" = "Ramka"
+"Frame selection" = "Utwórz ramkę z zaznaczenia"
+"Frame tools" = "Narzędzia ramek"
+"Frames" = "Ramki"
+"From the library \"{name}\": read-only" = "Z biblioteki „{name}”: tylko do odczytu"
+"From {name}" = "Od {name}"
+"From {server}" = "Z serwera {server}"
+"Frost" = "Szron"
+"Gap" = "Odstęp"
+"Gap between columns" = "Odstęp między kolumnami"
+"Gap between items" = "Odstęp między elementami"
+"Gap between rows" = "Odstęp między wierszami"
+"Getting started" = "Pierwsze kroki"
+"Give the address of a server open to the public, or a server's address with its key (`figcraft-server key` prints it)." = "Podaj adres serwera publicznego lub adres serwera z jego kluczem (polecenie `figcraft-server key` go wyświetla)."
+"Glass" = "Szkło"
+"Go to main component" = "Przejdź do głównego komponentu"
+"Go to {name}" = "Przejdź do: {name}"
+"Grab bag" = "Lista dowolna"
+"Gradient" = "Gradient"
+"Gray" = "Szary"
+"Green" = "Zielony"
+"Greyscale components and two example screens to sketch a flow with" = "Komponenty w odcieniach szarości i dwa przykładowe ekrany do naszkicowania przepływu"
+"Grid" = "Siatka"
+"Grid ({size})" = "Siatka ({size})"
+"Grid styles" = "Style siatki"
+"Grid {size}" = "Siatka {size}"
+"Group" = "Grupa"
+"Group selection" = "Grupuj zaznaczenie"
+"Groups" = "Grupy"
+"Gutter" = "Odstęp"
+"Hand tool" = "Narzędzie Rączka"
+"Hanging list" = "Lista z wysunięciem"
+"Hanging punctuation" = "Wiszące znaki interpunkcyjne"
+"Hard light" = "Mocne światło"
+"Heart" = "Serce"
+"Height" = "Wysokość"
+"Help" = "Pomoc"
+"Help and resources" = "Pomoc i zasoby"
+"Help page" = "Strona pomocy"
+"Here: {names}" = "Tutaj: {names}"
+"Hidden" = "Ukryty"
+"Hide contents" = "Ukryj zawartość"
+"Hide from publishing" = "Ukryj przed publikacją"
+"Hide section contents" = "Ukryj zawartość sekcji"
+"Hide these tips (Getting started in the Help menu shows them again)" = "Ukryj te wskazówki (Pierwsze kroki w menu Pomoc wyświetli je ponownie)"
+"Hide when publishing" = "Ukryj podczas publikacji"
+"Highlight layers on hover" = "Wyróżniaj warstwy po najechaniu kursorem"
+"Highlighter" = "Zakreślacz"
+"Highlights" = "Światła"
+"Hold Alt" = "Przytrzymaj Alt"
+"Hold Alt+Z" = "Przytrzymaj Alt+Z"
+"Hold Ctrl" = "Przytrzymaj Ctrl"
+"Hold Z" = "Przytrzymaj Z"
+"Hold ⌃ or ⌘" = "Przytrzymaj ⌃ lub ⌘"
+"Hold ⌥" = "Przytrzymaj ⌥"
+"Hold ⌥Z" = "Przytrzymaj ⌥Z"
+"Home" = "Start"
+"Horizontal" = "Poziomo"
+"Horizontal align" = "Wyrównanie poziome"
+"Horizontal hex" = "Poziomy sześciokąt"
+"Horizontal padding" = "Marginesy poziome"
+"Horizontal spacing" = "Odstępy poziome"
+"Hosted by {operator}" = "Hostowane przez {operator}"
+"Hover a layer to see its properties" = "Najedź na warstwę, aby zobaczyć jej właściwości"
+"Hover other layers to measure the distance" = "Najedź na inne warstwy, aby zmierzyć odległość"
+"Hue" = "Odcień"
+"Hug" = "Dopasuj"
+"Hug contents" = "Dopasuj do zawartości"
+"Icon components on a 24 px grid with keylines and a size preview" = "Komponenty ikon na siatce 24 px z liniami pomocniczymi i podglądem rozmiaru"
+"Icon set starter" = "Zestaw początkowy ikon"
+"If it keeps happening, please report it at {link} with this message." = "Jeśli problem będzie się powtarzał, zgłoś go pod adresem {link}, dołączając tę wiadomość."
+"If" = "Jeżeli"
+"If {condition}" = "Jeżeli {condition}"
+"Ignore auto layout (absolute position)" = "Ignoruj automatyczny układ (pozycja bezwzględna)"
+"Image" = "Obraz"
+"Images" = "Obrazy"
+"Import" = "Importuj"
+"Import path" = "Ścieżka importu"
+"Import plugin from manifest" = "Zaimportuj wtyczkę z manifestu"
+"Import plugin from manifest…" = "Zaimportuj wtyczkę z manifestu…"
+"Import report" = "Raport importu"
+"Import variables" = "Importuj zmienne"
+"Imported document" = "Zaimportowany dokument"
+"Imported {name}" = "Zaimportowano {name}"
+"Imported {n} new variables, updated {updated}" = { one = "Zaimportowano {n} nową zmienną, zaktualizowano {updated}", few = "Zaimportowano {n} nowe zmienne, zaktualizowano {updated}", many = "Zaimportowano {n} nowych zmiennych, zaktualizowano {updated}", other = "Zaimportowano {n} nowych zmiennych, zaktualizowano {updated}" }
+"Import…" = "Importuj…"
+"In an instance, this comes from the main component" = "W instancji pochodzi to z głównego komponentu"
+"In the browser you can join sessions the desktop app hosts and files on a FigCraft server. A page opened over https reaches other computers only through wss:// links (a server behind TLS)." = "W przeglądarce możesz dołączać do sesji hostowanych przez aplikację desktopową oraz do plików na serwerze FigCraft. Strona otwarta przez https łączy się z innymi komputerami tylko przez linki wss:// (serwer za TLS)."
+"Include bounding box" = "Dołącz ramkę otaczającą"
+"Include id attribute" = "Dołącz atrybut id"
+"Included" = "Uwzględniono"
+"Included in layout" = "Uwzględniono w układzie"
+"Individual corners" = "Niezależne narożniki"
+"Individual strokes" = "Niezależne obrysy"
+"Ink" = "Farba"
+"Inner shadow" = "Cień wewnętrzny"
+"Inside" = "Wewnątrz"
+"Inspect" = "Inspekcja"
+"Inspect the layer under the pointer: size, colours, typography" = "Sprawdź warstwę pod kursorem: rozmiar, kolory, typografia"
+"Install plugin" = "Zainstaluj wtyczkę"
+"Install" = "Zainstaluj"
+"Installed {name}" = "Zainstalowano {name}"
+"Installed" = "Zainstalowano"
+"Installing…" = "Instalowanie…"
+"Instance" = "Instancja"
+"Instance properties" = "Właściwości instancji"
+"Instance swap" = "Podmiana instancji"
+"Instance swap (no other component)" = "Podmiana instancji (brak innego komponentu)"
+"Instances" = "Instancje"
+"Instant" = "Natychmiastowo"
+"Intensity" = "Siła"
+"Interaction" = "Interakcja"
+"Interactions" = "Interakcje"
+"Interface design and prototyping. A free, open-source, clean-room design tool written from scratch in Rust, part of the ArtCraft Crafting Apps." = "Projektowanie interfejsów i prototypowanie. Darmowe, otwartoźródłowe, czysto implementowane narzędzie projektowe napisane od podstaw w Rust, część ArtCraft Crafting Apps."
+"Intersect" = "Przetnij"
+"Intersects" = "Przecina"
+"Invalid color" = "Nieprawidłowy kolor"
+"Invite link" = "Link z zaproszeniem"
+"Invite link copied" = "Skopiowano link z zaproszeniem"
+"It asks permission to:" = "Wymaga uprawnień do:"
+"Jan" = "Sty"
+"Join" = "Połącz"
+"Join code copied" = "Skopiowano kod dołączenia"
+"Join code or invite link" = "Kod dołączenia lub link z zaproszeniem"
+"Join live session" = "Dołącz do sesji na żywo"
+"Join us on Discord" = "Dołącz do nas na Discordzie"
+"Join with a code" = "Dołącz za pomocą kodu"
+"Joined" = "Dołączono"
+"Joined {file}" = "Dołączono do: {file}"
+"Joining…" = "Dołączanie…"
+"Join|stroke" = "Join|stroke"
+"Jul" = "Lip"
+"Jun" = "Cze"
+"Just now" = "Przed chwilą"
+"Justify" = "Wyjustuj"
+"Keep appearance" = "Zachowaj wygląd"
+"Keep appearance converts every color value to {profile} so colors look the same. Keep values leaves the numbers as they are, so colors shift." = "Zachowanie wyglądu konwertuje każdą wartość koloru na {profile}, aby kolory wyglądały tak samo. Zachowanie wartości pozostawia liczby bez zmian, co może zmienić odcienie barw."
+"Keep tool selected after use" = "Pozostaw narzędzie wybrane po użyciu"
+"Keep values" = "Zachowaj wartości"
+"Key/Gamepad" = "Klawisz/Kontroler"
+"Key/Gamepad {key}" = "Klawisz/Kontroler {key}"
+"Keyboard shortcuts" = "Skróty klawiaturowe"
+"Kits" = "Zestawy"
+"Landing page" = "Strona docelowa (Landing page)"
+"Language" = "Język"
+"Lasso" = "Lasso"
+"Last" = "Ostatni"
+"Last change: {note}" = "Ostatnia zmiana: {note}"
+"Last commit" = "Ostatni commit"
+"Last modified" = "Ostatnia modyfikacja"
+"Last on top" = "Ostatni na wierzchu"
+"Layer blur" = "Rozmycie warstwy"
+"Layer name" = "Nazwa warstwy"
+"Layers" = "Warstwy"
+"Layers in an instance take their position from the main component" = "Warstwy w instancji przyjmują pozycję z głównego komponentu"
+"Layout" = "Układ"
+"Layout grid" = "Siatka układu"
+"Layout grid settings" = "Ustawienia siatki układu"
+"Layout grids" = "Siatki układu"
+"Leave session" = "Opuść sesję"
+"Leaves" = "Opuszcza"
+"Left" = "Do lewej"
+"Left & right" = "Lewa i prawa"
+"Left side" = "Lewa strona"
+"Left side width" = "Szerokość lewej strony"
+"Letter case" = "Wielkość liter"
+"Letter spacing" = "Światło tekstu"
+"Libraries" = "Biblioteki"
+"Libraries in this file" = "Biblioteki w tym pliku"
+"Library updates available" = "Dostępne aktualizacje biblioteki"
+"Library: click to collapse" = "Biblioteka: kliknij, aby zwinąć"
+"Library: click to expand" = "Biblioteka: kliknij, aby rozwinąć"
+"Library: its variables are read-only here; edit them in the library file and publish it" = "Biblioteka: jej zmienne są tutaj tylko do odczytu; edytuj je w pliku biblioteki i opublikuj"
+"Light" = "Lekki"
+"Lighten" = "Jaśniej"
+"Light|glass" = "Light|glass"
+"Line" = "Linia"
+"Line arrow" = "Strzałka liniowa"
+"Line delta" = "Różnica wierszy"
+"Line height" = "Interlinia"
+"Linear" = "Liniowy"
+"Lines" = "Linie"
+"Lines +/−" = "Wiersze +/−"
+"Lines added" = "Dodane wiersze"
+"Lines deleted" = "Usunięte wiersze"
+"Link" = "Łącze"
+"Link copied" = "Skopiowano link"
+"Link docs, code or tickets for developers." = "Dołącz dokumentację, kod lub zgłoszenia dla programistów."
+"Link frames on the Prototype tab, then present the flow" = "Połącz ramki na karcie Prototyp, a następnie zaprezentuj przepływ"
+"Link this component to its code component: instances then show your real snippet with their values." = "Połącz ten komponent z jego odpowiednikiem w kodzie: instancje wyświetlą wtedy rzeczywisty fragment kodu z ich wartościami."
+"List spacing" = "Odstępy listy"
+"List style" = "Styl listy"
+"Live session" = "Sesja na żywo"
+"Live · {people}" = "Na żywo · {people}"
+"Local components" = "Komponenty lokalne"
+"Local network" = "Sieć lokalna"
+"Local styles" = "Style lokalne"
+"Local variables" = "Zmienne lokalne"
+"Lock/Unlock" = "Zablokuj/Odblokuj"
+"Locked" = "Zablokowane"
+"Lowercase" = "Małe litery"
+"Luminance" = "Luminancja"
+"Luminosity" = "Jasność"
+"Main" = "Główny"
+"Main component deleted" = "Usunięto główny komponent"
+"Main menu" = "Menu główne"
+"Make a component" = "Utwórz komponent"
+"Make slot" = "Utwórz gniazdo (slot)"
+"Mar" = "Mar"
+"Margin" = "Margines"
+"Mark all as read" = "Oznacz wszystkie jako przeczytane"
+"Mark as resolved" = "Oznacz jako rozwiązane"
+"Mark as unread" = "Oznacz jako nieprzeczytane"
+"Mark as unresolved" = "Oznacz jako nierozwiązane"
+"Marker" = "Marker"
+"Mask" = "Maska"
+"Mass · Stiffness · Damping" = "Masa · Sztywność · Tłumienie"
+"Match (empty: the whole name)" = "Dopasowanie (puste: cała nazwa)"
+"Max H" = "Maks. wys."
+"Max W" = "Maks. szer."
+"Max lines" = "Maks. linii"
+"Maximize" = "Maksymalizuj"
+"May" = "maja"
+"Measure to the selection" = "Zmierz odległość do zaznaczenia"
+"Merge into main" = "Scal z gałęzią główną"
+"Merge regions" = "Scal obszary"
+"Merge the branch into the main file (one undo step) and archive it" = "Scal gałąź z plikiem głównym (jeden krok cofnięcia) i zarchiwizuj ją"
+"Merged" = "Scalone"
+"Merged PRs" = "Scalone PR"
+"Min H" = "Min. wys."
+"Min W" = "Min. szer."
+"Minimize" = "Minimalizuj"
+"Mirror angle" = "Kąt odbicia lustrzanego"
+"Mirror angle and length" = "Kąt i długość odbicia lustrzanego"
+"Mirroring" = "Odbicie lustrzane"
+"Missing" = "Brak"
+"Missing fonts" = "Brakujące czcionki"
+"Missing layer" = "Brakująca warstwa"
+"Missing style" = "Brakujący styl"
+"Missing variable" = "Brakująca zmienna"
+"Miter" = "Ostre"
+"Miter angle" = "Kąt ścięcia (miter)"
+"Mixed" = "Różne wartości"
+"Mixed fonts" = "Różne czcionki"
+"Mixed interactions: click + to replace them" = "Różne interakcje: kliknij +, aby je zastąpić"
+"Mobile app" = "Aplikacja mobilna"
+"Mode" = "Tryb"
+"Model" = "Model"
+"Models" = "Modele"
+"Mono" = "Mono"
+"More" = "Więcej"
+"More instance actions" = "Więcej akcji instancji"
+"Mouse down" = "Naciśnięcie myszy"
+"Mouse enter" = "Wskazanie myszą (Mouse enter)"
+"Mouse leave" = "Opuszczenie kursora myszy"
+"Mouse up" = "Zwolnienie przycisku myszy"
+"Move along the toolbar or the layer rows" = "Przechodź wzdłuż paska narzędzi lub wierszy warstw"
+"Move" = "Przesuń"
+"Move column left" = "Przesuń kolumnę w lewo"
+"Move column right" = "Przesuń kolumnę w prawo"
+"Move down" = "Przesuń w dół"
+"Move in" = "Wsuń"
+"Move out" = "Wysuń"
+"Move tools" = "Narzędzia przesuwania"
+"Move up" = "Przesuń w górę"
+"Moved to {name}" = "Przeniesiono do: {name}"
+"Multi" = "Wiele"
+"Multiply" = "Mnożenie"
+"Muted" = "Stonowany"
+"Name" = "Nazwa"
+"Name (A–Z)" = "Nazwa (A–Z)"
+"Named instance" = "Nazwana instancja"
+"Navigate to" = "Przejdź do"
+"Nested instance" = "Zagnieżdżona instancja"
+"New board" = "Nowa tablica"
+"New design file" = "Nowy plik projektu"
+"Newest first" = "Najpierw najnowsze"
+"Next or previous control in the focused region" = "Następny lub poprzedni element w aktywnym obszarze"
+"Next frame" = "Następna klatka"
+"Next ready for dev" = "Następny element gotowy do wdrożenia"
+"Next size option" = "Następna opcja rozmiaru"
+"No assets: no export settings, icons or images. Add export settings in the Design tab." = "Brak zasobów: brak ustawień eksportu, ikon lub obrazów. Dodaj ustawienia eksportu na karcie Projekt."
+"No boolean variables fit here." = "Żadna zmienna logiczna (boolean) tutaj nie pasuje."
+"No boolean variables yet. Create them in Local variables." = "Brak zmiennych logicznych. Utwórz je w Zmiennych lokalnych."
+"No branches. A branch is a copy of the file to try changes in, then review and merge." = "Brak gałęzi. Gałąź to kopia pliku do testowania zmian, a następnie ich przeglądu i scalenia."
+"No category" = "Bez kategorii"
+"No changes" = "Brak zmian"
+"No color styles" = "Brak stylów kolorów"
+"No colour variables fit here." = "Żadna zmienna koloru tutaj nie pasuje."
+"No colour variables yet. Create them in Local variables." = "Brak zmiennych koloru. Utwórz je w Zmiennych lokalnych."
+"No comments yet" = "Brak komentarzy"
+"No compatibility warnings reported" = "Nie zgłoszono ostrzeżeń o zgodności"
+"No components yet. Select layers and press {keys}." = "Brak komponentów. Zaznacz warstwy i naciśnij {keys}."
+"No conflicts." = "Brak konfliktów."
+"No contributor data was built into this copy." = "Ta kopia nie zawiera danych o współtwórcach."
+"No device" = "Brak urządzenia"
+"No fonts match" = "Brak pasujących czcionek"
+"No files or templates match your search" = "Żaden plik ani szablon nie pasuje do wyszukiwania"
+"No join code here (the server is older than join codes, or this address can't be put in one): share the link instead." = "Brak kodu dołączenia (serwer jest starszy niż kody dołączenia lub ten adres nie może być zakodowany): zamiast tego udostępnij link."
+"No layer changes to show." = "Brak zmian warstw do wyświetlenia."
+"No libraries yet. Add a .figcraft file that was published as a library, or paste a team library's link." = "Brak bibliotek. Dodaj plik .figcraft opublikowany jako biblioteka lub wklej link do biblioteki zespołu."
+"No list" = "Brak listy"
+"No matching comments" = "Brak pasujących komentarzy"
+"No matching components" = "Brak pasujących komponentów"
+"No matching layers" = "Brak pasujących warstw"
+"No matching styles" = "Brak pasujących stylów"
+"No matching variables" = "Brak pasujących zmiennych"
+"No mirroring" = "Brak odbicia lustrzanego"
+"No model credits were built into this copy." = "Ta kopia nie zawiera informacji o modelach."
+"No number variables fit here." = "Żadna zmienna liczbowa tutaj nie pasuje."
+"No number variables yet. Create them in Local variables." = "Brak zmiennych liczbowych. Utwórz je w Zmiennych lokalnych."
+"No other pages" = "Brak innych stron"
+"No paints" = "Brak wypełnień/obrysów"
+"No plugins on {server}." = "Brak wtyczek na {server}."
+"No plugins yet. Import a development plugin from its figcraft-plugin.json." = "Brak wtyczek. Zaimportuj wtyczkę deweloperską z pliku figcraft-plugin.json."
+"No preferred components" = "Brak preferowanych komponentów"
+"No preset" = "Brak presetu"
+"No saved versions yet. Save a version to mark a point in your work you can come back to." = "Brak zapisanych wersji. Zapisz wersję, aby oznaczyć punkt w pracy, do którego możesz wrócić."
+"No scrolling" = "Brak przewijania"
+"No shortcuts match" = "Brak pasujących skrótów"
+"No status" = "Brak statusu"
+"No string variables fit here." = "Żadna zmienna tekstowa tutaj nie pasuje."
+"No string variables yet. Create them in Local variables." = "Brak zmiennych tekstowych. Utwórz je w Zmiennych lokalnych."
+"No styles yet." = "Brak stylów."
+"No styles yet. Click + to create one from the selection." = "Brak stylów. Kliknij +, aby utworzyć styl z zaznaczenia."
+"No templates match your search" = "Żaden szablon nie pasuje do wyszukiwania"
+"No text styles yet. Click + to create one from the selected text." = "Brak stylów tekstu. Kliknij +, aby utworzyć styl z zaznaczonego tekstu."
+"No variables fit here." = "Żadne zmienne tutaj nie pasują."
+"No variables yet. Create them in Local variables." = "Brak zmiennych. Utwórz je w Zmiennych lokalnych."
+"Nobody else is here yet" = "Nikogo innego tu jeszcze nie ma"
+"Noise" = "Szum"
+"None" = "Brak"
+"None." = "Brak."
+"Normal" = "Zwykły"
+"Not bound" = "Nieprzypisane"
+"Not in a live session" = "Nie jesteś w sesji na żywo"
+"Not in this font" = "Brak w tej czcionce"
+"Not properties, kept as written: {names}" = "Nie są to właściwości, zachowano bez zmian: {names}"
+"Not read yet" = "Jeszcze nieprzeczytane"
+"Not shared" = "Nieudostępnione"
+"Note {n}" = "Notatka {n}"
+"Nothing changed since this was marked ready for dev." = "Nic się nie zmieniło od czasu oznaczenia jako gotowe do wdrożenia."
+"Nothing here yet. Set a frame's status to list it." = "Nic tu jeszcze nie ma. Ustaw status ramki, aby ją wyświetlić."
+"Nothing online yet. Use Share on a file to put it online and it is listed here." = "Brak plików online. Użyj Udostępnij na pliku, aby umieścić go online i wyświetlić tutaj."
+"Nothing to export" = "Nic do wyeksportowania"
+"Nov" = "Lis"
+"Now" = "Teraz"
+"Nudge (Shift: big nudge)" = "Krok przesunięcia (Shift: duży krok)"
+"Nudge amount" = "Wielkość kroku przesunięcia"
+"Number" = "Liczba"
+"Number ↑" = "Liczba ↑"
+"Number ↓" = "Liczba ↓"
+"Numbered list" = "Lista numerowana"
+"Object" = "Obiekt"
+"Oct" = "Paź"
+"Off" = "Wyłączone"
+"Offered first when filling the slot (any content is allowed)" = "Proponowane w pierwszej kolejności przy wypełnianiu gniazda (dowolna zawartość jest dozwolona)"
+"Offered first when swapping the instance (any component is allowed)" = "Proponowane w pierwszej kolejności przy podmianie instancji (dowolny komponent jest dozwolony)"
+"Offset" = "Przesunięcie"
+"Oldest first" = "Najpierw najstarsze"
+"On click" = "Przy kliknięciu"
+"On drag" = "Podczas przeciągania"
+"On this page" = "Na tej stronie"
+"One announcement in five common sizes: square, portrait, story, link and banner" = "Jedno ogłoszenie w pięciu popularnych rozmiarach: kwadrat, pion, relacja, link i baner"
+"Online" = "Online"
+"Online files" = "Pliki online"
+"Online sharing is off: files are shared on the local network only." = "Udostępnianie online jest wyłączone: pliki są udostępniane tylko w sieci lokalnej."
+"Only the first changed layers are listed." = "Wymieniono tylko pierwsze zmienione warstwy."
+"Only the first {n} changed layers are listed." = "Wymieniono tylko pierwsze {n} zmienionych warstw."
+"Only your threads" = "Tylko Twoje wątki"
+"Opacity" = "Krycie"
+"Opacity & blend" = "Nieprzezroczystość i mieszanie"
+"Opacity 10%…90%, 0: 100%" = "Nieprzezroczystość 10%…90%, 0: 100%"
+"Open" = "Otwórz"
+"Open .figcraft, .svg or images" = "Otwórz .figcraft, .svg lub obrazy"
+"Open branch" = "Otwórz gałąź"
+"Open file" = "Otwórz plik"
+"Open files" = "Otwórz pliki"
+"Open presentations" = "Otwarte prezentacje"
+"Open in focus view" = "Otwórz w widoku skupienia"
+"Open in new window" = "Otwórz w nowym oknie"
+"Open invite links in FigCraft" = "Otwieraj linki z zaproszeniem w FigCraft"
+"Open link" = "Otwórz łącze"
+"Open link {url}" = "Otwórz link: {url}"
+"Open overlay" = "Otwórz nakładkę"
+"Open prototype preview" = "Otwórz podgląd prototypu"
+"Open variables ({count})" = "Otwórz zmienne ({count})"
+"Opened as a new document" = "Otwarto jako nowy dokument"
+"Opened “{name}” in a new tab" = "Otwarto „{name}” w nowej karcie"
+"Opening the file…" = "Otwieranie pliku…"
+"Opening {n} files as new files" = { one = "Otwieranie jako nowy plik", few = "Otwieranie {n} plików jako nowe pliki", many = "Otwieranie {n} plików jako nowe pliki", other = "Otwieranie {n} plików jako nowe pliki" }
+"Open|comments" = "Open|comments"
+"Options" = "Opcje"
+"Orange" = "Pomarańczowy"
+"Order" = "Kolejność"
+"Other apps may not open every .fig file exported here." = "Inne aplikacje mogą nie otworzyć każdego pliku .fig wyeksportowanego tutaj."
+"Other" = "Inne"
+"Others lose access and keep their copy; the file stays on the server for you" = "Inni tracą dostęp i zachowują swoją kopię; plik pozostaje na serwerze dla Ciebie"
+"Others type this under Share ▸ Join with a code" = "Inni wpisują to w menu Udostępnij ▸ Dołącz za pomocą kodu"
+"Outline stroke" = "Przekształć obrys w ścieżkę"
+"Outline text" = "Kontury tekstu"
+"Outlines" = "Kontury"
+"Outside" = "Na zewnątrz"
+"Overflow" = "Przepełnienie (overflow)"
+"Overlay" = "Nakładka"
+"Overlay position" = "Pozycja nakładki"
+"Overridden here (the collection it extends has another value)" = "Nadpisane tutaj (kolekcja, którą rozszerza, ma inną wartość)"
+"Overrides" = "Nadpisania"
+"Owner token" = "Token właściciela"
+"Owner token copied" = "Skopiowano token właściciela"
+"PDF print options" = "Opcje druku PDF"
+"PDF print settings" = "Ustawienia druku PDF"
+"Padding" = "Marginesy wewnętrzne"
+"Page" = "Strona"
+"Pages" = "Strony"
+"Pages added to the document" = "Strony dodane do dokumentu"
+"Pink" = "Różowy"
+"Placed on the current page" = "Umieszczono na bieżącej stronie"
+"Pages: {pages}" = "Strony: {pages}"
+"Paint bucket" = "Wiadro z farbą"
+"Pan the canvas" = "Przesuwaj płótno"
+"Pan with nothing selected (Shift: farther)" = "Przesuwaj przy braku zaznaczenia (Shift: dalej)"
+"Panels" = "Panele"
+"Paper" = "Papier"
+"Paragraph indent" = "Wcięcie akapitu"
+"Paragraph indent applies to left-aligned text" = "Wcięcie akapitu dotyczy tekstu wyrównanego do lewej"
+"Paragraph spacing" = "Odstęp akapitu"
+"Pass through" = "Przepuszczanie"
+"Paste a link (https://…)" = "Wklej link (https://…)"
+"Paste a team library link (a view link)" = "Wklej link do biblioteki zespołu (link do podglądu)"
+"Paste here" = "Wklej tutaj"
+"Paste to replace" = "Wklej, aby zastąpić"
+"Pasted design layers; {n} kinds of content were left out" = { one = "Wklejono warstwy projektu; pominięto {n} rodzaj zawartości", few = "Wklejono warstwy projektu; pominięto {n} rodzaje zawartości", many = "Wklejono warstwy projektu; pominięto {n} rodzajów zawartości", other = "Wklejono warstwy projektu; pominięto {n} rodzajów zawartości" }
+"Pattern" = "Wzór"
+"Pattern alignment" = "Wyrównanie wzoru"
+"Pattern scale" = "Skala wzoru"
+"Pattern source" = "Źródło wzoru"
+"Pen" = "Pióro"
+"Pencil" = "Ołówek"
+"People in this file" = "Osoby w tym pliku"
+"People join from anywhere with a code. The file is kept on {server} while you share it." = "Użytkownicy dołączają z dowolnego miejsca za pomocą kodu. Plik jest przechowywany na {server} podczas udostępniania."
+"People on your network join with a code. Nothing goes through a server." = "Użytkownicy w Twojej sieci dołączają za pomocą kodu. Nic nie przechodzi przez serwer zewnętrzny."
+"Phone" = "Telefon"
+"Pick color" = "Wybierz kolor"
+"Pick color (I)" = "Wybierz kolor (I)"
+"Pick one font family first" = "Najpierw wybierz jedną rodzinę czcionek"
+"Pick the Frame tool, then drag on the canvas or choose a device size" = "Wybierz narzędzie Ramka, a następnie przeciągnij po płótnie lub wybierz rozmiar urządzenia"
+"Pin a property" = "Przypnij właściwość"
+"Pinch" = "Uszczypnięcie"
+"Pixel grid" = "Siatka pikseli"
+"Pixel preview 1x" = "Podgląd pikselowy 1x"
+"Pixel preview 2x" = "Podgląd pikselowy 2x"
+"Place a shape or frame (its tool chosen)" = "Umieść kształt lub ramkę (wybrane narzędzie)"
+"Place automatically" = "Umieść automatycznie"
+"Place image" = "Umieść obraz"
+"Plugin" = "Wtyczka"
+"Plugins run in FigCraft's sandbox, without files, network or clock. Install only plugins you trust." = "Wtyczki działają w piaskownicy FigCraft, bez dostępu do plików, sieci czy zegara. Instaluj tylko zaufane wtyczki."
+"Plugins" = "Wtyczki"
+"Plugins & widgets" = "Wtyczki i widżety"
+"Plus darker" = "Plus ciemniejszy"
+"Plus lighter" = "Plus jaśniejszy"
+"Plus one" = "Plus jeden"
+"Point" = "Punkt"
+"Points" = "Punkty"
+"Polygon" = "Wielokąt"
+"Polygons" = "Wielokąty"
+"Port" = "Port"
+"Position" = "Położenie"
+"Post" = "Opublikuj"
+"Preferences" = "Preferencje"
+"Preferred" = "Preferowane"
+"Present" = "Prezentuj"
+"Present or preview" = "Prezentuj lub wyświetl podgląd"
+"Present this flow" = "Prezentuj ten przepływ"
+"Presentation" = "Prezentacja"
+"Presentation slides" = "Slajdy prezentacji"
+"Presenting: comments" = "Prezentacja: komentarze"
+"Presenting: cycle the size options" = "Prezentacja: przełączaj opcje rozmiaru"
+"Presenting: full screen" = "Prezentacja: pełny ekran"
+"Presenting: next frame" = "Prezentacja: następna ramka"
+"Presenting: previous frame" = "Prezentacja: poprzednia ramka"
+"Presenting: restart" = "Prezentacja: uruchom ponownie"
+"Preserve scroll position" = "Zachowaj pozycję przewijania"
+"Presets" = "Ustawienia wstępne"
+"Press a key…" = "Naciśnij klawisz…"
+"Playground" = "Piaskownica (Playground)"
+"Preview" = "Podgląd"
+"Preview this flow" = "Podgląd tego przepływu"
+"Preview this frame" = "Podgląd tej ramki"
+"Previous frame" = "Poprzednia klatka"
+"Previous ready for dev" = "Poprzedni gotowy do wdrożenia"
+"Progressive" = "Progresywny"
+"Properties" = "Właściwości"
+"Prototype" = "Prototyp"
+"Prototype preview" = "Podgląd prototypu"
+"Prototype settings" = "Ustawienia prototypu"
+"Publish" = "Publikuj"
+"Publish changes" = "Publikuj zmiany"
+"Publish to another server…" = "Publikuj na innym serwerze…"
+"Publish to server" = "Publikuj na serwerze"
+"Published version {v}" = "Opublikowano wersję {v}"
+"Published version {v} to the server" = "Opublikowano wersję {v} na serwerze"
+"Published version {v}: save the file so other files can use it" = "Opublikowano wersję {v}: zapisz plik, aby inne pliki mogły go używać"
+"Published · {people}" = "Opublikowano · {people}"
+"Publishing to a server needs the desktop app; in the browser you can join a server's files" = "Publikowanie na serwerze wymaga aplikacji desktopowej; w przeglądarce możesz dołączać do plików serwera"
+"Publishing with the server's key." = "Publikowanie przy użyciu klucza serwera."
+"Publishing…" = "Publikowanie…"
+"Push" = "Wypychanie"
+"Push changes to main component" = "Wypchnij zmiany do głównego komponentu"
+"Put text on path" = "Umieść tekst na ścieżce"
+"Question" = "Pytanie"
+"R" = "R"
+"Radial" = "Promienisty"
+"Radius" = "Promień"
+"Ratio" = "Proporcje"
+"Reading the library…" = "Odczytywanie biblioteki…"
+"Ready for dev" = "Gotowe do wdrożenia"
+"Real name" = "Imię i nazwisko"
+"Recent" = "Ostatnie"
+"Recent files" = "Ostatnie pliki"
+"Recents" = "Ostatnie"
+"Recovered {n} unsaved files after the app quit unexpectedly: save them to keep them" = { one = "Odzyskano niezapisany plik po nieoczekiwanym zamknięciu programu: zapisz go, aby go zachować", few = "Odzyskano {n} niezapisane pliki po nieoczekiwanym zamknięciu programu: zapisz je, aby je zachować", many = "Odzyskano {n} niezapisanych plików po nieoczekiwanym zamknięciu programu: zapisz je, aby je zachować", other = "Odzyskano {n} niezapisanych plików po nieoczekiwanym zamknięciu programu: zapisz je, aby je zachować" }
+"Rectangle" = "Prostokąt"
+"Rectangles" = "Prostokąty"
+"Red" = "Czerwony"
+"Reduce motion" = "Ogranicz ruch"
+"Refraction" = "Załamanie światła (refrakcja)"
+"Regular expression" = "Wyrażenie regularne"
+"Remove" = "Usuń"
+"Remove all" = "Usuń wszystko"
+"Remove annotation" = "Usuń adnotację"
+"Remove auto layout" = "Usuń Auto layout"
+"Remove dev resource" = "Usuń zasób programistyczny"
+"Remove export setting" = "Usuń ustawienie eksportu"
+"Remove from recents" = "Usuń z ostatnich"
+"Remove from server" = "Usuń z serwera"
+"Remove from server…" = "Usuń z serwera…"
+"Remove guide" = "Usuń linię pomocniczą"
+"Remove interaction" = "Usuń interakcję"
+"Remove library from this file" = "Usuń bibliotekę z tego pliku"
+"Remove min and max" = "Usuń min. i maks."
+"Remove min and max height" = "Usuń minimalną i maksymalną wysokość"
+"Remove min and max width" = "Usuń minimalną i maksymalną szerokość"
+"Remove regions" = "Usuń obszary"
+"Remove slot" = "Usuń gniazdo"
+"Remove starting point" = "Usuń punkt startowy"
+"Remove stop" = "Usuń punkt"
+"Remove text from path" = "Usuń tekst ze ścieżki"
+"Remove the else and its actions" = "Usuń warunek przeciwny (else) i jego akcje"
+"Remove this condition and its actions" = "Usuń ten warunek i jego akcje"
+"Remove this file from the server? It can't be shared or opened from there again. Your copy stays open here." = "Usunąć ten plik z serwera? Nie będzie można go już stamtąd udostępnić ani otworzyć. Twoja kopia pozostanie otwarta tutaj."
+"Remove {name} from session" = "Usuń {name} z sesji"
+"Remove {name} from {server}?" = "Usunąć {name} z {server}?"
+"Removed" = "Usunięto"
+"Removed from the server" = "Usunięto z serwera"
+"Removed since it was marked" = "Usunięto od momentu oznaczenia"
+"Rename" = "Zmień nazwę"
+"Rename duplicated layers" = "Zmień nazwę powielonych warstw"
+"Rename folder" = "Zmień nazwę folderu"
+"Rename group" = "Zmień nazwę grupy"
+"Rename layers" = "Zmień nazwę warstw"
+"Rename mode" = "Zmień nazwę trybu"
+"Rename on the server" = "Zmień nazwę na serwerze"
+"Rename on the server…" = "Zmień nazwę na serwerze…"
+"Rename page" = "Zmień nazwę strony"
+"Rename to" = "Zmień nazwę na"
+"Replace all" = "Zamień wszystko"
+"Replace mixed export settings" = "Zastąp zróżnicowane ustawienia eksportu"
+"Replace with" = "Zamień na"
+"Replace with a new interaction" = "Zastąp nową interakcją"
+"Reply" = "Odpowiedz"
+"Report" = "Raport"
+"Report this file…" = "Zgłoś ten plik…"
+"Reset" = "Resetuj"
+"Reset adjustments" = "Zresetuj korekty"
+"Reset all changes" = "Zresetuj wszystkie zmiany"
+"Reset all overrides on this layer" = "Zresetuj wszystkie nadpisania na tej warstwie"
+"Reset overrides" = "Zresetuj nadpisania"
+"Reset slot" = "Zresetuj gniazdo"
+"Reset this override" = "Zresetuj to nadpisanie"
+"Reset to style" = "Przywróć styl"
+"Reset to the inherited value" = "Przywróć wartość dziedziczoną"
+"Resize by the nudge amount" = "Zmień rozmiar o wielkość kroku przesunięcia"
+"Resize frames to the device's screen (or the window without a device): their constraints and auto layout respond" = "Dopasuj ramki do ekranu urządzenia (lub okna bez urządzenia): ich ograniczenia i automatyczny układ odpowiednio zareagują"
+"Resize to fit" = "Dopasuj rozmiar"
+"Resizing" = "Zmiana rozmiaru"
+"Resolve" = "Rozwiąż"
+"Resolve change" = "Rozwiąż zmianę"
+"Resolved" = "Rozwiązany"
+"Resources" = "Zasoby"
+"Responsive" = "Responsywny"
+"Restart" = "Uruchom ponownie"
+"Restore" = "Przywróć"
+"Restore main component" = "Przywróć główny komponent"
+"Restore this version" = "Przywróć tę wersję"
+"Restored “{name}”" = "Przywrócono „{name}”"
+"Reverse the order" = "Odwróć kolejność"
+"Reversed triangle" = "Odwrócony trójkąt"
+"Review and merge" = "Przejrzyj i scal"
+"Ribbon" = "Wstążka"
+"Right" = "Do prawej"
+"Right side" = "Prawa strona"
+"Right side width" = "Szerokość prawej strony"
+"Rotate 90°" = "Obróć o 90°"
+"Rotate 90° right" = "Obróć o 90° w prawo"
+"Rotate to landscape" = "Obróć do orientacji poziomej"
+"Rotate to portrait" = "Obróć do orientacji pionowej"
+"Rotation" = "Obrót"
+"Rotation jitter" = "Drżenie obrotu (jitter)"
+"Round" = "Okrągłe"
+"Rounded" = "Zaokrąglone"
+"Rounded rectangle" = "Zaokrąglony prostokąt"
+"Row" = "Wiersz"
+"Row gap" = "Odstęp między wierszami"
+"Row sizes" = "Rozmiary wierszy"
+"Row span" = "Rozpiętość wierszy"
+"Rows" = "Wiersze"
+"Rows {count}" = "Wiersze: {count}"
+"Rulers" = "Linijki"
+"Run" = "Uruchom"
+"Run {label}" = "Uruchom {label}"
+"Save files automatically" = "Zapisuj pliki automatycznie"
+"Search templates" = "Szukaj szablonów"
+"See all templates" = "Zobacz wszystkie szablony"
+"Select layers and they space themselves as their content changes" = "Zaznacz warstwy, a będą automatycznie zachowywać odstępy przy zmianie zawartości"
+"SHA-256: {sha}…" = "SHA-256: {sha}…"
+"Same as layer" = "Taki sam jak warstwa"
+"Saturation" = "Nasycenie"
+"Save" = "Zapisz"
+"Save as" = "Zapisz jako"
+"Save as preset…" = "Zapisz jako preset…"
+"Save version  {key}" = "Zapisz wersję  {key}"
+"Saved" = "Zapisano"
+"Saved {name}" = "Zapisano: {name}"
+"Say something" = "Napisz coś"
+"Scale" = "Skaluj"
+"Scatter" = "Rozproszenie"
+"Scoping: where pickers offer it" = "Zakres: gdzie próbniki go oferują"
+"Screen" = "Ekran"
+"Scroll behavior" = "Zachowanie przewijania"
+"Scroll to" = "Przewiń do"
+"Scroll to layer" = "Przewiń do warstwy"
+"Scroll with parent" = "Przewijaj z rodzicem"
+"Search plugins" = "Szukaj wtyczek"
+"Search" = "Szukaj"
+"Search actions, layers and tools" = "Szukaj akcji, warstw i narzędzi"
+"Search assets" = "Szukaj zasobów"
+"Search comments" = "Szukaj komentarzy"
+"Search files and templates" = "Szukaj plików i szablonów"
+"Search results" = "Wyniki wyszukiwania"
+"Search fonts" = "Szukaj czcionek"
+"Search layers" = "Szukaj warstw"
+"Search shortcuts" = "Szukaj skrótów"
+"Section" = "Sekcja"
+"Section color" = "Kolor sekcji"
+"Sections" = "Sekcje"
+"Select a frame and add a starting point to present it as a flow." = "Wybierz ramkę i dodaj punkt początkowy, aby zaprezentować ją jako przepływ."
+"Select a frame to preview it" = "Wybierz ramkę, aby wyświetlić jej podgląd"
+"Select a layer to see its properties and code" = "Wybierz warstwę, aby zobaczyć jej właściwości i kod"
+"Select all" = "Zaznacz wszystko"
+"Select all with same" = "Zaznacz wszystko z takim samym"
+"Select layer" = "Zaznacz warstwę"
+"Select layers to apply the style to" = "Zaznacz warstwy, do których chcesz zastosować styl"
+"Select layers with this color" = "Zaznacz warstwy z tym kolorem"
+"Select overlapping shapes" = "Zaznacz nakładające się kształty"
+"Select points to edit their position, radius and mirroring" = "Zaznacz punkty, aby edytować ich pozycję, promień i odbicie lustrzane"
+"Select slot" = "Zaznacz gniazdo (slot)"
+"Selection colors" = "Kolory zaznaczenia"
+"Selection" = "Zaznaczenie"
+"Selection box, {w} by {h} at {x}, {y}: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "Ramka zaznaczenia, {w} × {h} w ({x}, {y}): strzałki przesuwają, Shift+strzałki lub {cmd}+strzałki zmieniają rozmiar, Enter zatwierdza, Escape anuluje"
+"Selection box: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "Ramka zaznaczenia: strzałki przesuwają, Shift+strzałki lub {cmd}+strzałki zmieniają rozmiar, Enter zatwierdza, Escape anuluje"
+"Send backward" = "Przenieś do tyłu"
+"Send report" = "Wyślij zgłoszenie"
+"Send to back" = "Przenieś na spód"
+"Sep" = "Wrz"
+"Server address (ws://host:47900/)" = "Adres serwera (ws://host:47900/)"
+"Server address" = "Adres serwera"
+"Server for online sharing" = "Serwer do udostępniania online"
+"Set as default" = "Ustaw jako domyślne"
+"Set variable" = "Ustaw zmienną"
+"Set variable mode" = "Ustaw tryb zmiennej"
+"Set variable {name}" = "Ustaw zmienną {name}"
+"Set {name} to {value}" = "Ustaw {name} na {value}"
+"Shadows" = "Cienie"
+"Shape" = "Kształt"
+"Shape builder" = "Kreator kształtów"
+"Shape tools" = "Narzędzia kształtów"
+"Shapes" = "Kształty"
+"Share" = "Udostępnij"
+"Share this file" = "Udostępnij ten plik"
+"Share with a code" = "Udostępnij za pomocą kodu"
+"Share: live session, export" = "Udostępnianie: sesja na żywo, eksport"
+"Shared" = "Udostępniono"
+"Shared: copy its code from the file's menu" = "Udostępniono: skopiuj kod z menu pliku"
+"Sharing a file needs the desktop app; here you can join one." = "Udostępnianie pliku wymaga aplikacji desktopowej; tutaj możesz tylko dołączyć."
+"Sharing on the local network (online sharing is off: no server is set in Preferences)." = "Udostępnianie w sieci lokalnej (udostępnianie online wyłączone: brak serwera w Preferencjach)."
+"Sharing on your network · {people}" = "Udostępnianie w Twojej sieci · {people}"
+"Sharing online · {people}" = "Udostępnianie online · {people}"
+"Sharing stopped: the file stays on the server, open only to you" = "Zatrzymano udostępnianie: plik pozostaje na serwerze, otwarty tylko dla Ciebie"
+"Show" = "Pokaż"
+"Show all templates" = "Pokaż wszystkie szablony"
+"Show as grid" = "Pokaż jako siatkę"
+"Show as list" = "Pokaż jako listę"
+"Show autosaves" = "Pokaż automatyczne zapisy"
+"Show behind transparent areas" = "Pokaż za przezroczystymi obszarami"
+"Show comments (Shift+C)" = "Pokaż komentarze (Shift+C)"
+"Show device frame" = "Pokaż ramkę urządzenia"
+"Show dimensions on objects" = "Pokaż wymiary na obiektach"
+"Show hotspot hints" = "Pokaż podpowiedzi obszarów klikalnych (hotspots)"
+"Show in Explorer" = "Pokaż w Eksploratorze"
+"Show in Finder" = "Pokaż w Finderze"
+"Show in folder" = "Pokaż w folderze"
+"Show only this on the canvas" = "Pokaż tylko ten element na płótnie"
+"Show open" = "Pokaż otwarte"
+"Show section contents" = "Pokaż zawartość sekcji"
+"Show this layer" = "Pokaż tę warstwę"
+"Show usage" = "Pokaż użycie"
+"Show/Hide" = "Pokaż/Ukryj"
+"Show/Hide UI" = "Pokaż/Ukryj interfejs"
+"Side by side" = "Obok siebie"
+"Sidebar" = "Panel boczny"
+"Simplify stroke" = "Uprość obrys"
+"Size" = "Rozmiar"
+"Size jitter" = "Rozrzut rozmiaru"
+"Skip ink" = "Pomiń atrament"
+"Slashed zero" = "Przekreślone zero"
+"Slice" = "Wycinek"
+"Slices" = "Plasterki"
+"Slide in" = "Wsuń slajd"
+"Slide out" = "Wysuń slajd"
+"Slot" = "Gniazdo (slot)"
+"Slot content" = "Zawartość gniazda"
+"Small capitals" = "Kapitaliki"
+"Small caps" = "Kapitaliki"
+"Smart animate" = "Inteligentna animacja (Smart animate)"
+"Snap to pixel grid" = "Przyciągaj do siatki pikseli"
+"Social and slides" = "Social media i slajdy"
+"Social media" = "Media społecznościowe"
+"Social post sizes" = "Rozmiary postów w mediach społecznościowych"
+"Soft light" = "Łagodne światło"
+"Solid" = "Jednolity"
+"Some variants have the same property values: give each one a unique combination" = "Niektóre warianty mają takie same wartości właściwości: nadaj każdemu unikalną kombinację"
+"Sort" = "Sortuj"
+"Sort by" = "Sortuj według"
+"Sort by date" = "Sortuj według daty"
+"Sort by page" = "Sortuj według strony"
+"Sort by {column}" = "Sortuj według: {column}"
+"Space around" = "Równe odstępy z marginesem (Space around)"
+"Space between" = "Równe odstępy między elementami (Space between)"
+"Space drag" = "Przesuwanie spacją"
+"Space evenly" = "Rozmieść równomiernie"
+"Space+drag" = "Spacja+przeciągnięcie"
+"Spacing" = "Odstępy"
+"Spam, stolen work, abuse…" = "Spam, plagiat, naruszenie zasad…"
+"Speech bubble" = "Dymek"
+"Splay" = "Rozszerzenie"
+"Spotlight me" = "Wyróżnij mój widok (Spotlight me)"
+"Spread" = "Rozszerzenie"
+"Square" = "Kwadratowe"
+"Stamp" = "Pieczątka"
+"Stamps" = "Pieczątki"
+"Standard" = "Standardowy"
+"Standard ligatures" = "Ligatury standardowe"
+"Star" = "Gwiazda"
+"Stars" = "Gwiazdy"
+"Start" = "Uruchom"
+"Start ascending from / stop descending at" = "Początek narastania od / koniec opadania w"
+"Start from a blank canvas" = "Zacznij od pustego płótna"
+"Start from a template" = "Zacznij od szablonu"
+"Start on path" = "Początek na ścieżce"
+"Start point" = "Punkt początkowy"
+"Start sharing" = "Rozpocznij udostępnianie"
+"Start sharing with the Share button, then pass on the code it gives" = "Rozpocznij udostępnianie przyciskiem Udostępnij, a następnie przekaż wygenerowany kod"
+"Starting to share…" = "Rozpoczynanie udostępniania…"
+"Status" = "Stan"
+"Sticky" = "Przyklejony (sticky)"
+"Sticky note" = "Karteczka"
+"Sticky note colors" = "Kolory karteczek"
+"Sticky notes, shapes and connectors" = "Karteczki, kształty i łączniki"
+"Stop" = "Zatrzymaj"
+"Stop following {name}" = "Przestań obserwować: {name}"
+"Stop session" = "Zatrzymaj sesję"
+"Stop sharing" = "Zatrzymaj udostępnianie"
+"Stop spotlighting" = "Zatrzymaj wyróżnianie widoku"
+"Stop {n}  {hex}" = "Punkt przejścia {n}  {hex}"
+"Straight" = "Prosty"
+"Stretch" = "Rozciągnięcie"
+"Strikethrough" = "Przekreślenie"
+"String" = "Tekst (string)"
+"Stroke" = "Obrys"
+"Stroke style" = "Styl obrysu"
+"Stroke weight" = "Grubość obrysu"
+"Strokes" = "Obrysy"
+"Style" = "Styl"
+"Styles" = "Style"
+"Stylistic set 1" = "Zestaw stylistyczny 1"
+"Stylistic set 2" = "Zestaw stylistyczny 2"
+"Stylistic set 3" = "Zestaw stylistyczny 3"
+"Stylistic set 4" = "Zestaw stylistyczny 4"
+"Stylistic set 5" = "Zestaw stylistyczny 5"
+"Subtract" = "Odejmij"
+"Subtracts" = "Odejmuje"
+"Suffix" = "Przyrostek"
+"Suspend snapping while dragging" = "Zawieś przyciąganie podczas przeciągania"
+"Swap instance" = "Podmień instancję"
+"Swap library: use another library's assets of the same names" = "Podmień bibliotekę: użyj zasobów innej biblioteki o tych samych nazwach"
+"Swap orientation" = "Zmień orientację"
+"Swap overlay" = "Podmień nakładkę"
+"Swap to {name}" = "Podmień na {name}"
+"Swap width and height" = "Zamień szerokość i wysokość"
+"Swapped instance" = "Podmieniono instancję"
+"Swapped {n} assets" = { one = "Podmieniono {n} zasób", few = "Podmieniono {n} zasoby", many = "Podmieniono {n} zasobów", other = "Podmieniono {n} zasobów" }
+"Swapped {n} assets; {missed} had no match and still use the old library" = { one = "Podmieniono {n} zasób; {missed} nie ma dopasowania i nadal używa starej biblioteki", few = "Podmieniono {n} zasoby; {missed} nie ma dopasowania i nadal używa starej biblioteki", many = "Podmieniono {n} zasobów; {missed} nie ma dopasowania i nadal używa starej biblioteki", other = "Podmieniono {n} zasobów; {missed} nie ma dopasowania i nadal używa starej biblioteki" }
+"Sweep" = "Przemiatanie (sweep)"
+"System" = "Systemowy"
+"Tab / Shift+Tab" = "Tab / Shift+Tab"
+"Table" = "Tabela"
+"Tablet" = "Tablet"
+"Tabular numbers" = "Cyfry tabelaryczne"
+"Take the values from the first selected layer" = "Pobierz wartości z pierwszej zaznaczonej warstwy"
+"Taper" = "Zwężanie"
+"Taper both ends" = "Zwężaj oba końce"
+"Tell the server's operator what is wrong with it" = "Poinformuj administratora serwera, co jest nie tak"
+"Temperature" = "Temperatura"
+"Template" = "Szablon"
+"Templates" = "Szablony"
+"Terms" = "Warunki"
+"Text" = "Tekst"
+"Text align" = "Wyrównanie tekstu"
+"Text content" = "Zawartość tekstu"
+"Text size" = "Rozmiar tekstu"
+"Text style" = "Styl tekstu"
+"Text styles" = "Style tekstu"
+"Texts" = "Teksty"
+"Texture" = "Tekstura"
+"The canvas previews colors in sRGB; exported PNG, JPG and WebP files are tagged Display P3." = "Płótno wyświetla podgląd kolorów w sRGB; wyeksportowane pliki PNG, JPG i WebP są oznaczane profilem Display P3."
+"The destination document is unavailable. Nothing was imported." = "Dokument docelowy jest niedostępny. Nic nie zostało zaimportowane."
+"The destination document was closed. Nothing was imported." = "Dokument docelowy został zamknięty. Nic nie zostało zaimportowane."
+"The destination page was removed. Nothing was imported." = "Strona docelowa została usunięta. Nic nie zostało zaimportowane."
+"The file is deleted from the server: nobody can open or join it from there again, and this can't be undone. Copies that are open stay with whoever has them." = "Plik został usunięty z serwera: nikt nie może go już stamtąd otworzyć ani do niego dołączyć, a tej operacji nie można cofnąć. Otwarte kopie pozostają u ich posiadaczy."
+"The file now holds another library" = "Plik zawiera teraz inną bibliotekę"
+"The file now holds another library (\"{name}\")" = "Plik zawiera teraz inną bibliotekę („{name}”)"
+"The files you shared or published online from this computer. They stay on their server until you remove them." = "Pliki udostępnione lub opublikowane online z tego komputera. Pozostają na serwerze do momentu ich usunięcia."
+"The link carries the session's secret: share it only with people you invite." = "Link zawiera sekret sesji: udostępniaj go tylko osobom, które zapraszasz."
+"The name in your online files and on the server. The document inside keeps its own name." = "Nazwa w Twoich plikach online i na serwerze. Dokument wewnątrz zachowuje własną nazwę."
+"The selection uses several text styles: click to apply one" = "Zaznaczenie używa kilku stylów tekstu: kliknij, aby zastosować jeden"
+"The server deletes this file if nobody opens it before {date}." = "Serwer usunie ten plik, jeśli nikt go nie otworzy przed {date}."
+"The whole file" = "Cały plik"
+"Theme" = "Motyw"
+"There's no destination for that action" = "Brak miejsca docelowego dla tej akcji"
+"Thickness" = "Grubość"
+"This branch can't be reviewed: {e}" = "Tej gałęzi nie można przejrzeć: {e}"
+"This branch was merged or archived." = "Ta gałąź została scalona lub zarchiwizowana."
+"This computer only" = "Tylko ten komputer"
+"This computer remembers the owner token, so the file can be managed from the home screen's Online list. Copy it to manage the file from somewhere else: it is a password for this file and won't be shown again." = "Ten komputer pamięta token właściciela, więc plik może być zarządzany z listy Online na ekranie głównym. Skopiuj go, aby zarządzać plikiem z innego miejsca: jest to hasło do tego pliku i nie zostanie ponownie wyświetlone."
+"This condition is edited as an expression" = "Ten warunek jest edytowany jako wyrażenie"
+"This file" = "Ten plik"
+"This file has unsaved changes" = "Ten plik ma niezapisane zmiany"
+"This file uses fonts that aren't installed on this computer. Their text is drawn in a fallback font until you install them." = "Ten plik używa czcionek, które nie są zainstalowane na tym komputerze. Do czasu ich zainstalowania tekst jest wyświetlany czcionką zastępczą."
+"This file is on {server}, open only to you. Share it to let others in with a new code." = "Ten plik znajduje się na {server}, otwarty tylko dla Ciebie. Udostępnij go, aby wpuścić innych nowym kodem."
+"This frame is new on the branch." = "Ta ramka jest nowa w gałęzi."
+"This frame isn't on the branch." = "Tej ramki nie ma w gałęzi."
+"This server is open to the public: no key needed." = "Ten serwer jest otwarty publicznie: klucz nie jest wymagany."
+"This server needs its key: add ?key=… to the address (`figcraft-server key` prints it on the server's machine)." = "Ten serwer wymaga klucza: dodaj ?key=… do adresu (polecenie `figcraft-server key` wyświetla go na maszynie serwera)."
+"This server takes files only with its key: see Advanced." = "Ten serwer przyjmuje pliki tylko z kluczem: zobacz Zaawansowane."
+"Thumbs up" = "Kciuk w górę"
+"Tidy up" = "Uporządkuj"
+"Tile" = "Sąsiadująco"
+"Tile type" = "Typ kafelka"
+"Tint" = "Odcień barwny"
+"Title" = "Tytuł"
+"Title case" = "Jak W Tytule"
+"To share this library with your team, publish the file to a server (Share ▸ Publish to server…), then publish the library there." = "Aby udostępnić tę bibliotekę zespołowi, opublikuj plik na serwerze (Udostępnij ▸ Publikuj na serwerze…), a następnie opublikuj tam bibliotekę."
+"Toggle" = "Przełącz"
+"Toggle light/dark theme" = "Przełącz motyw jasny/ciemny"
+"Toggle visibility" = "Przełącz widoczność"
+"Tools" = "Narzędzia"
+"Top" = "Góra"
+"Top & bottom" = "Góra i dół"
+"Top left radius" = "Promień górnego lewego narożnika"
+"Top right radius" = "Promień górnego prawego narożnika"
+"Transform" = "Przekształć"
+"Triangle" = "Trójkąt"
+"Triangle arrow" = "Strzałka trójkątna"
+"Trigger" = "Wyzwalacz"
+"True" = "Prawda"
+"Truncate text" = "Utnij tekst"
+"Truncate with an ellipsis" = "Utnij tekst z wielokropkiem (…)"
+"Try again" = "Spróbuj ponownie"
+"Try another search or filter." = "Wypróbuj inne wyszukiwanie lub filtr."
+"Try another search, or browse templates." = "Spróbuj innego wyszukiwania lub przejrzyj szablony."
+"Try another word, or look at every kind." = "Wypróbuj inne słowo lub przejrzyj wszystkie typy."
+"Turn a layer into a component, reuse it, and change every copy at once" = "Przekształć warstwę w komponent, używaj jej ponownie i modyfikuj wszystkie kopie naraz"
+"Two digits" = "Dwie cyfry"
+"Type" = "Tekst"
+"Type settings" = "Ustawienia tekstu"
+"Type the join code you were given, or paste an invite link." = "Wpisz otrzymany kod dołączenia lub wklej link z zaproszeniem."
+"Typography" = "Typografia"
+"Underline" = "Podkreślenie"
+"Undo takes back only your own changes; what others changed since stays." = "Cofanie odwołuje tylko Twoje własne zmiany; modyfikacje wprowadzone przez innych pozostają."
+"Ungroup" = "Rozgrupuj"
+"Uniform" = "Jednolity"
+"Union" = "Suma zbiorów"
+"Unions" = "Sumy"
+"Unknown — treated as sRGB" = "Nieznany — traktowany jako sRGB"
+"Unread" = "Nieprzeczytane"
+"Unresolve" = "Cofnij rozwiązanie"
+"Unsaved changes" = "Niezapisane zmiany"
+"Unsaved changes in {names}. Save them before closing?" = "Niezapisane zmiany w: {names}. Zapisać je przed zamknięciem?"
+"Unsaved changes: save first ({save}), or close the tab with {alt}-click to discard" = "Niezapisane zmiany: najpierw zapisz ({save}) lub zamknij kartę z {alt}-kliknięciem, aby odrzucić"
+"Unsaved changes: save first, or close again with {key} to discard" = "Niezapisane zmiany: najpierw zapisz lub naciśnij ponownie {key}, aby odrzucić"
+"Up" = "W górę"
+"Update plugin" = "Zaktualizuj wtyczkę"
+"Update" = "Aktualizuj"
+"Update from main" = "Zaktualizuj z gałęzi głównej"
+"Update from selection" = "Zaktualizuj z zaznaczenia"
+"Updated {components} and {styles}" = "Zaktualizowano {components} i {styles}"
+"Updated {name}" = "Zaktualizowano {name}"
+"Updating the graphics driver often helps. To use OpenGL only, start FigCraft from a Command Prompt with:" = "Aktualizacja sterownika graficznego często pomaga. Aby używać tylko OpenGL, uruchom FigCraft z wiersza poleceń za pomocą:"
+"Updating the graphics driver often helps. WGPU_BACKEND (vulkan, gl, metal) names another graphics API to try." = "Aktualizacja sterownika graficznego często pomaga. Zmienna WGPU_BACKEND (vulkan, gl, metal) pozwala wybrać inne graficzne API do wypróbowania."
+"Uploads this file to a FigCraft server and keeps this tab in sync with it. You get a link to edit and a link to view." = "Przesyła ten plik na serwer FigCraft i synchronizuje tę kartę na bieżąco. Otrzymujesz link do edycji oraz link do podglądu."
+"Uppercase" = "WIELKIE LITERY"
+"Use a fixed value" = "Użyj stałej wartości"
+"Use an expression, e.g. count + 1" = "Użyj wyrażenia, np. count + 1"
+"Use as mask" = "Użyj jako maski"
+"Use auto layout" = "Użyj automatycznego układu"
+"Use number keys for opacity" = "Użyj klawiszy numerycznych dla nieprzezroczystości"
+"Use the .figcraft or .fig extension." = "Użyj rozszerzenia .figcraft lub .fig."
+"Use the layer's fill" = "Użyj wypełnienia warstwy"
+"Used in {files} · {instances}" = "Używane w {files} · {instances}"
+"Username" = "Nazwa użytkownika"
+"Value" = "Wartość"
+"Uses variables: each layer shows them in its own mode" = "Używa zmiennych: każda warstwa wyświetla je we własnym trybie"
+"Variable" = "Zmienna"
+"Variable collections" = "Kolekcje zmiennych"
+"Variable modes" = "Tryby zmiennych"
+"Variable width" = "Zmienna szerokość"
+"Variables" = "Zmienne"
+"Variables JSON…" = "JSON ze zmiennymi…"
+"Variables store reusable values (colours, numbers, strings, booleans) with modes such as Light and Dark." = "Zmienne przechowują wartości wielokrotnego użytku (kolory, liczby, teksty, wartości logiczne) z trybami takimi jak Jasny i Ciemny."
+"Variant" = "Wariant"
+"Vector" = "Wektor"
+"Vectors" = "Wektory"
+"Version" = "Wersja"
+"Version history" = "Historia wersji"
+"Version {version}" = "Wersja {version}"
+"Version {v} · {components} · {styles} · {variables}" = "Wersja {v} · {components} · {styles} · {variables}"
+"Vertical" = "Pionowo"
+"Vertical align" = "Wyrównanie pionowe"
+"Vertical hex" = "Pionowy sześciokąt"
+"Vertical padding" = "Marginesy pionowe"
+"Vertical spacing" = "Odstępy pionowe"
+"Vertical trim" = "Przycinanie pionowe (vertical trim)"
+"View" = "Widok"
+"View link" = "Link do podglądu"
+"View link copied" = "Skopiowano link do podglądu"
+"View only" = "Tylko podgląd"
+"View only: you see every change as it happens but can't edit. Leave to keep a copy you can edit." = "Tylko podgląd: widzisz każdą zmianę w czasie rzeczywistym, ale nie możesz edytować. Opuść sesję, aby zachować kopię do edycji."
+"Viewing “{name}”" = "Podglądanie „{name}”"
+"Violet" = "Fiolet"
+"Visibility" = "Widoczność"
+"Visible" = "Widoczne"
+"Vivid" = "Żywe kolory"
+"WGPU_BACKEND is set and names the graphics API to use; unsetting it lets FigCraft choose." = "Zmienna WGPU_BACKEND jest ustawiona i określa używane API graficzne; jej usunięcie pozwala FigCraft dokonać wyboru."
+"Warm" = "Ciepły"
+"Watch" = "Zegarek"
+"Wavy" = "Falisty"
+"Web" = "Internet"
+"Websites" = "Strony internetowe"
+"WebSocket URL" = "Adres WebSocket URL"
+"WebSocket URL copied" = "Skopiowano adres WebSocket URL"
+"Wedge" = "Klin"
+"Weight" = "Grubość"
+"What you try here changes this preview and the code below, not the file" = "To, co wypróbujesz tutaj, zmienia ten podgląd i kod poniżej, a nie plik"
+"What changed since it was marked ready for dev" = "Co się zmieniło od czasu oznaczenia jako gotowe do wdrożenia"
+"What is wrong with this file? The server's operator gets your report." = "Co jest nie tak z tym plikiem? Administrator serwera otrzyma Twoje zgłoszenie."
+"What it's for" = "Do czego to służy"
+"What this changed from isn't known: it changed before FigCraft kept a copy of ready-for-dev frames. Resolve the change (or mark it ready again) to compare from now on." = "Nie wiadomo, w stosunku do czego zaszła zmiana: ramka zmieniła się, zanim FigCraft zaczął zapisywać kopię ramek gotowych do wdrożenia. Rozwiąż zmianę (lub oznacz ponownie jako gotowe), aby móc porównywać od teraz."
+"While hovering" = "Podczas najechania"
+"While pressing" = "Podczas naciskania"
+"White" = "Biały"
+"Who runs it, its terms and how long it keeps files" = "Kto zarządza serwerem, jego regulamin i czas przechowywania plików"
+"Why it changed" = "Dlaczego to się zmieniło"
+"Widget" = "Widżet"
+"Widgets" = "Widżety"
+"Width" = "Szerokość"
+"Width point" = "Punkt szerokości"
+"Width profile" = "Profil szerokości"
+"Wireframe kit" = "Zestaw makiet (Wireframe kit)"
+"With the layers' export settings" = "Z ustawieniami eksportu warstw"
+"Wrap" = "Owinięcie"
+"Wrap in new section" = "Zawiń w nową sekcję"
+"Yellow" = "Żółty"
+"Yesterday" = "Wczoraj"
+"You" = "Ty"
+"You'll get the shared file as a new tab and edit it together." = "Otrzymasz udostępniony plik jako nową kartę i będziecie go edytować wspólnie."
+"You're spotlighting: everyone follows your view" = "Wyróżniasz swój widok (spotlight): wszyscy podążają za Twoim widokiem"
+"Your copy of the file stays open" = "Twoja kopia pliku pozostaje otwarta"
+"Your copy stays open; the file stays on the server" = "Twoja kopia pozostaje otwarta; plik pozostaje na serwerze"
+"Your name" = "Twoje imię i nazwisko"
+"Your name in comments" = "Twoje imię w komentarzach"
+"Your system asks for reduced motion: animations stay off." = "Twój system preferuje ograniczony ruch: animacje pozostają wyłączone."
+"Z" = "Z"
+"Z to A" = "Od Z do A"
+"Zoom" = "Powiększenie"
+"Zoom around the pointer" = "Powiększaj wokół kursora"
+"Zoom device to fill window" = "Dopasuj urządzenie do okna z powiększeniem"
+"Zoom in" = "Powiększ"
+"Zoom out" = "Pomniejsz"
+"Zoom to 100%" = "Powiększ do 100%"
+"Zoom to 200%" = "Powiększ do 200%"
+"Zoom to 50%" = "Zmniejsz do 50%"
+"Zoom to fit" = "Dopasuj do okna"
+"Zoom to selection" = "Powiększaj do zaznaczenia"
+"Zoom tool: click to zoom in, drag an area" = "Narzędzie powiększenia: kliknij, aby przybliżyć, przeciągnij obszar"
+"Zoom tool: zoom out" = "Narzędzie powiększenia: oddal"
+"and {n} more" = { one = "i jeszcze {n}", few = "i jeszcze {n}", many = "i jeszcze {n}", other = "i jeszcze {n}" }
+"bleed marks" = "znaczniki spadu"
+"by {author}" = "autor: {author}"
+"call any command its access allows" = "wywołaj dowolne polecenie, na które zezwala dostęp"
+"call only: {commands}" = "wywołaj tylko: {commands}"
+"can edit the document" = "może edytować dokument"
+"conditional prototype actions nested too deeply were skipped" = "zbyt głęboko zagnieżdżone warunkowe akcje prototypu zostały pominięte"
+"conditional prototype actions with conditions that can't be evaluated were skipped" = "warunkowe akcje prototypu z warunkami niemożliwymi do obliczenia zostały pominięte"
+"connector label background was skipped: style data is missing" = "tło etykiety łącznika zostało pominięte: brak danych stylu"
+"connector label was skipped: background bounds are invalid" = "etykieta łącznika została pominięta: nieprawidłowe granice tła"
+"connector label was skipped: background transform is invalid" = "etykieta łącznika została pominięta: nieprawidłowe przekształcenie tła"
+"connector label was skipped: composed text transform is invalid" = "etykieta łącznika została pominięta: nieprawidłowe przekształcenie tekstu złożonego"
+"connector label was skipped: derived background bounds are missing" = "etykieta łącznika została pominięta: brak wyznaczonych granic tła"
+"connector label was skipped: derived text bounds are missing" = "etykieta łącznika została pominięta: brak wyznaczonych granic tekstu"
+"connector label was skipped: text bounds are invalid" = "etykieta łącznika została pominięta: nieprawidłowe granice tekstu"
+"connector label was skipped: text style data is missing" = "etykieta łącznika została pominięta: brak danych stylu tekstu"
+"connector label was skipped: text transform is invalid" = "etykieta łącznika została pominięta: nieprawidłowe przekształcenie tekstu"
+"connector labels were skipped" = "etykiety łączników zostały pominięte"
+"connector layers import as static frame/vector snapshots with labels when present; live endpoint bindings are not retained" = "warstwy łączników są importowane jako statyczne ramki/wektory z etykietami; aktywne punkty końcowe nie są zachowywane"
+"connector snapshot vector data is missing; connector was left empty" = "brak danych wektorowych łącznika; łącznik pozostał pusty"
+"connectors whose ends can't be placed are empty" = "łączniki, których końców nie można umieścić, pozostają puste"
+"crop marks" = "Znaczniki przycięcia"
+"damaged vector geometry was skipped" = "uszkodzona geometria wektorowa została pominięta"
+"damaged vector networks import as outlines" = "uszkodzone sieci wektorowe są importowane jako kontury"
+"development: {path}" = "wersja rozwojowa: {path}"
+"document children other than pages were skipped" = "elementy podrzędne dokumentu inne niż strony zostały pominięte"
+"duplicate grid track sizing entries use equal tracks" = "zduplikowane wpisy rozmiaru siatki używają równych pasów"
+"e.g. count + 1" = "np. count + 1"
+"e.g. count >= 3 and not done" = "np. count >= 3 and not done"
+"elbowed and curved connectors without a saved path import as straight lines" = "złamane i zakrzywione łączniki bez zapisanej ścieżki są importowane jako linie proste"
+"entries without a node type were skipped" = "wpisy bez typu węzła zostały pominięte"
+"figcraft:// links from a browser, chat or email open this app and join the session." = "linki figcraft:// z przeglądarki, czatu lub poczty e-mail otwierają tę aplikację i dołączają do sesji."
+"filled areas of a vector with their own fill use the layer's fill" = "wypełnione obszary wektora z własnym wypełnieniem używają wypełnienia warstwy"
+"from {server}" = "z serwera {server}"
+"gamepad triggers without exactly one known controller button were skipped" = "wyzwalacze kontrolera bez dokładnie jednego znanego przycisku zostały pominięte"
+"grid track list exceeds 1000 entries; the tracks use the default equal sizing" = "lista ścieżek siatki przekracza 1000 pozycji; ścieżki używają domyślnego równego rozmiaru"
+"grid track sizing is unsupported or malformed; affected tracks use equal sizing" = "rozmiar ścieżek siatki jest nieobsługiwany lub nieprawidłowy; dotknięte ścieżki używają równego rozmiaru"
+"grid track sizing list exceeds 1000 entries; the tracks use the default equal sizing" = "lista rozmiarów ścieżek siatki przekracza 1000 pozycji; ścieżki używają domyślnego równego rozmiaru"
+"hidden" = "ukryty"
+"iOS" = "iOS"
+"image filters are ambiguous because both filter containers are present; filter conversion was skipped" = "filtry obrazu są niejednoznaczne, ponieważ obecne są oba kontenery filtrów; konwersja filtrów została pominięta"
+"image filters use FigCraft's approximate renderer" = "filtry obrazu używają przybliżonego renderera FigCraft"
+"instance swap properties whose default component isn't in the file were skipped" = "właściwości podmiany instancji, których domyślny komponent nie znajduje się w pliku, zostały pominięte"
+"instances inside their own main component were imported as frames" = "instancje wewnątrz własnego głównego komponentu zostały zaimportowane jako ramki"
+"instances of components that aren't in the file show no layers" = "instancje komponentów, których nie ma w pliku, nie pokazują żadnych warstw"
+"instances of components that aren't in the file were imported as frames" = "instancje komponentów, których nie ma w pliku, zostały zaimportowane jako ramki"
+"instances that would nest a component inside itself were imported as frames" = "instancje zagnieżdżające komponent wewnątrz samego siebie zostały zaimportowane jako ramki"
+"instances without a main component were imported as empty frames" = "instancje bez głównego komponentu zostały zaimportowane jako puste ramki"
+"invalid internal .fig text path data was ignored" = "nieprawidłowe wewnętrzne dane ścieżki tekstu .fig zostały zignorowane"
+"invalid or oversized vector networks import as outlines" = "nieprawidłowe lub przewymiarowane sieci wektorowe są importowane jako kontury"
+"invalid or oversized vector path data was skipped" = "nieprawidłowe lub przewymiarowane dane ścieżki wektorowej zostały pominięte"
+"just now" = "przed chwilą"
+"key triggers without a supported key were skipped" = "wyzwalacze klawiszy z nieobsługiwanym klawiszem zostały pominięte"
+"key up triggers import as key presses" = "wyzwalacze zwolnienia klawisza są importowane jako naciśnięcia klawiszy"
+"layers without a position were placed at their parent's origin" = "warstwy bez określonej pozycji zostały umieszczone w punkcie początkowym rodzica"
+"layers without a type were skipped" = "warstwy bez typu zostały pominięte"
+"legacy image filter container is unsupported; filter conversion was skipped" = "przestarzały kontener filtrów obrazu jest nieobsługiwany; konwersja filtrów została pominięta"
+"locked" = "Zablokowane"
+"malformed image filters container was skipped" = "nieprawidłowy kontener filtrów obrazu został pominięty"
+"malformed image paintFilter container was skipped" = "nieprawidłowy kontener filtrów malowania (paintFilter) został pominięty"
+"malformed slot content assignment was skipped" = "nieprawidłowe przypisanie zawartości gniazda zostało pominięte"
+"no bleed" = "brak spadu"
+"nobody else here yet" = "nikogo innego tu jeszcze nie ma"
+"non-default slot settings are not represented and were skipped" = "niedomyślne ustawienia gniazd nie są reprezentowane i zostały pominięte"
+"now" = "teraz"
+"only in a text style or variable" = "tylko w stylu tekstu lub zmiennej"
+"or" = "lub"
+"point stroke joins were preserved; dashed or variable-width strokes render with the layer join" = "połączenia punktów obrysu zostały zachowane; obrysy przerywane lub o zmiennej szerokości renderują się z łączeniem warstwy"
+"preferred slot component keys cannot be resolved to file nodes and were skipped" = "klucze preferowanych komponentów gniazda nie mogą zostać dopasowane do węzłów pliku i zostały pominięte"
+"prototype actions of unknown types were skipped" = "akcje prototypu o nieznanych typach zostały pominięte"
+"prototype actions without a destination in the file were skipped" = "akcje prototypu bez miejsca docelowego w pliku zostały pominięte"
+"prototype expressions on variables that aren't in the variables JSON were skipped" = "wyrażenia prototypu operujące na zmiennych, których nie ma w pliku JSON ze zmiennymi, zostały pominięte"
+"prototype expressions with unsupported functions were skipped" = "wyrażenia prototypu z nieobsługiwanymi funkcjami zostały pominięte"
+"prototype interactions without supported actions were skipped" = "interakcje prototypu bez obsługiwanych akcji zostały pominięte"
+"prototype navigations of unknown types were skipped" = "nawigacje prototypu o nieznanych typach zostały pominięte"
+"prototype transitions of unknown types play instantly" = "przejścia prototypu o nieznanych typach odtwarzają się natychmiast"
+"prototype triggers of unknown types were skipped" = "wyzwalacze prototypu o nieznanych typach zostały pominięte"
+"put a widget on the canvas" = "umieść widżet na płótnie"
+"read and edit the document" = "odczytuj i edytuj dokument"
+"read the document" = "odczytuj dokument"
+"reads the document" = "odczytuje dokument"
+"set-variable actions on variables that aren't in the variables JSON were skipped" = "akcje set-variable operujące na zmiennych, których nie ma w pliku JSON ze zmiennymi, zostały pominięte"
+"set-variable actions with values that can't be evaluated were skipped" = "akcje set-variable z wartościami, których nie można obliczyć, zostały pominięte"
+"set-variable actions with values that don't fit the variable were skipped" = "akcje set-variable z wartościami niepasującymi do zmiennej zostały pominięte"
+"set-variable actions without a value were skipped" = "akcje set-variable bez wartości zostały pominięte"
+"set-variable-mode actions on collections or modes that aren't in the variables JSON were skipped" = "akcje set-variable-mode dla kolekcji lub trybów, których nie ma w pliku JSON ze zmiennymi, zostały pominięte"
+"slot content assignment target is missing or is not slot content" = "cel przypisania zawartości gniazda nie istnieje lub nie jest zawartością gniazda"
+"slot content assignment uses the empty GUID sentinel and was skipped" = "przypisanie zawartości gniazda używa pustego identyfikatora GUID i zostało pominięte"
+"slot layers without a matching slot property were imported as frames" = "warstwy gniazd bez pasującej właściwości gniazda zostały zaimportowane jako ramki"
+"some vector points refer to point settings missing from the file; they use the layer's joins and plain corners" = "niektóre punkty wektorowe odwołują się do ustawień punktów brakujących w pliku; używają połączeń warstwy i zwykłych narożników"
+"some vector segments refer to style settings missing from the file; they use the layer's stroke" = "niektóre segmenty wektorowe odwołują się do ustawień stylu brakujących w pliku; używają obrysu warstwy"
+"stale or invalid grid track sizing entries were ignored" = "nieaktualne lub nieprawidłowe wpisy rozmiarów ścieżek siatki zostały zignorowane"
+"stars and polygons without point counts or geometry use the default point count" = "gwiazdy i wielokąty bez określonej liczby wierzchołków lub geometrii używają domyślnej liczby punktów"
+"style settings of some vector segments aren't supported; those segments use the layer's stroke" = "ustawienia stylu niektórych segmentów wektorowych nie są obsługiwane; segmenty te używają obrysu warstwy"
+"text path underline or strikethrough decoration is not rendered" = "podkreślenie lub przekreślenie tekstu na ścieżce nie jest renderowane"
+"text style overrides refer to missing table entries" = "nadpisania stylu tekstu odwołują się do brakujących wpisów w tabeli"
+"the file has no pages" = "plik nie zawiera stron"
+"the plugin" = "wtyczka"
+"the variables JSON has no `variableCollections` (expected the local variables response) and was ignored" = "plik JSON ze zmiennymi nie zawiera `variableCollections` (oczekiwano odpowiedzi ze zmiennymi lokalnymi) i został zignorowany"
+"this session only" = "tylko ta sesja"
+"unknown component property types were skipped" = "nieznane typy właściwości komponentu zostały pominięte"
+"variable aliases to variables that aren't in the variables JSON (or of another type) were skipped" = "aliasy zmiennych wskazujące na zmienne nieobecne w pliku JSON ze zmiennymi (lub innego typu) zostały pominięte"
+"variable bindings to properties the layer doesn't have were skipped" = "powiązania zmiennych z właściwościami, których warstwa nie posiada, zostały pominięte"
+"variable bindings to variables that aren't in the variables JSON (library variables) were skipped" = "powiązania zmiennych ze zmiennymi nieobecnymi w pliku JSON ze zmiennymi (zmienne biblioteki) zostały pominięte"
+"variable bindings were skipped: the file JSON has no variable definitions (pass the local variables JSON as `variables`, or embed its `meta` next to the file JSON)" = "powiązania zmiennych zostały pominięte: plik JSON nie zawiera definicji zmiennych (przekaż JSON zmiennych lokalnych jako `variables` lub osadź jego `meta` obok pliku JSON)"
+"variable bindings whose variable type doesn't fit the property were skipped" = "powiązania zmiennych, których typ nie pasuje do właściwości, zostały pominięte"
+"variable collections without modes were skipped" = "kolekcje zmiennych bez trybów zostały pominięte"
+"variable mode lookups in prototype expressions that aren't a variable and one of its modes were skipped" = "odwołania do trybu zmiennej w wyrażeniach prototypu niebędące zmienną i jednym z jej trybów zostały pominięte"
+"variable modes of collections that aren't in the file were skipped" = "tryby zmiennych dla kolekcji nieobecnych w pliku zostały pominięte"
+"variable modes of collections that aren't in the variables JSON were skipped" = "tryby zmiennych dla kolekcji nieobecnych w pliku JSON ze zmiennymi zostały pominięte"
+"variable values that don't match their type (or composed colours) were skipped" = "wartości zmiennych niezgodne ze swoim typem (lub złożone kolory) zostały pominięte"
+"variables of unknown types were skipped" = "zmienne o nieznanych typach zostały pominięte"
+"variables whose collection isn't in the variables JSON were skipped" = "zmienne, których kolekcji nie ma w pliku JSON ze zmiennymi, zostały pominięte"
+"variables without readable values were skipped" = "zmienne bez czytelnych wartości zostały pominięte"
+"vector points with unknown stroke joins use the layer join" = "punkty wektorowe z nieznanymi połączeniami obrysu używają połączenia warstwy"
+"vectors without geometry are empty" = "wektory bez geometrii są puste"
+"vectors without geometry are empty (export the file JSON with geometry=paths)" = "wektory bez geometrii są puste (wyeksportuj plik JSON z opcją geometry=paths)"
+"very long text was cut to 1,048,576 characters" = "bardzo długi tekst został przycięty do 1 048 576 znaków"
+"very long vector paths were skipped" = "bardzo długie ścieżki wektorowe zostały pominięte"
+"video actions are not supported and were skipped" = "akcje wideo nie są obsługiwane i zostały pominięte"
+"video triggers are not supported and were skipped" = "wyzwalacze wideo nie są obsługiwane i zostały pominięte"
+"yesterday" = "wczoraj"
+"{instances} in {files}" = "{instances} w {files}"
+"{language}: draft translation, waiting for a native speaker's review." = "{language}: wersja robocza tłumaczenia, oczekuje na weryfikację przez native speakera."
+"{length} bleed" = "spad {length}"
+"{month} {day}, {year}" = "{day} {month} {year}"
+"{name} cleared from the list" = "Usunięto {name} z listy"
+"{name} is forgotten on this computer; the file stays on {server}" = "{name} usunięto z pamięci tego komputera; plik pozostaje na {server}"
+"{name} is on the server." = "{name} znajduje się na serwerze."
+"{name} is spotlighting" = "{name} prezentuje widok (spotlight)"
+"{name} is too large to open in the browser (over 512 MB)." = "Plik {name} jest za duży, aby otworzyć go w przeglądarce (ponad 512 MB)."
+"{name}\nClick to apply to the selection" = "{name}\nKliknij, aby zastosować do zaznaczenia"
+"{name}\nDrag onto the canvas, or click to place in the middle of the view.\nHold Alt (Option) while dropping onto an instance to swap it." = "{name}\nPrzeciągnij na płótno lub kliknij, aby umieścić na środku widoku.\nPrzytrzymaj klawisz Alt (Option) podczas upuszczania na instancję, aby ją zamienić."
+"{name} (from {library})" = "{name} (z biblioteki {library})"
+"{name} (you)" = "{name} (Ty)"
+"{name} ({layers} layers)" = "{name} ({layers} warstw)"
+"{name} ({tag}): {min} – {max}, default {default}. Double-click the slider to go back to the style's value; Escape while dragging cancels." = "{name} ({tag}): {min} – {max}, domyślnie {default}. Kliknij dwukrotnie suwak, aby przywrócić wartość stylu; naciśnięcie Escape podczas przeciągania anuluje."
+"{name} from {path}" = "{name} z {path}"
+"{name} was removed from the server" = "Plik {name} został usunięty z serwera"
+"{name} · deleted on main" = "{name} · usunięto w gałęzi głównej"
+"{name} · deleted on the branch" = "{name} · usunięto w gałęzi"
+"{name} · not published" = "{name} · nieopublikowane"
+"{name} · on a server" = "{name} · na serwerze"
+"{name} · published version {v}" = "{name} · opublikowana wersja {v}"
+"{name} · version {v} on the server" = "{name} · wersja {v} na serwerze"
+"{name}, in a live session" = "{name}, w sesji na żywo"
+"{name}, online, open only to you" = "{name}, online, otwarty tylko dla Ciebie"
+"{name}, {kind}, {w} by {h}, selected" = "{name}, {kind}, {w} × {h}, zaznaczono"
+"{n} added" = { one = "Dodano {n}", few = "Dodano {n}", many = "Dodano {n}", other = "Dodano {n}" }
+"{n} autosave versions" = { one = "{n} wersja autozapisu", few = "{n} wersje autozapisu", many = "{n} wersji autozapisu", other = "{n} wersji autozapisu" }
+"{n} changed" = { one = "Zmieniono {n}", few = "Zmieniono {n}", many = "Zmieniono {n}", other = "Zmieniono {n}" }
+"{n} columns" = { one = "{n} kolumna", few = "{n} kolumny", many = "{n} kolumn", other = "{n} kolumn" }
+"{n} components" = { one = "{n} komponent", few = "{n} komponenty", many = "{n} komponentów", other = "{n} komponentów" }
+"{n} components and styles have newer versions" = { one = "{n} komponent lub styl ma nowszą wersję", few = "{n} komponenty i style mają nowsze wersje", many = "{n} komponentów i stylów ma nowsze wersje", other = "{n} komponentów i stylów ma nowsze wersje" }
+"{n} conflicts to resolve" = { one = "{n} konflikt do rozwiązania", few = "{n} konflikty do rozwiązania", many = "{n} konfliktów do rozwiązania", other = "{n} konfliktów do rozwiązania" }
+"{n} days ago" = { one = "{n} dzień temu", few = "{n} dni temu", many = "{n} dni temu", other = "{n} dni temu" }
+"{n} files" = { one = "{n} plik", few = "{n} pliki", many = "{n} plików", other = "{n} plików" }
+"{n} hours ago" = { one = "{n} godzinę temu", few = "{n} godziny temu", many = "{n} godzin temu", other = "{n} godzin temu" }
+"{n} instances" = { one = "{n} instancja", few = "{n} instancje", many = "{n} instancji", other = "{n} instancji" }
+"{n} layers" = { one = "{n} warstwa", few = "{n} warstwy", many = "{n} warstw", other = "{n} warstw" }
+"{n} layers as one file" = { one = "{n} warstwa jako jeden plik", few = "{n} warstwy jako jeden plik", many = "{n} warstw jako jeden plik", other = "{n} warstw jako jeden plik" }
+"{n} layers selected" = { one = "Zaznaczono {n} warstwę", few = "Zaznaczono {n} warstwy", many = "Zaznaczono {n} warstw", other = "Zaznaczono {n} warstw" }
+"{n} layers · {parts}" = { one = "{n} warstwa · {parts}", few = "{n} warstwy · {parts}", many = "{n} warstw · {parts}", other = "{n} warstw · {parts}" }
+"{n} matches" = { one = "{n} dopasowanie", few = "{n} dopasowania", many = "{n} dopasowań", other = "{n} dopasowań" }
+"{n} minutes ago" = { one = "{n} minutę temu", few = "{n} minuty temu", many = "{n} minut temu", other = "{n} minut temu" }
+"{n} months ago" = { one = "{n} miesiąc temu", few = "{n} miesiące temu", many = "{n} miesięcy temu", other = "{n} miesięcy temu" }
+"{n} more notes omitted from this report" = { one = "Pominięto jeszcze {n} notatkę w tym raporcie", few = "Pominięto jeszcze {n} notatki w tym raporcie", many = "Pominięto jeszcze {n} notatek w tym raporcie", other = "Pominięto jeszcze {n} notatek w tym raporcie" }
+"{n} of {total}" = "{n} z {total}"
+"{n} people joined" = { one = "Dołączyła {n} osoba", few = "Dołączyły {n} osoby", many = "Dołączyło {n} osób", other = "Dołączyło {n} osób" }
+"{n} preferred components" = { one = "{n} preferowany komponent", few = "{n} preferowane komponenty", many = "{n} preferowanych komponentów", other = "{n} preferowanych komponentów" }
+"{n} ready" = { one = "{n} gotowy", few = "{n} gotowe", many = "{n} gotowych", other = "{n} gotowych" }
+"{n} removed" = { one = "Usunięto {n}", few = "Usunięto {n}", many = "Usunięto {n}", other = "Usunięto {n}" }
+"{n} replies" = { one = "{n} odpowiedź", few = "{n} odpowiedzi", many = "{n} odpowiedzi", other = "{n} odpowiedzi" }
+"{n} rows" = { one = "{n} wiersz", few = "{n} wiersze", many = "{n} wierszy", other = "{n} wierszy" }
+"{n} styles" = { one = "{n} styl", few = "{n} style", many = "{n} stylów", other = "{n} stylów" }
+"{n} text layers" = { one = "{n} warstwa tekstowa", few = "{n} warstwy tekstowe", many = "{n} warstw tekstowych", other = "{n} warstw tekstowych" }
+"{n} variables" = { one = "{n} zmienna", few = "{n} zmienne", many = "{n} zmiennych", other = "{n} zmiennych" }
+"{n} weeks ago" = { one = "{n} tydzień temu", few = "{n} tygodnie temu", many = "{n} tygodni temu", other = "{n} tygodni temu" }
+"{n} years ago" = { one = "{n} rok temu", few = "{n} lata temu", many = "{n} lat temu", other = "{n} lat temu" }
+"{n}d" = "{n} d"
+"{n}h" = "{n} godz."
+"{n}m" = "{n} min"
+"{n}w" = "{n} tyg."
+"{page}, nothing selected" = "{page}, nic nie zaznaczono"
+"{profile} (current)" = "{profile} (bieżący)"
+"{property} is its value; {property ? \"a\" : \"b\"} picks a string. Other {…} stays as written." = "{property} to jej wartość; {property ? \"a\" : \"b\"} wybiera tekst. Pozostałe wyrażenia {…} pozostają bez zmian."
+"{server} can't say what became of your files (it is older than this app)." = "{server} nie może określić stanu Twoich plików (jest starszy niż ta aplikacja)."
+"{server} · No longer on the server" = "{server} · Brak na serwerze"
+"{server} · {shared} · Opened {date}" = "{server} · {shared} · Otwarto {date}"
+"{tool}  hold {key}" = "{tool}  przytrzymaj {key}"
+"{value} isn't a colour" = "Wartość {value} nie jest kolorem"
+"{when} · edited" = "{when} · edytowano"
+"← ↑ → ↓" = "← ↑ → ↓"
+"← → ↑ ↓" = "← → ↑ ↓"
+"←" = "←"
+"→, Space or N" = "→, Spacja lub N"
+"↵" = "↵"
+"⇥ / ⇧⇥" = "⇥ / ⇧⇥"
+"⌘ arrows" = "⌘ strzałki"
+"⌘ click" = "⌘ kliknięcie"
+"⌘ scroll" = "⌘ przewijanie"
+"⌥ drag" = "⌥ przeciągnięcie"
+
+[commands]
+"align.bottom" = "Wyrównaj do dołu"
+"align.hcenter" = "Wyrównaj poziomo do środka"
+"align.left" = "Wyrównaj do lewej"
+"align.right" = "Wyrównaj do prawej"
+"align.top" = "Wyrównaj do góry"
+"align.vcenter" = "Wyrównaj pionowo do środka"
+"annotation.add" = "Dodaj adnotację"
+"annotation.addCategory" = "Dodaj kategorię adnotacji"
+"annotation.categories" = "Kategorie adnotacji"
+"annotation.edit" = "Edytuj adnotację"
+"annotation.editCategory" = "Edytuj kategorię adnotacji"
+"annotation.list" = "Lista adnotacji"
+"annotation.remove" = "Usuń adnotację"
+"annotation.removeCategory" = "Usuń kategorię adnotacji"
+"app.actions" = "Akcje"
+"app.preferences" = "Preferencje"
+"arrange.back" = "Przesuń na sam spód"
+"arrange.backward" = "Przesuń do tyłu"
+"arrange.forward" = "Przesuń do przodu"
+"arrange.front" = "Przesuń na sam wierzch"
+"arrange.packH" = "Upakuj w poziomie"
+"arrange.packV" = "Upakuj w pionie"
+"arrange.roundToPixels" = "Zaokrąglij do pikseli"
+"arrange.spacing" = "Odstępy"
+"arrange.tidy" = "Uporządkuj"
+"board.connector" = "Łącznik"
+"board.ink" = "Pociągnięcie markera"
+"board.label" = "Etykieta łącznika"
+"board.nextSticky" = "Następna karteczka"
+"board.setColor" = "Kolor na tablicy"
+"board.setStyle" = "Styl na tablicy"
+"board.shape" = "Kształt z tekstem"
+"board.stamp" = "Pieczątka"
+"board.sticky" = "Karteczka"
+"bool.exclude" = "Wyklucz zaznaczenie"
+"bool.flatten" = "Spłaszcz operację logiczną"
+"bool.intersect" = "Część wspólna zaznaczenia"
+"bool.subtract" = "Odejmij zaznaczenie"
+"bool.union" = "Połącz zaznaczenie"
+"branch.archive" = "Zarchiwizuj gałąź"
+"branch.create" = "Utwórz gałąź"
+"branch.list" = "Lista gałęzi"
+"branch.merge" = "Scal gałąź"
+"branch.open" = "Otwórz gałąź"
+"branch.review" = "Przejrzyj gałąź"
+"branch.updateFromMain" = "Zaktualizuj z gałęzi głównej"
+"codeConnect.export" = "Eksportuj połączenia kodu"
+"codeConnect.import" = "Importuj połączenia kodu"
+"codeConnect.remove" = "Odłącz od kodu"
+"codeConnect.set" = "Połącz z kodem"
+"collab.cursor" = "Pokaż kursor na pozycji"
+"collab.cursorChat" = "Czat kursora"
+"collab.diff" = "Pokaż zmiany synchronizacji"
+"collab.files" = "Twoje pliki online"
+"collab.follow" = "Obserwuj"
+"collab.forgetFile" = "Zapomnij plik online"
+"collab.host" = "Rozpocznij sesję na żywo"
+"collab.join" = "Dołącz do sesji na żywo"
+"collab.leave" = "Opuść sesję na żywo"
+"collab.manageFile" = "Zarządzaj opublikowanym plikiem"
+"collab.openFile" = "Otwórz plik online"
+"collab.peers" = "Osoby w tym pliku"
+"collab.publish" = "Opublikuj na serwerze"
+"collab.recoverFile" = "Odzyskaj plik online"
+"collab.registerLinks" = "Otwieraj linki z zaproszeniem w FigCraft"
+"collab.removePerson" = "Usuń z sesji"
+"collab.report" = "Zgłoś plik operatorowi serwera"
+"collab.serverInfo" = "Informacje o serwerze"
+"collab.share" = "Udostępnij z kodem dołączenia"
+"collab.spotlight" = "Wyróżnij mój widok"
+"collab.stop" = "Zatrzymaj sesję na żywo"
+"command.batch" = "Wykonaj serię poleceń"
+"comment.add" = "Dodaj komentarz"
+"comment.delete" = "Usuń komentarz"
+"comment.edit" = "Edytuj komentarz"
+"comment.link" = "Kopiuj link do komentarza"
+"comment.list" = "Lista komentarzy"
+"comment.markRead" = "Oznacz komentarz jako przeczytany"
+"comment.move" = "Przenieś komentarz"
+"comment.next" = "Następny komentarz"
+"comment.open" = "Otwórz komentarz"
+"comment.people" = "Osoby w komentarzach"
+"comment.react" = "Zareaguj na komentarz"
+"comment.reply" = "Odpowiedz na komentarz"
+"comment.resolve" = "Rozwiąż komentarz"
+"comment.zoom" = "Powiększ do komentarzy"
+"component.addProperty" = "Dodaj właściwość komponentu"
+"component.addVariant" = "Dodaj wariant"
+"component.bindProperty" = "Powiąż warstwę z właściwością"
+"component.combineVariants" = "Połącz jako warianty"
+"component.create" = "Utwórz komponent"
+"component.createMultiple" = "Utwórz wiele komponentów"
+"component.deleteProperty" = "Usuń właściwość komponentu"
+"component.detach" = "Odłącz instancję"
+"component.editProperty" = "Edytuj właściwość komponentu"
+"component.exposeInstance" = "Udostępnij zagnieżdżoną instancję"
+"component.goToMain" = "Przejdź do głównego komponentu"
+"component.hideWhenPublishing" = "Ukryj podczas publikowania"
+"component.list" = "Lista komponentów"
+"component.makeSlot" = "Utwórz gniazdo (Slot)"
+"component.playground" = "Środowisko testowe komponentu (Playground)"
+"component.properties" = "Właściwości komponentu"
+"component.pushChanges" = "Zastosuj zmiany w głównym komponencie"
+"component.removeSlot" = "Usuń gniazdo"
+"component.resetInstance" = "Zresetuj wszystkie zmiany"
+"component.resetOverride" = "Zresetuj zmianę"
+"component.restoreMain" = "Przywróć główny komponent"
+"dev.compare" = "Porównaj zmiany"
+"dev.focus" = "Widok skupienia"
+"dev.resolveChange" = "Rozwiąż zmianę"
+"dev.unfocus" = "Wyjdź z widoku skupienia"
+"devResource.add" = "Dodaj zasób programistyczny"
+"devResource.edit" = "Edytuj zasób programistyczny"
+"devResource.list" = "Lista zasobów programistycznych"
+"devResource.remove" = "Usuń zasób programistyczny"
+"distribute.horizontal" = "Rozmieść równe odstępy poziome"
+"distribute.vertical" = "Rozmieść równe odstępy pionowe"
+"doc.home" = "Ekran główny"
+"doc.list" = "Lista dokumentów"
+"doc.nextTab" = "Następna karta"
+"doc.previousTab" = "Poprzednia karta"
+"doc.switch" = "Przełącz dokument"
+"edit.copy" = "Kopiuj"
+"edit.copyAsCss" = "Kopiuj jako CSS"
+"edit.copyAsPng" = "Kopiuj jako PNG"
+"edit.copyAsSvg" = "Kopiuj jako SVG"
+"edit.copyAsText" = "Kopiuj jako tekst"
+"edit.copyLink" = "Kopiuj łącze do zaznaczenia"
+"edit.copyProperties" = "Kopiuj właściwości"
+"edit.cut" = "Wytnij"
+"edit.delete" = "Usuń"
+"edit.duplicate" = "Powiel"
+"edit.findReplace" = "Znajdź i zamień…"
+"edit.paste" = "Wklej"
+"edit.pasteDesignLayers" = "Wklej warstwy projektu"
+"edit.pasteOver" = "Wklej na zaznaczenie"
+"edit.pasteProperties" = "Wklej właściwości"
+"edit.pasteReplace" = "Wklej, aby zastąpić"
+"edit.pickColor" = "Wybierz kolor"
+"edit.redo" = "Ponów"
+"edit.repeat" = "Powtórz ostatnie polecenie"
+"edit.setDefaultProperties" = "Ustaw właściwości domyślne"
+"edit.undo" = "Cofnij"
+"effect.add" = "Dodaj efekt"
+"effect.move" = "Przenieś efekt"
+"effect.remove" = "Usuń efekt"
+"effect.set" = "Ustaw efekt"
+"export.add" = "Dodaj ustawienie eksportu"
+"export.remove" = "Usuń ustawienie eksportu"
+"export.update" = "Edytuj ustawienie eksportu"
+"file.close" = "Zamknij kartę"
+"file.colorProfile" = "Profil kolorów"
+"file.duplicate" = "Powiel plik"
+"file.export" = "Eksportuj…"
+"file.exportFramesPdf" = "Eksportuj ramki do PDF"
+"file.exportLayers" = "Eksportuj warstwy"
+"file.exportSvg" = "Eksportuj zaznaczenie jako SVG"
+"file.import" = "Importuj z pliku…"
+"file.new" = "Nowy plik projektu"
+"file.newBoard" = "Nowa tablica"
+"file.newFromTemplate" = "Nowy z szablonu"
+"file.open" = "Otwórz…"
+"file.openRecent" = "Otwórz ostatnie"
+"file.placeImage" = "Umieść obraz"
+"file.recover" = "Odzyskaj plik"
+"file.rename" = "Zmień nazwę pliku"
+"file.revert" = "Przywróć do zapisanego"
+"file.save" = "Zapisz"
+"file.saveAs" = "Zapisz jako…"
+"file.saveVersion" = "Zapisz w historii wersji…"
+"file.versionHistory" = "Pokaż historię wersji"
+"fill.add" = "Dodaj wypełnienie"
+"fill.move" = "Przenieś wypełnienie"
+"fill.pattern" = "Wypełnienie wzorem"
+"fill.remove" = "Usuń wypełnienie"
+"fill.set" = "Ustaw wypełnienie"
+"frame.create" = "Utwórz ramkę"
+"frame.presets" = "Lista presetów ramek"
+"frame.swapOrientation" = "Zmień orientację ramki"
+"grid.add" = "Dodaj siatkę układu"
+"grid.move" = "Przenieś siatkę układu"
+"grid.remove" = "Usuń siatkę układu"
+"guide.add" = "Dodaj prowadnicę"
+"guide.clear" = "Wyczyść prowadnice"
+"guide.move" = "Przesuń prowadnicę"
+"guide.remove" = "Usuń prowadnicę"
+"guide.select" = "Zaznacz prowadnicę"
+"help.about" = "O programie FigCraft"
+"help.gettingStarted" = "Wprowadzenie"
+"help.page" = "Strona pomocy"
+"help.shortcuts" = "Skróty klawiszowe"
+"image.adjust" = "Dostosuj obraz"
+"image.deletePreset" = "Usuń preset obrazu"
+"image.place" = "Umieść obraz"
+"image.presets" = "Presety obrazów"
+"image.savePreset" = "Zapisz preset obrazu"
+"inspect.assets" = "Zasoby do inspekcji"
+"inspect.code" = "Kod warstwy"
+"inspect.componentCode" = "Kod komponentu"
+"inspect.properties" = "Właściwości do inspekcji"
+"inspect.readyForDev" = "Gotowe do wdrożenia"
+"instance.create" = "Utwórz instancję"
+"instance.exposed" = "Udostępnione zagnieżdżone instancje"
+"instance.place" = "Umieść instancję"
+"instance.resetSlot" = "Zresetuj gniazdo"
+"instance.setProperties" = "Ustaw właściwości instancji"
+"instance.slotInsert" = "Wstaw do gniazda"
+"instance.swap" = "Podmień instancję"
+"instance.swapAt" = "Podmień instancję w punkcie"
+"layers.collapseAll" = "Zwiń wszystkie warstwy"
+"layout.add" = "Dodaj automatyczny układ"
+"layout.remove" = "Usuń automatyczny układ"
+"layout.setTrack" = "Ustaw rozmiar linii siatki"
+"layout.suggest" = "Sugeruj automatyczny układ"
+"libraries.open" = "Biblioteki"
+"libraries.publish" = "Publikuj bibliotekę…"
+"library.acceptUpdates" = "Zaakceptuj aktualizacje biblioteki"
+"library.add" = "Dodaj bibliotekę"
+"library.aliasVariable" = "Utwórz alias zmiennej biblioteki"
+"library.applyStyle" = "Zastosuj styl biblioteki"
+"library.bindVariable" = "Powiąż zmienną biblioteki"
+"library.extendCollection" = "Rozszerz kolekcję biblioteki"
+"library.import" = "Importuj komponent biblioteki"
+"library.importVariable" = "Importuj zmienną biblioteki"
+"library.list" = "Lista bibliotek"
+"library.place" = "Umieść komponent biblioteki"
+"library.publish" = "Opublikuj bibliotekę"
+"library.publishToServer" = "Opublikuj bibliotekę na serwerze"
+"library.remove" = "Usuń bibliotekę"
+"library.setVariableMode" = "Ustaw tryb zmiennej biblioteki"
+"library.swap" = "Podmień bibliotekę"
+"library.swapAt" = "Podmień instancję na komponent biblioteki"
+"library.updates" = "Aktualizacje biblioteki"
+"library.usage" = "Użycie biblioteki"
+"measure.distances" = "Zmierz odległości"
+"measure.padding" = "Zmierz marginesy automatycznego układu"
+"node.create" = "Utwórz warstwę"
+"node.get" = "Pobierz warstwę"
+"node.reorder" = "Zmień kolejność warstwy"
+"node.reparent" = "Przenieś warstwę do"
+"node.set" = "Ustaw właściwości"
+"object.batchRename" = "Zmień nazwy wsadowo…"
+"object.convertToFrame" = "Konwertuj na ramkę"
+"object.convertToGroup" = "Konwertuj na grupę"
+"object.convertToSection" = "Konwertuj na sekcję"
+"object.flipH" = "Odbij w poziomie"
+"object.flipV" = "Odbij w pionie"
+"object.frameSelection" = "Umieść zaznaczenie w ramce"
+"object.group" = "Grupuj zaznaczenie"
+"object.hideOthers" = "Ukryj pozostałe warstwy"
+"object.mask" = "Użyj jako maski"
+"object.moveToPage" = "Przenieś na stronę"
+"object.opacityKeys" = "Krycie z klawiatury numerycznej"
+"object.rasterize" = "Rasteryzuj zaznaczenie"
+"object.releaseMask" = "Zwolnij maskę"
+"object.removeFill" = "Usuń wypełnienie"
+"object.removeFrame" = "Usuń ramkę"
+"object.removeStroke" = "Usuń obrys"
+"object.rename" = "Zmień nazwę"
+"object.resizeToFit" = "Dopasuj rozmiar do zawartości"
+"object.rotate180" = "Obróć o 180°"
+"object.rotateLeft" = "Obróć o 90° w lewo"
+"object.rotateRight" = "Obróć o 90° w prawo"
+"object.setThumbnail" = "Ustaw jako miniaturę"
+"object.swapFillStroke" = "Zamień wypełnienie i obrys"
+"object.toggleLock" = "Zablokuj/Odblokuj zaznaczenie"
+"object.toggleVisible" = "Pokaż/Ukryj zaznaczenie"
+"object.ungroup" = "Rozgrupuj zaznaczenie"
+"object.wrapInSection" = "Umieść w nowej sekcji"
+"page.add" = "Dodaj stronę"
+"page.delete" = "Usuń stronę"
+"page.duplicate" = "Powiel stronę"
+"page.list" = "Lista stron"
+"page.move" = "Przenieś stronę"
+"page.rename" = "Zmień nazwę strony"
+"page.select" = "Przejdź do strony"
+"page.setBackground" = "Tło strony"
+"paint.documentColors" = "Kolory dokumentu"
+"plugin.close" = "Zamknij panel wtyczki"
+"plugin.directory.install" = "Zainstaluj wtyczkę z katalogu"
+"plugin.directory.list" = "Przeglądaj katalog wtyczek"
+"plugin.directory.publish" = "Opublikuj wtyczkę w katalogu"
+"plugin.directory.unpublish" = "Wycofaj wtyczkę z katalogu"
+"plugin.event" = "Użyj kontrolki panelu wtyczki"
+"plugin.import" = "Importuj wtyczkę z manifestu…"
+"plugin.list" = "Lista wtyczek"
+"plugin.remove" = "Usuń wtyczkę"
+"plugin.run" = "Uruchom wtyczkę"
+"plugin.ui" = "Panel wtyczki"
+"plugins.manage" = "Zarządzaj wtyczkami…"
+"plugins.runLast" = "Uruchom ponownie ostatnią wtyczkę"
+"pref.autoSave" = "Zapisuj pliki automatycznie"
+"pref.highlightHover" = "Podświetlaj warstwy przy najechaniu myszą"
+"pref.keepTool" = "Zachowaj wybrane narzędzie po użyciu"
+"pref.language" = "Język interfejsu"
+"pref.nudge" = "Wartości przesunięcia (Nudge)"
+"pref.numberKeysOpacity" = "Klawisze numeryczne zmieniają krycie"
+"pref.publishServer" = "Serwer do udostępniania online"
+"pref.reduceMotion" = "Ogranicz animacje"
+"pref.renameDuplicates" = "Zmieniaj nazwy duplikatów"
+"pref.showDimensions" = "Pokazuj wymiary przy zaznaczeniu"
+"pref.userName" = "Twoja nazwa w komentarzach"
+"proto.action.add" = "Dodaj akcję prototypu"
+"proto.action.move" = "Zmień kolejność akcji prototypu"
+"proto.action.remove" = "Usuń akcję prototypu"
+"proto.action.set" = "Edytuj akcję prototypu"
+"proto.closePreview" = "Zamknij podgląd prototypu"
+"proto.conditional.addBlock" = "Dodaj else if / else"
+"proto.conditional.removeBlock" = "Usuń if / else if / else"
+"proto.conditional.setCondition" = "Edytuj warunek"
+"proto.evaluate" = "Oblicz wyrażenie prototypu"
+"proto.flow.add" = "Dodaj punkt początkowy przepływu"
+"proto.flow.remove" = "Usuń przepływ"
+"proto.flow.rename" = "Zmień nazwę przepływu"
+"proto.interaction.add" = "Dodaj interakcję"
+"proto.interaction.clear" = "Usuń wszystkie interakcje"
+"proto.interaction.remove" = "Usuń interakcję"
+"proto.interaction.set" = "Edytuj interakcję"
+"proto.present" = "Prezentuj"
+"proto.presentOptions" = "Opcje prezentacji"
+"proto.preview" = "Otwórz podgląd prototypu"
+"proto.settings" = "Ustawienia prototypu"
+"section.toggleContents" = "Ukryj/Pokaż zawartość sekcji"
+"select.add" = "Dodaj do zaznaczenia"
+"select.all" = "Zaznacz wszystko"
+"select.area" = "Zaznacz obszar"
+"select.byName" = "Zaznacz warstwy po nazwie"
+"select.children" = "Zaznacz elementy podrzędne"
+"select.inverse" = "Odwróć zaznaczenie"
+"select.layersAt" = "Warstwy w punkcie"
+"select.matching" = "Zaznacz pasujące warstwy"
+"select.next" = "Zaznacz następną warstwę"
+"select.none" = "Odznacz wszystko"
+"select.parent" = "Zaznacz element nadrzędny"
+"select.previous" = "Zaznacz poprzednią warstwę"
+"select.remove" = "Usuń z zaznaczenia"
+"select.sameEffect" = "Zaznacz elementy z takim samym efektem"
+"select.sameFill" = "Zaznacz elementy z takim samym wypełnieniem"
+"select.sameFont" = "Zaznacz elementy z taką samą czcionką"
+"select.sameInstance" = "Zaznacz taką samą instancję"
+"select.sameProperties" = "Zaznacz elementy z takimi samymi właściwościami"
+"select.sameStroke" = "Zaznacz elementy z takim samym obrysem"
+"select.sameText" = "Zaznacz elementy z takimi samymi właściwościami tekstu"
+"select.set" = "Zaznacz"
+"selection.applyColorStyle" = "Zastosuj styl koloru do zaznaczenia"
+"selection.colors" = "Kolory zaznaczenia"
+"selection.selectColor" = "Zaznacz warstwy z kolorem"
+"selection.setPaint" = "Zmień kolor zaznaczenia"
+"shape.arrow" = "Strzałka"
+"shape.ellipse" = "Elipsa"
+"shape.line" = "Linia"
+"shape.polygon" = "Wielokąt"
+"shape.rectangle" = "Prostokąt"
+"shape.star" = "Gwiazda"
+"shapeBuilder.merge" = "Połącz obszary kształtów"
+"shapeBuilder.mode" = "Tryb generatora kształtów"
+"shapeBuilder.regions" = "Obszary generatora kształtów"
+"shapeBuilder.remove" = "Usuń obszary"
+"stroke.add" = "Dodaj obrys"
+"stroke.brush" = "Pędzel"
+"stroke.move" = "Przenieś obrys"
+"stroke.remove" = "Usuń obrys"
+"stroke.set" = "Ustaw obrys"
+"stroke.widthProfile" = "Profil grubości"
+"style.apply" = "Zastosuj styl"
+"style.bind" = "Powiąż zmienną w stylu"
+"style.create" = "Utwórz styl"
+"style.delete" = "Usuń styl"
+"style.detach" = "Odłącz styl"
+"style.duplicate" = "Powiel styl"
+"style.list" = "Lista stylów"
+"style.move" = "Przenieś style"
+"style.renameFolder" = "Zmień nazwę folderu stylów"
+"style.update" = "Edytuj styl"
+"template.list" = "Lista szablonów"
+"text.alignCenter" = "Wyrównaj tekst do środka"
+"text.alignJustify" = "Wyjustuj tekst"
+"text.alignLeft" = "Wyrównaj tekst do lewej"
+"text.alignRight" = "Wyrównaj tekst do prawej"
+"text.bold" = "Pogrubienie"
+"text.bulletList" = "Lista punktowana"
+"text.case" = "Wielkość liter"
+"text.caseLower" = "Małe litery"
+"text.caseOriginal" = "Oryginalna wielkość liter"
+"text.caseSmallCaps" = "Kapitaliki"
+"text.caseTitle" = "Jak nazwy własne"
+"text.caseUpper" = "Wielkie litery"
+"text.create" = "Tekst"
+"text.decoration" = "Dekoracja tekstu"
+"text.edit.begin" = "Edytuj tekst"
+"text.edit.caret" = "Ustaw kursor tekstu"
+"text.edit.end" = "Zakończ edycję tekstu"
+"text.edit.insert" = "Wpisz tekst"
+"text.edit.key" = "Klawisz tekstu"
+"text.edit.preedit" = "Redaguj tekst"
+"text.edit.selectLine" = "Zaznacz wiersz"
+"text.edit.selectWord" = "Zaznacz słowo"
+"text.edit.selection" = "Zaznaczenie tekstu"
+"text.endPreview" = "Zakończ podgląd tekstu"
+"text.fonts" = "Lista czcionek"
+"text.italic" = "Kursywa"
+"text.lineHeightDown" = "Zmniejsz interlinię"
+"text.lineHeightUp" = "Zwiększ interlinię"
+"text.link" = "Wstaw łącze"
+"text.listIndent" = "Zwiększ wcięcie listy"
+"text.listOutdent" = "Zmniejsz wcięcie listy"
+"text.listStyle" = "Styl listy"
+"text.maxLines" = "Maksymalna liczba wierszy"
+"text.missingFonts" = "Brakujące czcionki"
+"text.numberList" = "Lista numerowana"
+"text.onPath" = "Tekst na ścieżce"
+"text.paragraphIndent" = "Wcięcie akapitu"
+"text.paragraphSpacing" = "Odstęp między akapitami"
+"text.pathOptions" = "Opcje ścieżki tekstu"
+"text.preview" = "Podgląd zmiany tekstu"
+"text.removeFromPath" = "Usuń tekst ze ścieżki"
+"text.set" = "Ustaw tekst"
+"text.setFeatures" = "Funkcje OpenType"
+"text.setVariations" = "Osie czcionki zmiennej (Variable Font)"
+"text.sizeDown" = "Zmniejsz rozmiar czcionki"
+"text.sizeUp" = "Zwiększ rozmiar czcionki"
+"text.strikethrough" = "Przekreślenie"
+"text.style" = "Zastosuj styl do fragmentu tekstu"
+"text.trackingDown" = "Zmniejsz odstęp między literami"
+"text.trackingUp" = "Zwiększ odstęp między literami"
+"text.underline" = "Podkreślenie"
+"text.weightDown" = "Zmniejsz grubość czcionki"
+"text.weightUp" = "Zwiększ grubość czcionki"
+"tool.arrow" = "Strzałka"
+"tool.comment" = "Komentarz"
+"tool.connector" = "Łącznik"
+"tool.ellipse" = "Elipsa"
+"tool.eraser" = "Gumka"
+"tool.frame" = "Ramka"
+"tool.hand" = "Rączka"
+"tool.highlighter" = "Zakreślacz"
+"tool.line" = "Linia"
+"tool.marker" = "Marker"
+"tool.move" = "Wskaźnik"
+"tool.pen" = "Pióro"
+"tool.pencil" = "Ołówek"
+"tool.pencilBrush" = "Pędzel ołówka"
+"tool.place" = "Umieść za pomocą narzędzia"
+"tool.polygon" = "Wielokąt"
+"tool.rectangle" = "Prostokąt"
+"tool.scale" = "Skalowanie"
+"tool.scaleAnchor" = "Punkt zaczepienia skalowania"
+"tool.section" = "Sekcja"
+"tool.set" = "Wybierz narzędzie"
+"tool.shape" = "Kształty"
+"tool.shapeBuilder" = "Generator kształtów"
+"tool.slice" = "Plaster"
+"tool.stamp" = "Pieczątka"
+"tool.star" = "Gwiazda"
+"tool.sticky" = "Karteczka"
+"tool.text" = "Tekst"
+"transform.move" = "Przenieś"
+"transform.moveTo" = "Przenieś do"
+"transform.nudge" = "Przesuń o krok (Nudge)"
+"transform.nudgeSize" = "Zmień rozmiar o krok"
+"transform.resize" = "Zmień rozmiar"
+"transform.rotate" = "Obróć"
+"transform.rotationOrigin" = "Przesuń punkt obrotu"
+"transform.scale" = "Skaluj"
+"transform.setRotationOrigin" = "Ustaw punkt obrotu"
+"variable.addMode" = "Dodaj tryb"
+"variable.bind" = "Powiąż zmienną"
+"variable.create" = "Utwórz zmienną"
+"variable.createCollection" = "Utwórz kolekcję zmiennych"
+"variable.delete" = "Usuń zmienną"
+"variable.deleteCollection" = "Usuń kolekcję"
+"variable.duplicate" = "Powiel zmienną"
+"variable.export" = "Eksportuj zmienne"
+"variable.import" = "Importuj zmienne"
+"variable.list" = "Lista zmiennych"
+"variable.moveMode" = "Przenieś tryb"
+"variable.removeMode" = "Usuń tryb"
+"variable.renameCollection" = "Zmień nazwę kolekcji"
+"variable.renameMode" = "Zmień nazwę trybu"
+"variable.resetOverride" = "Zresetuj nadpisanie zmiennej"
+"variable.set" = "Ustaw wartość zmiennej"
+"variable.setMode" = "Ustaw tryb zmiennej"
+"variable.update" = "Edytuj zmienną"
+"vector.create" = "Wektor"
+"vector.deleteHeal" = "Usuń punkt i napraw zaznaczenie"
+"vector.edit.addVertex" = "Dodaj punkt"
+"vector.edit.begin" = "Edytuj wektor"
+"vector.edit.bend" = "Zegnij segment"
+"vector.edit.bounds" = "Granice zaznaczonych punktów"
+"vector.edit.connect" = "Połącz punkty"
+"vector.edit.cornerRadius" = "Promień zaokrąglenia punktu"
+"vector.edit.cut" = "Rozetnij ścieżkę"
+"vector.edit.delete" = "Usuń punkty"
+"vector.edit.end" = "Zakończ edycję"
+"vector.edit.erase" = "Wymaż"
+"vector.edit.lasso" = "Zaznacz lasso"
+"vector.edit.mirroring" = "Symetria uchwytów"
+"vector.edit.moveHandles" = "Przesuń uchwyty"
+"vector.edit.moveVertices" = "Przesuń punkty"
+"vector.edit.nudge" = "Przesuń punkty o krok"
+"vector.edit.paint" = "Wiadro z farbą"
+"vector.edit.pen" = "Punkt pióra"
+"vector.edit.penEnd" = "Zakończ ścieżkę pióra"
+"vector.edit.position" = "Pozycja punktu"
+"vector.edit.resize" = "Zmień rozmiar punktów"
+"vector.edit.rotate" = "Obróć punkty"
+"vector.edit.select" = "Zaznacz punkty"
+"vector.edit.selectAll" = "Zaznacz wszystkie punkty"
+"vector.edit.setHandle" = "Ustaw uchwyt"
+"vector.edit.smooth" = "Wygładź lub wyostrz punkty"
+"vector.edit.state" = "Stan edycji wektora"
+"vector.edit.strokeCap" = "Zakończenie obrysu punktu"
+"vector.edit.strokeJoin" = "Połączenie obrysu punktu"
+"vector.edit.tool" = "Narzędzie edycji wektora"
+"vector.edit.transform" = "Przekształć punkty"
+"vector.edit.widthPoint" = "Punkt szerokości"
+"vector.flatten" = "Spłaszcz do wektora"
+"vector.join" = "Połącz ścieżki"
+"vector.offset" = "Przesunięcie ścieżki (Offset)"
+"vector.outlineStroke" = "Przekształć obrys w ścieżkę"
+"vector.reverse" = "Odwróć kierunek ścieżki"
+"vector.simplify" = "Uprość wektor"
+"vector.smoothJoin" = "Płynne połączenie zaznaczenia"
+"version.autosave" = "Wersja autozapisu"
+"version.delete" = "Usuń wersję"
+"version.duplicate" = "Powiel wersję"
+"version.exitPreview" = "Powrót do bieżącej wersji"
+"version.list" = "Historia wersji"
+"version.preview" = "Wyświetl wersję"
+"version.rename" = "Zmień nazwę wersji"
+"version.restore" = "Przywróć wersję"
+"view.assets" = "Panel zasobów"
+"view.comments" = "Pokaż komentarze"
+"view.contextMenu" = "Pokaż menu kontekstowe"
+"view.design" = "Panel projektu"
+"view.designPrototype" = "Przełącz między Projektem a Prototypem"
+"view.devMode" = "Tryb programisty"
+"view.frameOutlines" = "Kontury ramek"
+"view.fullscreen" = "Tryb pełnoekranowy"
+"view.get" = "Pobierz widok"
+"view.layers" = "Panel warstw"
+"view.layoutGrids" = "Siatki układu"
+"view.leftSidebar" = "Pokaż/Ukryj lewy pasek boczny"
+"view.maskOutlines" = "Kontury masek"
+"view.multiplayerCursors" = "Kursory innych użytkowników"
+"view.nextFrame" = "Przejdź do następnej ramki"
+"view.nextPage" = "Następna strona"
+"view.nextRegion" = "Przejdź do następnego obszaru"
+"view.outlines" = "Pokaż kontury"
+"view.outlinesHiddenLayers" = "Pokaż kontury ukrytych warstw"
+"view.outlinesObjectBounds" = "Pokaż granice obiektów"
+"view.outlinesSelection" = "Pokaż kontury zaznaczenia"
+"view.pan" = "Przesuń widok"
+"view.panelWidths" = "Zresetuj szerokości paneli"
+"view.pixelGrid" = "Siatka pikseli"
+"view.pixelPreview" = "Podgląd pikseli"
+"view.prevFrame" = "Przejdź do poprzedniej ramki"
+"view.prevPage" = "Poprzednia strona"
+"view.previousRegion" = "Przejdź do poprzedniego obszaru"
+"view.proofSrgb" = "Symulacja sRGB (Soft-proof)"
+"view.prototype" = "Panel prototypu"
+"view.rulers" = "Linijki"
+"view.set" = "Ustaw widok"
+"view.slices" = "Plastry"
+"view.snapGeometry" = "Przyciągaj do geometrii"
+"view.snapObjects" = "Przyciągaj do obiektów"
+"view.snapPixel" = "Przyciągaj do pikseli"
+"view.themeDark" = "Ciemny motyw"
+"view.themeLight" = "Jasny motyw"
+"view.themeSystem" = "Motyw zgodny z systemem"
+"view.toggleUi" = "Pokaż/Ukryj interfejs"
+"view.zoom100" = "Powiększenie 100%"
+"view.zoom200" = "Powiększenie 200%"
+"view.zoom50" = "Powiększenie 50%"
+"view.zoomAt" = "Narzędzie lupy"
+"view.zoomFit" = "Dopasuj do ekranu"
+"view.zoomIn" = "Powiększ"
+"view.zoomOut" = "Pomniejsz"
+"view.zoomSelection" = "Powiększ do zaznaczenia"
+"widget.click" = "Kliknij widżet"
+"widget.insert" = "Wstaw widżet"
+"widget.list" = "Lista widżetów"
+"window.focus" = "Przesuń okno na wierzch"
+"window.new" = "Nowe okno"
+
+[menu]
+"bool.exclude" = "Wyklucz"
+"bool.flatten" = "Spłaszcz"
+"bool.intersect" = "Część wspólna"
+"bool.subtract" = "Odejmij"
+"bool.union" = "Połącz"
+"file.duplicate" = "Powiel"
+"file.import" = "Importuj z pliku…"
+"file.rename" = "Zmień nazwę"
+"libraries.open" = "Otwórz biblioteki"
+"select.sameEffect" = "Efekt"
+"select.sameFill" = "Wypełnienie"
+"select.sameFont" = "Czcionka"
+"select.sameInstance" = "Instancja"
+"select.sameProperties" = "Właściwości"
+"select.sameStroke" = "Obrys"
+"select.sameText" = "Właściwości tekstu"
+"text.alignCenter" = "Wyrównaj do środka"
+"text.alignJustify" = "Wyjustuj"
+"text.alignLeft" = "Wyrównaj do lewej"
+"text.alignRight" = "Wyrównaj do prawej"
+"view.assets" = "Zasoby"
+"view.design" = "Projekt"
+"view.layers" = "Warstwy"
+"view.outlines" = "Pokaż kontury"
+"view.outlinesHiddenLayers" = "Uwzględnij ukryte warstwy"
+"view.outlinesObjectBounds" = "Uwzględnij granice obiektów"
+"view.outlinesSelection" = "Pokaż kontury zaznaczenia"
+"view.prototype" = "Prototyp"
+"view.themeDark" = "Ciemny"
+"view.themeLight" = "Jasny"
+"view.themeSystem" = "Zgodny z systemem"
diff --git a/crates/ui-egui/locales/pt-BR.toml b/crates/ui-egui/locales/pt-BR.toml
index c2189de81..22fffb178 100644
--- a/crates/ui-egui/locales/pt-BR.toml
+++ b/crates/ui-egui/locales/pt-BR.toml
@@ -16,6 +16,7 @@ status = "draft — needs native review"
 "1…9, 0" = "1…9, 0"
 "@{login}: {prs} PRs, {commits} commits, +{added} / −{deleted} lines (Δ {delta}), +{bin_added} / −{bin_deleted} binary assets, {first} – {last}" = "@{login}: {prs} PRs, {commits} commits, +{added} / −{deleted} linhas (Δ {delta}), +{bin_added} / −{bin_deleted} arquivos binários, {first} – {last}"
 "A collection of this file with these modes and variables: override their values per mode and add variables of its own" = "Uma coleção deste arquivo com estes modos e variáveis: substitua os valores por modo e adicione variáveis próprias"
+"A .figcraft file with this name already exists. Choose its full name to confirm replacement." = "Já existe um arquivo .figcraft com este nome. Escolha o nome completo dele para confirmar a substituição."
 "A layer on its own aligns to its frame: select more layers, or one in a frame" = "Uma camada sozinha se alinha ao seu quadro: selecione mais camadas ou uma dentro de um quadro"
 "A spring plays until it settles: its mass, stiffness and damping set how long" = "Uma mola se move até se estabilizar: sua massa, rigidez e amortecimento definem a duração"
 "About" = "Sobre"
@@ -115,6 +116,7 @@ status = "draft — needs native review"
 "Archived" = "Arquivada"
 "Arrange" = "Organizar"
 "Arrow" = "Seta"
+"Arrow at the end" = "Seta no final"
 "As typed" = "Como digitado"
 "Asking the server…" = "Consultando o servidor…"
 "Assets" = "Recursos"
@@ -186,7 +188,9 @@ status = "draft — needs native review"
 "C or ⇧C" = "C ou ⇧C"
 "CMYK colour" = "Cor CMYK"
 "Can view" = "Pode visualizar"
+"Check" = "Visto"
 "Checking the server…" = "Verificando o servidor…"
+"Chevron" = "Divisa"
 "Clear from this list" = "Limpar desta lista"
 "Code or invite link" = "Código ou link de convite"
 "Color profile: {name}" = "Perfil de cor: {name}"
@@ -232,7 +236,6 @@ status = "draft — needs native review"
 "Close tab" = "Fechar aba"
 "Close version history" = "Fechar histórico de versões"
 "Close when clicking outside" = "Fechar ao clicar fora"
-"Close without saving" = "Fechar sem salvar"
 "Code" = "Código"
 "Code syntax" = "Sintaxe de código"
 "Collapse" = "Recolher"
@@ -259,6 +262,8 @@ status = "draft — needs native review"
 "Commits" = "Commits"
 "Company" = "Empresa"
 "Compare changes" = "Comparar alterações"
+"Compare with" = "Comparar com"
+"Compatibility notes" = "Notas de compatibilidade"
 "Completed" = "Concluído"
 "Component" = "Componente"
 "Component name" = "Nome do componente"
@@ -273,6 +278,7 @@ status = "draft — needs native review"
 "Connected" = "Conectado"
 "Connected to code: {from}" = "Conectado ao código: {from}"
 "Connection lost, reconnecting (attempt {attempt})…" = "Conexão perdida, reconectando (tentativa {attempt})…"
+"Connector" = "Conector"
 "Constrain proportions" = "Manter proporções"
 "Constraints" = "Restrições"
 "Content" = "Conteúdo"
@@ -302,6 +308,7 @@ status = "draft — needs native review"
 "Corner smoothing" = "Suavização de cantos"
 "Couldn't download the variables" = "Não foi possível baixar as variáveis"
 "Couldn't reach {server}: showing what this computer remembers." = "Não foi possível alcançar {server}: mostrando o que este computador lembra."
+"Couldn't read {name}." = "Não foi possível ler {name}."
 "Couldn't save automatically: {error}" = "Não foi possível salvar automaticamente: {error}"
 "Count" = "Quantidade"
 "Create" = "Criar"
@@ -325,6 +332,7 @@ status = "draft — needs native review"
 "Current version" = "Versão atual"
 "Cursor chat" = "Chat do cursor"
 "Custom" = "Personalizado"
+"Custom size" = "Tamanho personalizado"
 "Cut" = "Recortar"
 "Dark" = "Escuro"
 "Darken" = "Escurecer"
@@ -355,6 +363,7 @@ status = "draft — needs native review"
 "Description" = "Descrição"
 "Description (optional)" = "Descrição (opcional)"
 "Design" = "Design"
+"Design panel" = "Painel de design"
 "Desktop" = "Desktop"
 "Destination" = "Destino"
 "Detach alias" = "Desvincular alias"
@@ -365,6 +374,7 @@ status = "draft — needs native review"
 "Detach variable" = "Desvincular variável"
 "Details" = "Detalhes"
 "Dev Mode" = "Modo Dev"
+"Dev Mode only inspects: switch to Design (Shift+D) to edit" = "O modo Dev só inspeciona: mude para Design (Shift+D) para editar"
 "Dev resources" = "Recursos de desenvolvimento"
 "Development" = "Desenvolvimento"
 "Device" = "Dispositivo"
@@ -381,6 +391,7 @@ status = "draft — needs native review"
 "Distribute horizontal spacing" = "Distribuir espaçamento horizontal"
 "Distribute vertical spacing" = "Distribuir espaçamento vertical"
 "Divider" = "Divisor"
+"Don't Save" = "Não salvar"
 "Don't truncate" = "Não truncar"
 "Done" = "Concluído"
 "Done editing" = "Concluir edição"
@@ -411,6 +422,7 @@ status = "draft — needs native review"
 "Effect settings" = "Configurações do efeito"
 "Effect styles" = "Estilos de efeito"
 "Effects" = "Efeitos"
+"Elbow" = "Em ângulo"
 "Ellipse" = "Elipse"
 "Ellipses" = "Elipses"
 "Else" = "Senão"
@@ -459,6 +471,7 @@ status = "draft — needs native review"
 "False" = "Falso"
 "Fetching from the server…" = "Buscando no servidor…"
 "FigCraft couldn't open its window: {error}" = "O FigCraft não conseguiu abrir a janela: {error}"
+"FigCraft doesn't support every feature of these files yet. The notes list what was left out or changed in the imported copy; the original file is unchanged." = "O FigCraft ainda não oferece suporte a todos os recursos desses arquivos. As notas listam o que foi omitido ou alterado na cópia importada; o arquivo original não é alterado."
 "File" = "Arquivo"
 "File name" = "Nome do arquivo"
 "File published" = "Arquivo publicado"
@@ -540,6 +553,7 @@ status = "draft — needs native review"
 "Hanging list" = "Lista com recuo deslocado"
 "Hanging punctuation" = "Pontuação pendente"
 "Hard light" = "Luz forte"
+"Heart" = "Coração"
 "Height" = "Altura"
 "Help" = "Ajuda"
 "Help and resources" = "Ajuda e recursos"
@@ -550,6 +564,7 @@ status = "draft — needs native review"
 "Hide from publishing" = "Não publicar"
 "Hide section contents" = "Ocultar conteúdo da seção"
 "Highlight layers on hover" = "Destacar camadas ao passar o cursor"
+"Highlighter" = "Marca-texto"
 "Highlights" = "Realces"
 "Hold Alt" = "Segure Alt"
 "Hold Alt+Z" = "Segure Alt+Z"
@@ -575,11 +590,14 @@ status = "draft — needs native review"
 "If {condition}" = "Se {condition}"
 "Ignore auto layout (absolute position)" = "Ignorar layout automático (posição absoluta)"
 "Image" = "Imagem"
+"Images" = "Imagens"
 "Import" = "Importar"
 "Import path" = "Caminho de importação"
 "Import plugin from manifest" = "Importar plugin a partir do manifesto"
 "Import plugin from manifest…" = "Importar plugin a partir do manifesto…"
+"Import report" = "Relatório de importação"
 "Import variables" = "Importar variáveis"
+"Imported document" = "Documento importado"
 "Imported {name}" = "{name} importado"
 "Imported {n} new variables, updated {updated}" = { one = "{n} variável nova importada, {updated} atualizadas", other = "{n} variáveis novas importadas, {updated} atualizadas" }
 "Import…" = "Importar…"
@@ -607,11 +625,13 @@ status = "draft — needs native review"
 "Instance swap (no other component)" = "Troca de instância (nenhum outro componente)"
 "Instances" = "Instâncias"
 "Instant" = "Instantâneo"
+"Intensity" = "Brilho"
 "Interaction" = "Interação"
 "Interactions" = "Interações"
 "Interface design and prototyping. A free, open-source, clean-room design tool written from scratch in Rust, part of the ArtCraft Crafting Apps." = "Design de interfaces e prototipagem. Uma ferramenta de design gratuita e de código aberto, com implementação independente (clean-room), escrita do zero em Rust, parte dos Crafting Apps da ArtCraft."
 "Intersect" = "Interseção"
 "Intersects" = "Interseções"
+"Invalid color" = "Cor inválida"
 "Invite link" = "Link de convite"
 "Invite link copied" = "Link de convite copiado"
 "It asks permission to:" = "Ele pede permissão para:"
@@ -700,6 +720,7 @@ status = "draft — needs native review"
 "Mark as resolved" = "Marcar como resolvido"
 "Mark as unread" = "Marcar como não lido"
 "Mark as unresolved" = "Marcar como não resolvido"
+"Marker" = "Marcador"
 "Mask" = "Máscara"
 "Mass · Stiffness · Damping" = "Massa · Rigidez · Amortecimento"
 "Match (empty: the whole name)" = "Correspondência (vazio: o nome inteiro)"
@@ -756,7 +777,9 @@ status = "draft — needs native review"
 "Named instance" = "Instância nomeada"
 "Navigate to" = "Navegar para"
 "Nested instance" = "Instância aninhada"
+"New board" = "Novo quadro"
 "New design file" = "Novo arquivo de design"
+"Next frame" = "Próximo quadro"
 "Next or previous control in the focused region" = "Controle seguinte ou anterior na região em foco"
 "Next ready for dev" = "Próximo pronto para dev"
 "Next size option" = "Próxima opção de tamanho"
@@ -766,12 +789,15 @@ status = "draft — needs native review"
 "No branches. A branch is a copy of the file to try changes in, then review and merge." = "Nenhuma branch. Uma branch é uma cópia do arquivo para testar alterações e depois revisá-las e mesclá-las."
 "No category" = "Sem categoria"
 "No changes" = "Nenhuma alteração"
+"No color styles" = "Nenhum estilo de cor"
 "No colour variables fit here." = "Nenhuma variável de cor se encaixa aqui."
 "No colour variables yet. Create them in Local variables." = "Ainda não há variáveis de cor. Crie-as em Variáveis locais."
 "No comments yet" = "Ainda não há comentários"
+"No compatibility warnings reported" = "Nenhum aviso de compatibilidade relatado"
 "No components yet. Select layers and press {keys}." = "Ainda não há componentes. Selecione camadas e pressione {keys}."
 "No conflicts." = "Nenhum conflito."
 "No contributor data was built into this copy." = "Esta cópia não inclui dados de colaboradores."
+"No device" = "Nenhum dispositivo"
 "No fonts match" = "Nenhuma fonte corresponde"
 "No join code here (the server is older than join codes, or this address can't be put in one): share the link instead." = "Não há código de acesso aqui (o servidor é anterior aos códigos de acesso, ou este endereço não cabe em um): compartilhe o link."
 "No layer changes to show." = "Nenhuma alteração de camada para mostrar."
@@ -814,6 +840,7 @@ status = "draft — needs native review"
 "Not read yet" = "Ainda não lido"
 "Not shared" = "Não compartilhado"
 "Note {n}" = "Nota {n}"
+"Nothing changed since this version." = "Nada mudou desde esta versão."
 "Nothing changed since this was marked ready for dev." = "Nada mudou desde que isto foi marcado como pronto para dev."
 "Nothing here yet. Set a frame's status to list it." = "Ainda não há nada aqui. Defina o status de um quadro para listá-lo."
 "Nothing online yet. Use Share on a file to put it online and it is listed here." = "Nada online ainda. Use Compartilhar em um arquivo para colocá-lo online e ele aparecerá aqui."
@@ -847,6 +874,7 @@ status = "draft — needs native review"
 "Open branch" = "Abrir branch"
 "Open file" = "Abrir arquivo"
 "Open files" = "Arquivos abertos"
+"Open presentations" = "Apresentações abertas"
 "Open in focus view" = "Abrir na visualização em foco"
 "Open in new window" = "Abrir em nova janela"
 "Open invite links in FigCraft" = "Abrir links de convite no FigCraft"
@@ -855,6 +883,7 @@ status = "draft — needs native review"
 "Open overlay" = "Abrir sobreposição"
 "Open prototype preview" = "Abrir visualização do protótipo"
 "Open variables ({count})" = "Abrir variáveis ({count})"
+"Opened as a new document" = "Aberto como novo documento"
 "Opened “{name}” in a new tab" = "“{name}” aberto em uma nova aba"
 "Open|comments" = "Abertos"
 "Options" = "Opções"
@@ -877,7 +906,11 @@ status = "draft — needs native review"
 "PDF print settings" = "Configurações de impressão em PDF"
 "Padding" = "Espaçamento interno"
 "Page" = "Página"
+"Page deleted" = "Página excluída"
 "Pages" = "Páginas"
+"Pages added to the document" = "Páginas adicionadas ao documento"
+"Pink" = "Rosa"
+"Placed on the current page" = "Colocado na página atual"
 "Pages: {pages}" = "Páginas: {pages}"
 "Paint bucket" = "Balde de tinta"
 "Pan the canvas" = "Mover a tela"
@@ -892,6 +925,7 @@ status = "draft — needs native review"
 "Paste a team library link (a view link)" = "Cole o link de uma biblioteca de equipe (um link de visualização)"
 "Paste here" = "Colar aqui"
 "Paste to replace" = "Colar para substituir"
+"Pasted design layers; {n} kinds of content were left out" = { one = "Camadas de design coladas; {n} tipo de conteúdo ficou de fora", other = "Camadas de design coladas; {n} tipos de conteúdo ficaram de fora" }
 "Pattern" = "Padrão"
 "Pattern alignment" = "Alinhamento do padrão"
 "Pattern scale" = "Escala do padrão"
@@ -917,6 +951,7 @@ status = "draft — needs native review"
 "Plugins run in FigCraft's sandbox, without files, network or clock. Install only plugins you trust." = "Os plugins são executados na sandbox do FigCraft, sem arquivos, rede nem relógio. Instale apenas plugins em que você confia."
 "Plus darker" = "Mais escuro"
 "Plus lighter" = "Mais claro"
+"Plus one" = "Mais um"
 "Point" = "Ponto"
 "Points" = "Pontos"
 "Polygon" = "Polígono"
@@ -942,6 +977,7 @@ status = "draft — needs native review"
 "Preview" = "Visualização"
 "Preview this flow" = "Visualizar este fluxo"
 "Preview this frame" = "Visualizar este quadro"
+"Previous frame" = "Quadro anterior"
 "Previous ready for dev" = "Anterior pronto para dev"
 "Progressive" = "Progressivo"
 "Properties" = "Propriedades"
@@ -962,6 +998,7 @@ status = "draft — needs native review"
 "Push" = "Empurrar"
 "Push changes to main component" = "Enviar alterações ao componente principal"
 "Put text on path" = "Colocar texto no caminho"
+"Question" = "Pergunta"
 "R" = "R"
 "Radial" = "Radial"
 "Radius" = "Raio"
@@ -1006,6 +1043,7 @@ status = "draft — needs native review"
 "Removed" = "Removido"
 "Removed from the server" = "Removido do servidor"
 "Removed since it was marked" = "Removido desde a marcação"
+"Removed since this version" = "Removido desde esta versão"
 "Rename" = "Renomear"
 "Rename duplicated layers" = "Renomear camadas duplicadas"
 "Rename folder" = "Renomear pasta"
@@ -1035,6 +1073,7 @@ status = "draft — needs native review"
 "Resize by the nudge amount" = "Redimensionar pelo valor do deslocamento"
 "Resize frames to the device's screen (or the window without a device): their constraints and auto layout respond" = "Redimensiona os quadros para a tela do dispositivo (ou para a janela, sem dispositivo): as restrições e o layout automático deles se adaptam"
 "Resize to fit" = "Redimensionar para caber"
+"Resizing" = "Redimensionamento"
 "Resolve" = "Resolver"
 "Resolve change" = "Resolver alteração"
 "Resolved" = "Resolvido"
@@ -1060,6 +1099,7 @@ status = "draft — needs native review"
 "Rotation jitter" = "Variação de rotação"
 "Round" = "Arredondado"
 "Rounded" = "Arredondado"
+"Rounded rectangle" = "Retângulo arredondado"
 "Row" = "Linha"
 "Row gap" = "Espaço entre linhas"
 "Row sizes" = "Tamanhos de linha"
@@ -1106,12 +1146,14 @@ status = "draft — needs native review"
 "Select all with same" = "Selecionar tudo com o mesmo"
 "Select layer" = "Selecionar camada"
 "Select layers to apply the style to" = "Selecione as camadas às quais aplicar o estilo"
+"Select layers with this color" = "Selecionar camadas com esta cor"
 "Select overlapping shapes" = "Selecione formas sobrepostas"
 "Select points to edit their position, radius and mirroring" = "Selecione pontos para editar posição, raio e espelhamento"
 "Select slot" = "Selecionar slot"
 "Selection" = "Seleção"
 "Selection box, {w} by {h} at {x}, {y}: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "Caixa de seleção, {w} por {h} em {x}, {y}: as setas a movem, Shift+setas ou {cmd}+setas a redimensionam, Enter seleciona, Esc cancela"
 "Selection box: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "Caixa de seleção: as setas a movem, Shift+setas ou {cmd}+setas a redimensionam, Enter seleciona, Esc cancela"
+"Selection colors" = "Cores da seleção"
 "Send backward" = "Enviar para trás"
 "Send report" = "Enviar denúncia"
 "Send to back" = "Enviar para o plano de fundo"
@@ -1127,6 +1169,7 @@ status = "draft — needs native review"
 "Shape" = "Forma"
 "Shape builder" = "Construtor de formas"
 "Shape tools" = "Ferramentas de forma"
+"Shapes" = "Formas"
 "Share" = "Compartilhar"
 "Share this file" = "Compartilhar este arquivo"
 "Share: live session, export" = "Compartilhar: sessão ao vivo, exportar"
@@ -1184,10 +1227,13 @@ status = "draft — needs native review"
 "Space+drag" = "Espaço+arrastar"
 "Spacing" = "Espaçamento"
 "Spam, stolen work, abuse…" = "Spam, trabalho roubado, abuso…"
+"Speech bubble" = "Balão de fala"
 "Splay" = "Abertura"
 "Spotlight me" = "Colocar o foco em mim"
 "Spread" = "Expansão"
 "Square" = "Quadrado"
+"Stamp" = "Carimbo"
+"Stamps" = "Carimbos"
 "Standard" = "Padrão"
 "Standard ligatures" = "Ligaduras padrão"
 "Star" = "Estrela"
@@ -1196,17 +1242,22 @@ status = "draft — needs native review"
 "Start ascending from / stop descending at" = "Contar para cima a partir de / para baixo até"
 "Start from a blank canvas" = "Comece com uma tela em branco"
 "Start on path" = "Início no caminho"
+"Start on the Home screen" = "Começar no Início"
 "Start point" = "Ponto inicial"
 "Start sharing" = "Começar a compartilhar"
 "Starting to share…" = "Começando a compartilhar…"
 "Status" = "Status"
 "Sticky" = "Fixado"
+"Sticky note" = "Nota adesiva"
+"Sticky note colors" = "Cores das notas adesivas"
+"Sticky notes, shapes and connectors" = "Notas adesivas, formas e conectores"
 "Stop" = "Parar"
 "Stop following {name}" = "Parar de seguir {name}"
 "Stop session" = "Encerrar sessão"
 "Stop sharing" = "Parar de compartilhar"
 "Stop spotlighting" = "Remover o foco"
 "Stop {n}  {hex}" = "Parada {n}  {hex}"
+"Straight" = "Reto"
 "Stretch" = "Esticar"
 "Strikethrough" = "Tachado"
 "String" = "String"
@@ -1250,6 +1301,7 @@ status = "draft — needs native review"
 "Text" = "Texto"
 "Text align" = "Alinhamento do texto"
 "Text content" = "Conteúdo do texto"
+"Text size" = "Tamanho do texto"
 "Text style" = "Estilo de texto"
 "Text styles" = "Estilos de texto"
 "Texts" = "Textos"
@@ -1280,6 +1332,9 @@ status = "draft — needs native review"
 "This server is open to the public: no key needed." = "Este servidor é aberto ao público: não precisa de chave."
 "This server needs its key: add ?key=… to the address (`figcraft-server key` prints it on the server's machine)." = "Este servidor precisa da própria chave: adicione ?key=… ao endereço (`figcraft-server key` a mostra na máquina do servidor)."
 "This server takes files only with its key: see Advanced." = "Este servidor só aceita arquivos com a própria chave: veja Avançado."
+"Thumbs up" = "Joinha"
+"This version can't be read." = "Não é possível ler esta versão."
+"This version doesn't have it: all of it is new." = "Esta versão não o tem: tudo é novo."
 "Tidy up" = "Organizar"
 "Tile" = "Mosaico"
 "Tile type" = "Tipo de mosaico"
@@ -1296,6 +1351,7 @@ status = "draft — needs native review"
 "Top left radius" = "Raio superior esquerdo"
 "Top right radius" = "Raio superior direito"
 "Transform" = "Transformar"
+"Triangle" = "Triângulo"
 "Triangle arrow" = "Seta triangular"
 "Trigger" = "Gatilho"
 "True" = "Verdadeiro"
@@ -1318,7 +1374,7 @@ status = "draft — needs native review"
 "Unread" = "Não lidos"
 "Unresolve" = "Reabrir"
 "Unsaved changes" = "Alterações não salvas"
-"Unsaved changes in {names}. Close the window and lose them?" = "Há alterações não salvas em {names}. Fechar a janela e perdê-las?"
+"Unsaved changes in {names}. Save them before closing?" = "Há alterações não salvas em {names}. Salvá-las antes de fechar?"
 "Unsaved changes: save first ({save}), or close the tab with {alt}-click to discard" = "Alterações não salvas: salve primeiro ({save}) ou feche a aba com {alt}+clique para descartá-las"
 "Unsaved changes: save first, or close again with {key} to discard" = "Alterações não salvas: salve primeiro ou feche de novo com {key} para descartá-las"
 "Up" = "Para cima"
@@ -1337,6 +1393,7 @@ status = "draft — needs native review"
 "Use as mask" = "Usar como máscara"
 "Use auto layout" = "Usar layout automático"
 "Use number keys for opacity" = "Usar teclas numéricas para a opacidade"
+"Use the .figcraft or .fig extension." = "Use a extensão .figcraft ou .fig."
 "Use the layer's fill" = "Usar o preenchimento da camada"
 "Used in {files} · {instances}" = "Usado em {files} · {instances}"
 "Username" = "Nome de usuário"
@@ -1380,10 +1437,12 @@ status = "draft — needs native review"
 "WebSocket URL copied" = "URL do WebSocket copiada"
 "Wedge" = "Cunha"
 "Weight" = "Espessura"
+"What changed since a saved version" = "O que mudou desde uma versão salva"
 "What changed since it was marked ready for dev" = "O que mudou desde que foi marcado como pronto para dev"
 "What is wrong with this file? The server's operator gets your report." = "O que há de errado com este arquivo? O operador do servidor recebe a sua denúncia."
 "What it's for" = "Para que serve"
 "What this changed from isn't known: it changed before FigCraft kept a copy of ready-for-dev frames. Resolve the change (or mark it ready again) to compare from now on." = "Não se sabe de onde esta alteração partiu: ela ocorreu antes de o FigCraft guardar cópias dos quadros prontos para dev. Resolva a alteração (ou marque-o como pronto de novo) para comparar daqui em diante."
+"When marked ready" = "Ao marcar como pronto"
 "While hovering" = "Enquanto passa o cursor"
 "While pressing" = "Enquanto pressiona"
 "White" = "Branco"
@@ -1425,25 +1484,118 @@ status = "draft — needs native review"
 "call any command its access allows" = "chamar qualquer comando que seu acesso permita"
 "call only: {commands}" = "chamar apenas: {commands}"
 "can edit the document" = "pode editar o documento"
+"conditional prototype actions nested too deeply were skipped" = "ações condicionais de protótipo aninhadas profundamente demais foram ignoradas"
+"conditional prototype actions with conditions that can't be evaluated were skipped" = "ações condicionais de protótipo com condições que não podem ser avaliadas foram ignoradas"
+"connector label background was skipped: style data is missing" = "o fundo do rótulo do conector foi ignorado: faltam os dados de estilo"
+"connector label was skipped: background bounds are invalid" = "o rótulo do conector foi ignorado: os limites do fundo são inválidos"
+"connector label was skipped: background transform is invalid" = "o rótulo do conector foi ignorado: a transformação do fundo é inválida"
+"connector label was skipped: composed text transform is invalid" = "o rótulo do conector foi ignorado: a transformação composta do texto é inválida"
+"connector label was skipped: derived background bounds are missing" = "o rótulo do conector foi ignorado: faltam os limites derivados do fundo"
+"connector label was skipped: derived text bounds are missing" = "o rótulo do conector foi ignorado: faltam os limites derivados do texto"
+"connector label was skipped: text bounds are invalid" = "o rótulo do conector foi ignorado: os limites do texto são inválidos"
+"connector label was skipped: text style data is missing" = "o rótulo do conector foi ignorado: faltam os dados de estilo do texto"
+"connector label was skipped: text transform is invalid" = "o rótulo do conector foi ignorado: a transformação do texto é inválida"
+"connector labels were skipped" = "rótulos de conectores foram ignorados"
+"connector layers import as static frame/vector snapshots with labels when present; live endpoint bindings are not retained" = "camadas de conector são importadas como instantâneos estáticos de quadro ou vetor, com rótulos quando houver; os vínculos dinâmicos das pontas não são mantidos"
+"connector snapshot vector data is missing; connector was left empty" = "faltam os dados vetoriais do instantâneo do conector; o conector ficou vazio"
+"connectors whose ends can't be placed are empty" = "conectores cujas pontas não podem ser posicionadas ficam vazios"
 "crop marks" = "marcas de corte"
+"damaged vector geometry was skipped" = "geometria vetorial danificada foi ignorada"
+"damaged vector networks import as outlines" = "redes vetoriais danificadas são importadas como contornos"
 "development: {path}" = "desenvolvimento: {path}"
+"document children other than pages were skipped" = "filhos do documento que não são páginas foram ignorados"
+"duplicate grid track sizing entries use equal tracks" = "entradas duplicadas de dimensionamento de faixas da grade usam faixas iguais"
 "e.g. count + 1" = "por ex. count + 1"
 "e.g. count >= 3 and not done" = "por ex. count >= 3 and not done"
+"elbowed and curved connectors without a saved path import as straight lines" = "conectores angulares e curvos sem um caminho salvo são importados como linhas retas"
+"entries without a node type were skipped" = "entradas sem tipo de nó foram ignoradas"
 "figcraft:// links from a browser, chat or email open this app and join the session." = "Links figcraft:// de um navegador, chat ou e-mail abrem este app e entram na sessão."
+"filled areas of a vector with their own fill use the layer's fill" = "áreas preenchidas de um vetor com preenchimento próprio usam o preenchimento da camada"
 "from {server}" = "de {server}"
+"gamepad triggers without exactly one known controller button were skipped" = "gatilhos de gamepad sem exatamente um botão de controle conhecido foram ignorados"
+"grid track list exceeds 1000 entries; the tracks use the default equal sizing" = "a lista de faixas da grade passa de 1000 entradas; as faixas usam o dimensionamento igual padrão"
+"grid track sizing is unsupported or malformed; affected tracks use equal sizing" = "o dimensionamento de faixas da grade não é compatível ou está malformado; as faixas afetadas usam dimensionamento igual"
+"grid track sizing list exceeds 1000 entries; the tracks use the default equal sizing" = "a lista de dimensionamento de faixas da grade passa de 1000 entradas; as faixas usam o dimensionamento igual padrão"
 "hidden" = "oculta"
 "iOS" = "iOS"
+"image filters are ambiguous because both filter containers are present; filter conversion was skipped" = "os filtros de imagem são ambíguos porque os dois contêineres de filtro estão presentes; a conversão dos filtros foi ignorada"
+"image filters use FigCraft's approximate renderer" = "os filtros de imagem usam a renderização aproximada do FigCraft"
+"instance swap properties whose default component isn't in the file were skipped" = "propriedades de troca de instância cujo componente padrão não está no arquivo foram ignoradas"
+"instances inside their own main component were imported as frames" = "instâncias dentro do próprio componente principal foram importadas como quadros"
+"instances of components that aren't in the file show no layers" = "instâncias de componentes que não estão no arquivo não mostram camadas"
+"instances of components that aren't in the file were imported as frames" = "instâncias de componentes que não estão no arquivo foram importadas como quadros"
+"instances that would nest a component inside itself were imported as frames" = "instâncias que aninhariam um componente dentro dele mesmo foram importadas como quadros"
+"instances without a main component were imported as empty frames" = "instâncias sem componente principal foram importadas como quadros vazios"
+"invalid internal .fig text path data was ignored" = "dados internos inválidos de texto em caminho do .fig foram ignorados"
+"invalid or oversized vector networks import as outlines" = "redes vetoriais inválidas ou grandes demais são importadas como contornos"
+"invalid or oversized vector path data was skipped" = "dados de caminho vetorial inválidos ou grandes demais foram ignorados"
+"key triggers without a supported key were skipped" = "gatilhos de tecla sem uma tecla compatível foram ignorados"
+"key up triggers import as key presses" = "gatilhos ao soltar uma tecla são importados como pressionamentos de tecla"
+"layers without a position were placed at their parent's origin" = "camadas sem posição foram colocadas na origem do elemento pai"
+"layers without a type were skipped" = "camadas sem tipo foram ignoradas"
+"legacy image filter container is unsupported; filter conversion was skipped" = "o contêiner legado de filtros de imagem não é compatível; a conversão dos filtros foi ignorada"
 "locked" = "bloqueada"
+"malformed image filters container was skipped" = "o contêiner de filtros de imagem malformado foi ignorado"
+"malformed image paintFilter container was skipped" = "o contêiner paintFilter de imagem malformado foi ignorado"
+"malformed slot content assignment was skipped" = "uma atribuição de conteúdo de slot malformada foi ignorada"
 "no bleed" = "sem sangria"
 "nobody else here yet" = "ainda não há mais ninguém"
+"non-default slot settings are not represented and were skipped" = "configurações de slot diferentes do padrão não são representadas e foram ignoradas"
 "now" = "agora"
 "or" = "ou"
+"point stroke joins were preserved; dashed or variable-width strokes render with the layer join" = "as junções de traço por ponto foram mantidas; traços tracejados ou de largura variável são desenhados com a junção da camada"
+"preferred slot component keys cannot be resolved to file nodes and were skipped" = "chaves de componentes preferidos de slots não correspondem a camadas do arquivo e foram ignoradas"
+"prototype actions of unknown types were skipped" = "ações de protótipo de tipos desconhecidos foram ignoradas"
+"prototype actions without a destination in the file were skipped" = "ações de protótipo sem destino no arquivo foram ignoradas"
+"prototype expressions on variables that aren't in the variables JSON were skipped" = "expressões de protótipo com variáveis que não estão no JSON de variáveis foram ignoradas"
+"prototype expressions with unsupported functions were skipped" = "expressões de protótipo com funções sem suporte foram ignoradas"
+"prototype interactions without supported actions were skipped" = "interações de protótipo sem ações compatíveis foram ignoradas"
+"prototype navigations of unknown types were skipped" = "navegações de protótipo de tipos desconhecidos foram ignoradas"
+"prototype transitions of unknown types play instantly" = "transições de protótipo de tipos desconhecidos são instantâneas"
+"prototype triggers of unknown types were skipped" = "gatilhos de protótipo de tipos desconhecidos foram ignorados"
 "put a widget on the canvas" = "colocar um widget na tela"
 "read and edit the document" = "ler e editar o documento"
 "read the document" = "ler o documento"
 "reads the document" = "lê o documento"
+"set-variable actions on variables that aren't in the variables JSON were skipped" = "ações de definir variável em variáveis que não estão no JSON de variáveis foram ignoradas"
+"set-variable actions with values that can't be evaluated were skipped" = "ações de definir variável com valores que não podem ser avaliados foram ignoradas"
+"set-variable actions with values that don't fit the variable were skipped" = "ações de definir variável com valores que não cabem na variável foram ignoradas"
+"set-variable actions without a value were skipped" = "ações de definir variável sem valor foram ignoradas"
+"set-variable-mode actions on collections or modes that aren't in the variables JSON were skipped" = "ações de definir modo de variável em coleções ou modos que não estão no JSON de variáveis foram ignoradas"
+"slot content assignment target is missing or is not slot content" = "o destino da atribuição de conteúdo de slot está ausente ou não é conteúdo de slot"
+"slot content assignment uses the empty GUID sentinel and was skipped" = "a atribuição de conteúdo de slot usa o GUID vazio como sentinela e foi ignorada"
+"some vector points refer to point settings missing from the file; they use the layer's joins and plain corners" = "alguns pontos vetoriais se referem a configurações de ponto ausentes no arquivo; eles usam as junções da camada e cantos simples"
+"some vector segments refer to style settings missing from the file; they use the layer's stroke" = "alguns segmentos vetoriais se referem a configurações de estilo ausentes no arquivo; eles usam o traço da camada"
+"stale or invalid grid track sizing entries were ignored" = "entradas de dimensionamento de faixas da grade obsoletas ou inválidas foram ignoradas"
+"stars and polygons without point counts or geometry use the default point count" = "estrelas e polígonos sem número de pontas nem geometria usam o número de pontas padrão"
+"style settings of some vector segments aren't supported; those segments use the layer's stroke" = "as configurações de estilo de alguns segmentos vetoriais não são compatíveis; esses segmentos usam o traço da camada"
+"text path underline or strikethrough decoration is not rendered" = "o sublinhado ou tachado do texto em caminho não é desenhado"
+"text style overrides refer to missing table entries" = "substituições de estilo de texto se referem a entradas de tabela ausentes"
+"the file has no pages" = "o arquivo não tem páginas"
 "the plugin" = "o plugin"
+"the variables JSON has no `variableCollections` (expected the local variables response) and was ignored" = "o JSON de variáveis não tem `variableCollections` (era esperada a resposta de variáveis locais) e foi ignorado"
 "this session only" = "somente nesta sessão"
+"unknown component property types were skipped" = "tipos desconhecidos de propriedade de componente foram ignorados"
+"variable aliases to variables that aren't in the variables JSON (or of another type) were skipped" = "aliases para variáveis que não estão no JSON de variáveis (ou de outro tipo) foram ignorados"
+"variable bindings to properties the layer doesn't have were skipped" = "vínculos de variáveis a propriedades que a camada não tem foram ignorados"
+"variable bindings to variables that aren't in the variables JSON (library variables) were skipped" = "vínculos a variáveis que não estão no JSON de variáveis (variáveis de biblioteca) foram ignorados"
+"variable bindings were skipped: the file JSON has no variable definitions (pass the local variables JSON as `variables`, or embed its `meta` next to the file JSON)" = "vínculos de variáveis foram ignorados: o JSON do arquivo não tem definições de variáveis (passe o JSON de variáveis locais como `variables` ou incorpore o `meta` dele ao lado do JSON do arquivo)"
+"variable bindings whose variable type doesn't fit the property were skipped" = "vínculos de variáveis cujo tipo de variável não combina com a propriedade foram ignorados"
+"variable collections without modes were skipped" = "coleções de variáveis sem modos foram ignoradas"
+"variable mode lookups in prototype expressions that aren't a variable and one of its modes were skipped" = "consultas de modo de variável em expressões de protótipo que não são uma variável e um de seus modos foram ignoradas"
+"variable modes of collections that aren't in the file were skipped" = "modos de variáveis de coleções que não estão no arquivo foram ignorados"
+"variable modes of collections that aren't in the variables JSON were skipped" = "modos de variáveis de coleções que não estão no JSON de variáveis foram ignorados"
+"variable values that don't match their type (or composed colours) were skipped" = "valores de variáveis que não correspondem ao seu tipo (ou cores compostas) foram ignorados"
+"variables of unknown types were skipped" = "variáveis de tipos desconhecidos foram ignoradas"
+"variables whose collection isn't in the variables JSON were skipped" = "variáveis cuja coleção não está no JSON de variáveis foram ignoradas"
+"variables without readable values were skipped" = "variáveis sem valores legíveis foram ignoradas"
+"vector points with unknown stroke joins use the layer join" = "pontos vetoriais com junções de traço desconhecidas usam a junção da camada"
+"vectors without geometry are empty" = "vetores sem geometria ficam vazios"
+"vectors without geometry are empty (export the file JSON with geometry=paths)" = "vetores sem geometria ficam vazios (exporte o JSON do arquivo com geometry=paths)"
+"very long text was cut to 1,048,576 characters" = "textos muito longos foram cortados em 1.048.576 caracteres"
+"very long vector paths were skipped" = "caminhos vetoriais muito longos foram ignorados"
+"video actions are not supported and were skipped" = "ações de vídeo não têm suporte e foram ignoradas"
+"video triggers are not supported and were skipped" = "gatilhos de vídeo não têm suporte e foram ignorados"
 "{instances} in {files}" = "{instances} em {files}"
 "{language}: draft translation, waiting for a native speaker's review." = "{language}: tradução em rascunho, aguardando revisão de um falante nativo."
 "{length} bleed" = "sangria de {length}"
@@ -1458,6 +1610,7 @@ status = "draft — needs native review"
 "{name} is forgotten on this computer; the file stays on {server}" = "{name} foi esquecido neste computador; o arquivo continua em {server}"
 "{name} is on the server." = "{name} está no servidor."
 "{name} is spotlighting" = "{name} está em destaque"
+"{name} is too large to open in the browser (over 512 MB)." = "{name} é grande demais para abrir no navegador (mais de 512 MB)."
 "{name} was removed from the server" = "{name} foi removido do servidor"
 "{name} · deleted on main" = "{name} · excluído no principal"
 "{name} · deleted on the branch" = "{name} · excluído na branch"
@@ -1486,6 +1639,7 @@ status = "draft — needs native review"
 "{n} matches" = { one = "{n} resultado", other = "{n} resultados" }
 "{n} minutes ago" = { one = "há {n} minuto", other = "há {n} minutos" }
 "{n} months ago" = { one = "há {n} mês", other = "há {n} meses" }
+"{n} more notes omitted from this report" = { one = "{n} nota a mais omitida deste relatório", other = "{n} notas a mais omitidas deste relatório" }
 "{n} of {total}" = "{n} de {total}"
 "{n} people joined" = { one = "{n} pessoa entrou", other = "{n} pessoas entraram" }
 "{n} preferred components" = { one = "{n} componente preferido", other = "{n} componentes preferidos" }
@@ -1520,6 +1674,120 @@ status = "draft — needs native review"
 "⌘ click" = "⌘ clique"
 "⌘ scroll" = "⌘ rolar"
 "⌥ drag" = "⌥ arrastar"
+"A responsive product page: hero, features, figures, a quote and a footer" = "Uma página de produto responsiva: destaque, recursos, dados, depoimento e rodapé"
+"A title, an agenda, a big figure, a chart and a closing slide" = "Um título, uma pauta, um número em destaque, um gráfico e um slide de encerramento"
+"A to Z" = "De A a Z"
+"Adding to {name}" = "Adicionando a {name}"
+"All the fonts this file uses are installed" = "Todas as fontes usadas neste arquivo estão instaladas"
+"Alphabetical" = "Alfabética"
+"An analytics screen on a grid: figures, charts drawn from vectors and a table" = "Uma tela de análise em grade: dados, gráficos vetoriais e uma tabela"
+"Apps" = "Aplicativos"
+"Apr" = "abr."
+"Aug" = "ago."
+"Bottom padding" = "Espaçamento interno inferior"
+"Bound to {name}. Click to detach the variable." = "Vinculada a {name}. Clique para desvincular a variável."
+"Checking the fonts installed on this computer…" = "Verificando as fontes instaladas neste computador…"
+"Colour and text styles, Light and Dark variables, buttons, inputs and cards" = "Estilos de cor e texto, variáveis Claro e Escuro, botões, campos e cartões"
+"Convert to frame" = "Converter em quadro"
+"Convert to section" = "Converter em seção"
+"Created" = "Criado"
+"Dashboard" = "Painel"
+"Date created" = "Data de criação"
+"Dec" = "dez."
+"Design system starter" = "Ponto de partida para sistema de design"
+"Draw a frame" = "Desenhe um quadro"
+"Drop a .figcraft, .fig, .json, .svg or image file." = "Solte um arquivo .figcraft, .fig, .json, .svg ou uma imagem."
+"Drop to import" = "Solte para importar"
+"Drop to open" = "Solte para abrir"
+"Edited {when}" = "Editado {when}"
+"Export frames and layers as PNG, JPG, SVG or PDF" = "Exporte quadros e camadas como PNG, JPG, SVG ou PDF"
+"Feb" = "fev."
+"File not found" = "Arquivo não encontrado"
+"Four screens of a trail app with components and a prototype flow" = "Quatro telas de um aplicativo de trilhas com componentes e um fluxo de protótipo"
+"Getting started" = "Primeiros passos"
+"Greyscale components and two example screens to sketch a flow with" = "Componentes em escala de cinza e duas telas de exemplo para esboçar um fluxo"
+"Hide these tips (Getting started in the Help menu shows them again)" = "Ocultar estas dicas (Primeiros passos no menu Ajuda as exibe novamente)"
+"Hide when publishing" = "Ocultar ao publicar"
+"Icon components on a 24 px grid with keylines and a size preview" = "Componentes de ícone em uma grade de 24 px, com linhas-guia e prévia de tamanho"
+"Icon set starter" = "Ponto de partida para conjunto de ícones"
+"Individual padding" = "Espaçamento interno individual"
+"Interface size" = "Tamanho da interface"
+"Jan" = "jan."
+"Jul" = "jul."
+"Jun" = "jun."
+"Kits" = "Kits"
+"Landing page" = "Página de apresentação"
+"Last modified" = "Modificado por último"
+"Left padding" = "Espaçamento interno à esquerda"
+"Link frames on the Prototype tab, then present the flow" = "Vincule os quadros na aba Protótipo e apresente o fluxo"
+"Make a component" = "Criar um componente"
+"Mar" = "mar."
+"May" = "mai."
+"Missing fonts" = "Fontes ausentes"
+"Mobile app" = "Aplicativo para celular"
+"Newest first" = "Mais recentes primeiro"
+"No files or templates match your search" = "Nenhum arquivo ou modelo corresponde à sua busca"
+"No other pages" = "Não há outras páginas"
+"No templates match your search" = "Nenhum modelo corresponde à sua busca"
+"Nov" = "nov."
+"Oct" = "out."
+"Oldest first" = "Mais antigos primeiro"
+"One announcement in five common sizes: square, portrait, story, link and banner" = "Um anúncio em cinco tamanhos comuns: quadrado, retrato, story, link e banner"
+"Opening the file…" = "Abrindo o arquivo…"
+"Opening {n} files as new files" = { one = "Abrindo como um novo arquivo", other = "Abrindo {n} arquivos como novos arquivos" }
+"Order" = "Ordem"
+"Other" = "Outro"
+"Pick the Frame tool, then drag on the canvas or choose a device size" = "Selecione a ferramenta Quadro e arraste na tela ou escolha o tamanho de um dispositivo"
+"Plugin" = "Plugin"
+"Plugins & widgets" = "Plugins e widgets"
+"Presentation slides" = "Slides de apresentação"
+"Playground" = "Área de testes"
+"Relative to your system's display scaling (100% is the system's own size). Document zoom is separate." = "Em relação à escala de exibição do sistema (100% corresponde ao tamanho definido pelo sistema). O zoom do documento é independente."
+"Remove from recents" = "Remover dos recentes"
+"Reorder selection" = "Reordenar seleção"
+"Right padding" = "Espaçamento interno à direita"
+"Search templates" = "Buscar modelos"
+"See all templates" = "Ver todos os modelos"
+"Select layers and they space themselves as their content changes" = "Selecione camadas e elas ajustarão o espaçamento conforme o conteúdo mudar"
+"Search files and templates" = "Buscar arquivos e modelos"
+"Search results" = "Resultados da busca"
+"Search pages" = "Buscar páginas"
+"Sep" = "set."
+"Share with a code" = "Compartilhar com um código"
+"Show all templates" = "Mostrar todos os modelos"
+"Show in Explorer" = "Mostrar no Explorador de Arquivos"
+"Show in Finder" = "Mostrar no Finder"
+"Show in folder" = "Mostrar na pasta"
+"Social and slides" = "Redes sociais e slides"
+"Social post sizes" = "Tamanhos de publicação para redes sociais"
+"Sort by" = "Ordenar por"
+"Sort by {column}" = "Ordenar por {column}"
+"Start from a template" = "Começar com um modelo"
+"Start sharing with the Share button, then pass on the code it gives" = "Comece a compartilhar pelo botão Compartilhar e envie o código gerado"
+"Templates" = "Modelos"
+"The destination document is unavailable. Nothing was imported." = "O documento de destino está indisponível. Nada foi importado."
+"The destination document was closed. Nothing was imported." = "O documento de destino foi fechado. Nada foi importado."
+"The destination page was removed. Nothing was imported." = "A página de destino foi removida. Nada foi importado."
+"The window is too small for {size}%, so the interface is drawn at {drawn}%. Make the window larger to use {size}%." = "A janela é pequena demais para {size}%, então a interface é exibida em {drawn}%. Aumente a janela para usar {size}%."
+"This file uses fonts that aren't installed on this computer. Their text is drawn in a fallback font until you install them." = "Este arquivo usa fontes que não estão instaladas neste computador. O texto será exibido com uma fonte substituta até que você as instale."
+"Top padding" = "Espaçamento interno superior"
+"Try another search, or browse templates." = "Tente outra busca ou explore os modelos."
+"Try another word, or look at every kind." = "Tente outra palavra ou veja todos os tipos."
+"Turn a layer into a component, reuse it, and change every copy at once" = "Transforme uma camada em componente, reutilize-a e altere todas as cópias de uma só vez"
+"Use your browser's zoom to change the interface size." = "Use o zoom do navegador para alterar o tamanho da interface."
+"Uses variables: each layer shows them in its own mode" = "Usa variáveis: cada camada as exibe em seu próprio modo"
+"Websites" = "Sites"
+"What you try here changes this preview and the code below, not the file" = "O que você experimentar aqui altera esta prévia e o código abaixo, não o arquivo"
+"Widget" = "Widget"
+"Wireframe kit" = "Kit de wireframe"
+"Z to A" = "De Z a A"
+"just now" = "agora mesmo"
+"only in a text style or variable" = "somente em um estilo de texto ou variável"
+"slot layers without a matching slot property were imported as frames" = "camadas de slot sem uma propriedade de slot correspondente foram importadas como quadros"
+"yesterday" = "ontem"
+"{month} {day}, {year}" = "{day} de {month} de {year}"
+"{n} text layers" = { one = "{n} camada de texto", other = "{n} camadas de texto" }
+"{percent}%" = "{percent}%"
 
 [commands]
 "align.bottom" = "Alinhar embaixo"
@@ -1545,7 +1813,17 @@ status = "draft — needs native review"
 "arrange.packH" = "Compactar na horizontal"
 "arrange.packV" = "Compactar na vertical"
 "arrange.roundToPixels" = "Arredondar para pixels"
+"arrange.spacing" = "Espaçamento"
 "arrange.tidy" = "Organizar"
+"board.connector" = "Conector"
+"board.ink" = "Traço de marcador"
+"board.label" = "Rótulo do conector"
+"board.nextSticky" = "Próxima nota adesiva"
+"board.setColor" = "Cor no quadro"
+"board.setStyle" = "Estilo no quadro"
+"board.shape" = "Forma com texto"
+"board.stamp" = "Carimbo"
+"board.sticky" = "Nota adesiva"
 "bool.exclude" = "Excluir sobreposição da seleção"
 "bool.flatten" = "Nivelar booleano"
 "bool.intersect" = "Interseção da seleção"
@@ -1644,6 +1922,7 @@ status = "draft — needs native review"
 "edit.duplicate" = "Duplicar"
 "edit.findReplace" = "Localizar e substituir"
 "edit.paste" = "Colar"
+"edit.pasteDesignLayers" = "Colar camadas de design"
 "edit.pasteOver" = "Colar sobre a seleção"
 "edit.pasteProperties" = "Colar propriedades"
 "edit.pasteReplace" = "Colar para substituir"
@@ -1667,7 +1946,9 @@ status = "draft — needs native review"
 "file.exportLayers" = "Exportar camadas"
 "file.exportSvg" = "Exportar seleção como SVG"
 "file.import" = "Importar"
+"file.moveTab" = "Mover aba"
 "file.new" = "Novo arquivo de design"
+"file.newBoard" = "Novo quadro"
 "file.open" = "Abrir"
 "file.openRecent" = "Abrir recente"
 "file.placeImage" = "Inserir imagem"
@@ -1804,6 +2085,7 @@ status = "draft — needs native review"
 "pref.reduceMotion" = "Reduzir movimento"
 "pref.renameDuplicates" = "Renomear camadas duplicadas"
 "pref.showDimensions" = "Mostrar dimensões nos objetos"
+"pref.startOnHome" = "Começar no Início"
 "pref.userName" = "Seu nome nos comentários"
 "proto.action.add" = "Adicionar ação de protótipo"
 "proto.action.move" = "Reordenar ação de protótipo"
@@ -1847,6 +2129,10 @@ status = "draft — needs native review"
 "select.sameStroke" = "Selecionar mesmo traço"
 "select.sameText" = "Selecionar mesmas propriedades de texto"
 "select.set" = "Selecionar"
+"selection.applyColorStyle" = "Aplicar estilo de cor à seleção"
+"selection.colors" = "Cores da seleção"
+"selection.selectColor" = "Selecionar camadas com esta cor"
+"selection.setPaint" = "Alterar cor da seleção"
 "shape.arrow" = "Seta"
 "shape.ellipse" = "Elipse"
 "shape.line" = "Linha"
@@ -1926,10 +2212,14 @@ status = "draft — needs native review"
 "text.weightUp" = "Aumentar peso da fonte"
 "tool.arrow" = "Seta"
 "tool.comment" = "Comentário"
+"tool.connector" = "Conector"
 "tool.ellipse" = "Elipse"
+"tool.eraser" = "Borracha"
 "tool.frame" = "Quadro"
 "tool.hand" = "Mão"
+"tool.highlighter" = "Marca-texto"
 "tool.line" = "Linha"
+"tool.marker" = "Marcador"
 "tool.move" = "Mover"
 "tool.pen" = "Caneta"
 "tool.pencil" = "Lápis"
@@ -1941,9 +2231,12 @@ status = "draft — needs native review"
 "tool.scaleAnchor" = "Âncora de escala"
 "tool.section" = "Seção"
 "tool.set" = "Escolher ferramenta"
+"tool.shape" = "Formas"
 "tool.shapeBuilder" = "Construtor de formas"
 "tool.slice" = "Fatia"
+"tool.stamp" = "Carimbo"
 "tool.star" = "Estrela"
+"tool.sticky" = "Nota adesiva"
 "tool.text" = "Texto"
 "transform.move" = "Mover"
 "transform.moveTo" = "Mover para"
@@ -2005,11 +2298,13 @@ status = "draft — needs native review"
 "vector.edit.tool" = "Ferramenta de edição vetorial"
 "vector.edit.transform" = "Transformar pontos"
 "vector.edit.widthPoint" = "Ponto de largura"
+"vector.fillRule" = "Definir regra de preenchimento"
 "vector.flatten" = "Nivelar"
 "vector.join" = "Unir seleção"
 "vector.offset" = "Deslocar caminho"
 "vector.outlineStroke" = "Contornar traço"
 "vector.reverse" = "Inverter direção do caminho"
+"vector.reverseLoop" = "Inverter laço"
 "vector.simplify" = "Simplificar vetor"
 "vector.smoothJoin" = "Unir seleção com suavização"
 "version.autosave" = "Salvar versão automaticamente"
diff --git a/crates/ui-egui/locales/ru.toml b/crates/ui-egui/locales/ru.toml
index 3ab407572..baba56fd6 100644
--- a/crates/ui-egui/locales/ru.toml
+++ b/crates/ui-egui/locales/ru.toml
@@ -1,5 +1,6 @@
 # FigCraft interface strings: Russian.
 # Wording reviewed and approved by VanTan.
+# Strings added since that review (2026-10-20) are a machine draft awaiting review.
 # Keep Frame, Dev Mode and Smart animate as familiar tool names.
 # See docs/translating.md; plural forms follow Russian integer rules.
 
@@ -15,6 +16,8 @@ name = "Русский"
 "1…9, 0" = "1…9, 0"
 "@{login}: {prs} PRs, {commits} commits, +{added} / −{deleted} lines (Δ {delta}), +{bin_added} / −{bin_deleted} binary assets, {first} – {last}" = "@{login}: PR: {prs}, коммитов: {commits}, +{added} / −{deleted} строк (Δ {delta}), +{bin_added} / −{bin_deleted} бинарных ресурсов, {first} – {last}"
 "A collection of this file with these modes and variables: override their values per mode and add variables of its own" = "Коллекция этого файла с этими режимами и переменными: переопределяйте значения для каждого режима и добавляйте собственные переменные"
+"A .figcraft file with this name already exists. Choose its full name to confirm replacement." = "Файл .figcraft с таким именем уже существует. Чтобы подтвердить замену, выберите его полное имя."
+"A layer on its own aligns to its frame: select more layers, or one in a frame" = "Отдельный слой выравнивается по своему фрейму: выделите больше слоёв или слой внутри фрейма."
 "A responsive product page: hero, features, figures, a quote and a footer" = "Адаптивная страница продукта: главный блок, возможности, показатели, цитата и подвал"
 "A spring plays until it settles: its mass, stiffness and damping set how long" = "Пружинная анимация длится до затухания: её время задают масса, жёсткость и демпфирование"
 "A title, an agenda, a big figure, a chart and a closing slide" = "Заголовок, повестка, крупный показатель, диаграмма и заключительный слайд"
@@ -64,6 +67,7 @@ name = "Русский"
 "Add variant with a new value" = "Добавить вариант с новым значением"
 "Added" = "Добавлено"
 "Added the library \"{name}\"" = "Добавлена библиотека «{name}»"
+"Adding to {name}" = "Добавление в {name}"
 "Adjust" = "Коррекция"
 "Adjustment presets" = "Пресеты коррекции"
 "Advanced" = "Дополнительно"
@@ -87,6 +91,7 @@ name = "Русский"
 "All components" = "Все компоненты"
 "All fonts" = "Все шрифты"
 "All supported properties" = "Все поддерживаемые свойства"
+"All the fonts this file uses are installed" = "Все шрифты, которые использует этот файл, установлены"
 "All variables" = "Все переменные"
 "Alpha" = "Альфа"
 "Alphabetical" = "По алфавиту"
@@ -120,6 +125,7 @@ name = "Русский"
 "Archived" = "В архиве"
 "Arrange" = "Упорядочить"
 "Arrow" = "Стрелка"
+"Arrow at the end" = "Стрелка на конце"
 "As typed" = "Как введено"
 "Asking the server…" = "Запрос к серверу…"
 "Assets" = "Ресурсы"
@@ -167,6 +173,7 @@ name = "Русский"
 "Both directions" = "Оба направления"
 "Bottom" = "Снизу"
 "Bottom left radius" = "Радиус нижнего левого угла"
+"Bottom padding" = "Нижний внутренний отступ"
 "Bottom right radius" = "Радиус нижнего правого угла"
 "Branch" = "Ветка"
 "Branch archived" = "Ветка архивирована"
@@ -193,7 +200,10 @@ name = "Русский"
 "C or ⇧C" = "C или ⇧C"
 "CMYK colour" = "Цвет CMYK"
 "Can view" = "Может просматривать"
+"Check" = "Галочка"
+"Checking the fonts installed on this computer…" = "Проверка шрифтов, установленных на этом компьютере…"
 "Checking the server…" = "Проверка сервера…"
+"Chevron" = "Шеврон"
 "Clear from this list" = "Убрать из этого списка"
 "Code or invite link" = "Код или ссылка приглашения"
 "Color profile: {name}" = "Цветовой профиль: {name}"
@@ -240,7 +250,6 @@ name = "Русский"
 "Close tab" = "Закрыть вкладку"
 "Close version history" = "Закрыть историю версий"
 "Close when clicking outside" = "Закрывать при нажатии снаружи"
-"Close without saving" = "Закрыть без сохранения"
 "Code" = "Код"
 "Code syntax" = "Синтаксис кода"
 "Collapse" = "Свернуть"
@@ -267,6 +276,7 @@ name = "Русский"
 "Commits" = "Коммиты"
 "Company" = "Компания"
 "Compare changes" = "Сравнить изменения"
+"Compatibility notes" = "Замечания о совместимости"
 "Completed" = "Завершено"
 "Component" = "Компонент"
 "Component name" = "Имя компонента"
@@ -281,6 +291,7 @@ name = "Русский"
 "Connected" = "Подключено"
 "Connected to code: {from}" = "Связано с кодом: {from}"
 "Connection lost, reconnecting (attempt {attempt})…" = "Соединение потеряно, переподключение (попытка {attempt})…"
+"Connector" = "Соединитель"
 "Constrain proportions" = "Сохранять пропорции"
 "Constraints" = "Ограничения"
 "Content" = "Содержимое"
@@ -291,6 +302,8 @@ name = "Русский"
 "Contributors" = "Участники"
 "Contributors: {people} · Commits: {commits}" = "Участники: {people} · Коммиты: {commits}"
 "Controller" = "Контроллер"
+"Convert to frame" = "Преобразовать во Frame"
+"Convert to section" = "Преобразовать в секцию"
 "Cool" = "Холодный"
 "Copied as CSS" = "Скопировано как CSS"
 "Copied as PNG" = "Скопировано как PNG"
@@ -308,7 +321,10 @@ name = "Русский"
 "Copy {value}" = "Копировать {value}"
 "Corner radius" = "Радиус углов"
 "Corner smoothing" = "Сглаживание углов"
+"Couldn't download the variables" = "Не удалось загрузить переменные"
 "Couldn't reach {server}: showing what this computer remembers." = "Не удалось связаться с {server}: показаны данные, сохранённые на этом компьютере."
+"Couldn't read {name}." = "Не удалось прочитать {name}."
+"Couldn't save automatically: {error}" = "Не удалось сохранить автоматически: {error}"
 "Count" = "Количество"
 "Create" = "Создать"
 "Create a variable collection first" = "Сначала создайте коллекцию переменных"
@@ -332,6 +348,7 @@ name = "Русский"
 "Current version" = "Текущая версия"
 "Cursor chat" = "Чат у курсора"
 "Custom" = "Пользовательский"
+"Custom size" = "Пользовательский размер"
 "Cut" = "Вырезать"
 "Dark" = "Тёмная"
 "Darken" = "Затемнение"
@@ -365,6 +382,7 @@ name = "Русский"
 "Description" = "Описание"
 "Description (optional)" = "Описание (необязательно)"
 "Design" = "Дизайн"
+"Design panel" = "Панель дизайна"
 "Design system starter" = "Основа дизайн-системы"
 "Desktop" = "Компьютер"
 "Destination" = "Назначение"
@@ -392,6 +410,7 @@ name = "Русский"
 "Distribute horizontal spacing" = "Распределить по горизонтали"
 "Distribute vertical spacing" = "Распределить по вертикали"
 "Divider" = "Разделитель"
+"Don't Save" = "Не сохранять"
 "Don't truncate" = "Не обрезать"
 "Done" = "Готово"
 "Done editing" = "Завершить редактирование"
@@ -403,7 +422,10 @@ name = "Русский"
 "Draw" = "Рисование"
 "Draw a frame" = "Нарисовать Frame"
 "Drawing tools" = "Инструменты рисования"
+"Drop a .figcraft, .fig, .json, .svg or image file." = "Перетащите файл .figcraft, .fig, .json, .svg или изображение."
 "Drop shadow" = "Внешняя тень"
+"Drop to import" = "Отпустите, чтобы импортировать"
+"Drop to open" = "Отпустите, чтобы открыть"
 "Dual-licensed MIT OR Apache-2.0. Made by the ArtCraft team and community." = "Двойная лицензия MIT OR Apache-2.0. Создано командой и сообществом ArtCraft."
 "Duo" = "Дуо"
 "Duplicate" = "Дублировать"
@@ -424,6 +446,7 @@ name = "Русский"
 "Effect settings" = "Настройки эффекта"
 "Effect styles" = "Стили эффектов"
 "Effects" = "Эффекты"
+"Elbow" = "Ломаная"
 "Ellipse" = "Эллипс"
 "Ellipses" = "Эллипсы"
 "Else" = "Иначе"
@@ -473,6 +496,8 @@ name = "Русский"
 "False" = "Ложь"
 "Feb" = "февр."
 "Fetching from the server…" = "Загрузка с сервера…"
+"FigCraft couldn't open its window: {error}" = "FigCraft не смог открыть своё окно: {error}"
+"FigCraft doesn't support every feature of these files yet. The notes list what was left out or changed in the imported copy; the original file is unchanged." = "FigCraft пока поддерживает не все возможности этих файлов. В замечаниях перечислено, что было пропущено или изменено в импортированной копии; исходный файл не меняется."
 "File" = "Файл"
 "File name" = "Имя файла"
 "File not found" = "Файл не найден"
@@ -558,6 +583,7 @@ name = "Русский"
 "Hanging list" = "Выступающий список"
 "Hanging punctuation" = "Висячая пунктуация"
 "Hard light" = "Жёсткий свет"
+"Heart" = "Сердце"
 "Height" = "Высота"
 "Help" = "Справка"
 "Help and resources" = "Справка и ресурсы"
@@ -570,6 +596,7 @@ name = "Русский"
 "Hide these tips (Getting started in the Help menu shows them again)" = "Скрыть подсказки (их можно вернуть через «Начало работы» в меню справки)"
 "Hide when publishing" = "Скрывать при публикации"
 "Highlight layers on hover" = "Подсвечивать слои при наведении"
+"Highlighter" = "Текстовыделитель"
 "Highlights" = "Света"
 "Hold Alt" = "Удерживайте Alt"
 "Hold Alt+Z" = "Удерживайте Alt+Z"
@@ -593,14 +620,18 @@ name = "Русский"
 "Icon components on a 24 px grid with keylines and a size preview" = "Компоненты иконок на сетке 24 px с направляющими и предпросмотром размеров"
 "Icon set starter" = "Основа набора иконок"
 "If" = "Если"
+"If it keeps happening, please report it at {link} with this message." = "Если это повторяется, сообщите об этом по адресу {link}, приложив это сообщение."
 "If {condition}" = "Если {condition}"
 "Ignore auto layout (absolute position)" = "Игнорировать автолейаут (абсолютная позиция)"
 "Image" = "Изображение"
+"Images" = "Изображения"
 "Import" = "Импорт"
 "Import path" = "Путь импорта"
 "Import plugin from manifest" = "Импортировать плагин из манифеста"
 "Import plugin from manifest…" = "Импортировать плагин из манифеста…"
+"Import report" = "Отчёт об импорте"
 "Import variables" = "Импортировать переменные"
+"Imported document" = "Импортированный документ"
 "Imported {name}" = "Импортировано: {name}"
 "Imported {n} new variables, updated {updated}" = { one = "Импортирована {n} новая переменная, обновлено: {updated}", few = "Импортированы {n} новые переменные, обновлено: {updated}", many = "Импортировано {n} новых переменных, обновлено: {updated}", other = "Импортировано {n} новой переменной, обновлено: {updated}" }
 "Import…" = "Импорт…"
@@ -611,6 +642,7 @@ name = "Русский"
 "Included" = "Включено"
 "Included in layout" = "Участвует в компоновке"
 "Individual corners" = "Углы по отдельности"
+"Individual padding" = "Внутренние отступы по отдельности"
 "Individual strokes" = "Обводки по отдельности"
 "Ink" = "Чернила"
 "Inner shadow" = "Внутренняя тень"
@@ -628,11 +660,14 @@ name = "Русский"
 "Instance swap (no other component)" = "Замена экземпляра (других компонентов нет)"
 "Instances" = "Экземпляры"
 "Instant" = "Мгновенно"
+"Intensity" = "Яркость"
 "Interaction" = "Взаимодействие"
 "Interactions" = "Взаимодействия"
 "Interface design and prototyping. A free, open-source, clean-room design tool written from scratch in Rust, part of the ArtCraft Crafting Apps." = "Дизайн интерфейсов и прототипирование. Бесплатный инструмент с открытым исходным кодом, независимо созданный с нуля на Rust, из семейства ArtCraft Crafting Apps."
+"Interface size" = "Размер интерфейса"
 "Intersect" = "Пересечение"
 "Intersects" = "Пересечения"
+"Invalid color" = "Недопустимый цвет"
 "Invite link" = "Ссылка приглашения"
 "Invite link copied" = "Ссылка приглашения скопирована"
 "It asks permission to:" = "Запрашивает разрешение на:"
@@ -679,6 +714,7 @@ name = "Русский"
 "Leaves" = "Листья"
 "Left" = "Слева"
 "Left & right" = "Слева и справа"
+"Left padding" = "Левый внутренний отступ"
 "Left side" = "Левая сторона"
 "Left side width" = "Ширина левой стороны"
 "Letter case" = "Регистр букв"
@@ -730,6 +766,7 @@ name = "Русский"
 "Mark as resolved" = "Отметить как решённое"
 "Mark as unread" = "Отметить как непрочитанное"
 "Mark as unresolved" = "Отметить как нерешённое"
+"Marker" = "Маркер"
 "Mask" = "Маска"
 "Mass · Stiffness · Damping" = "Масса · Жёсткость · Демпфирование"
 "Match (empty: the whole name)" = "Совпадение (пусто: всё имя)"
@@ -751,6 +788,7 @@ name = "Русский"
 "Mirror angle and length" = "Отражать угол и длину"
 "Mirroring" = "Зеркальность"
 "Missing" = "Отсутствует"
+"Missing fonts" = "Отсутствующие шрифты"
 "Missing layer" = "Слой отсутствует"
 "Missing style" = "Стиль отсутствует"
 "Missing variable" = "Переменная отсутствует"
@@ -788,8 +826,10 @@ name = "Русский"
 "Named instance" = "Именованный экземпляр"
 "Navigate to" = "Перейти к"
 "Nested instance" = "Вложенный экземпляр"
+"New board" = "Новая доска"
 "New design file" = "Новый файл дизайна"
 "Newest first" = "Сначала новые"
+"Next frame" = "Следующий Frame"
 "Next or previous control in the focused region" = "Следующий или предыдущий элемент в активной области"
 "Next ready for dev" = "Следующий готовый к разработке"
 "Next size option" = "Следующий вариант размера"
@@ -799,13 +839,17 @@ name = "Русский"
 "No branches. A branch is a copy of the file to try changes in, then review and merge." = "Веток нет. Ветка — копия файла, в которой можно попробовать изменения, затем проверить и объединить их."
 "No category" = "Без категории"
 "No changes" = "Нет изменений"
+"No color styles" = "Нет цветовых стилей"
 "No colour variables fit here." = "Нет подходящих цветовых переменных."
 "No colour variables yet. Create them in Local variables." = "Цветовых переменных пока нет. Создайте их в разделе «Локальные переменные»."
 "No comments yet" = "Комментариев пока нет"
+"No compatibility warnings reported" = "Предупреждений о совместимости нет"
 "No components yet. Select layers and press {keys}." = "Компонентов пока нет. Выделите слои и нажмите {keys}."
 "No conflicts." = "Конфликтов нет."
 "No contributor data was built into this copy." = "В этой сборке нет данных об участниках."
+"No device" = "Без устройства"
 "No fonts match" = "Подходящих шрифтов нет"
+"No files or templates match your search" = "Файлы и шаблоны по запросу не найдены"
 "No join code here (the server is older than join codes, or this address can't be put in one): share the link instead." = "Код подключения недоступен (сервер не поддерживает коды или адрес нельзя включить в код): поделитесь ссылкой."
 "No layer changes to show." = "Нет изменений слоёв для показа."
 "No libraries yet. Add a .figcraft file that was published as a library, or paste a team library's link." = "Библиотек пока нет. Добавьте файл .figcraft, опубликованный как библиотека, или вставьте ссылку на командную библиотеку."
@@ -819,6 +863,7 @@ name = "Русский"
 "No model credits were built into this copy." = "В этой сборке нет сведений об использованных моделях."
 "No number variables fit here." = "Нет подходящих числовых переменных."
 "No number variables yet. Create them in Local variables." = "Числовых переменных пока нет. Создайте их в разделе «Локальные переменные»."
+"No other pages" = "Других страниц нет"
 "No paints" = "Заливок нет"
 "No plugins on {server}." = "На {server} нет плагинов."
 "No plugins yet. Import a development plugin from its figcraft-plugin.json." = "Плагинов пока нет. Импортируйте плагин для разработки из его figcraft-plugin.json."
@@ -885,6 +930,7 @@ name = "Русский"
 "Open branch" = "Открыть ветку"
 "Open file" = "Открыть файл"
 "Open files" = "Открыть файлы"
+"Open presentations" = "Открытые презентации"
 "Open in focus view" = "Открыть в режиме фокуса"
 "Open in new window" = "Открыть в новом окне"
 "Open invite links in FigCraft" = "Открывать ссылки приглашения в FigCraft"
@@ -893,11 +939,15 @@ name = "Русский"
 "Open overlay" = "Открыть оверлей"
 "Open prototype preview" = "Открыть предпросмотр прототипа"
 "Open variables ({count})" = "Открыть переменные ({count})"
+"Opened as a new document" = "Открыт как новый документ"
 "Opened “{name}” in a new tab" = "«{name}» открыт в новой вкладке"
+"Opening the file…" = "Открытие файла…"
+"Opening {n} files as new files" = { one = "Открытие {n} файла как нового", few = "Открытие {n} файлов как новых", many = "Открытие {n} файлов как новых", other = "Открытие {n} файлов как новых" }
 "Open|comments" = "Открытые"
 "Options" = "Параметры"
 "Orange" = "Оранжевый"
 "Order" = "Порядок"
+"Other" = "Другое"
 "Other apps may not open every .fig file exported here." = "Другие приложения могут открыть не каждый экспортированный здесь файл .fig."
 "Others lose access and keep their copy; the file stays on the server for you" = "Другие участники потеряют доступ, сохранив свои копии; файл останется на сервере для вас"
 "Others type this under Share ▸ Join with a code" = "Другие участники вводят это в «Поделиться» ▸ «Подключиться по коду»"
@@ -916,7 +966,11 @@ name = "Русский"
 "PDF print settings" = "Настройки печати PDF"
 "Padding" = "Внутренние отступы"
 "Page" = "Страница"
+"Page deleted" = "Страница удалена"
 "Pages" = "Страницы"
+"Pages added to the document" = "Страницы добавлены в документ"
+"Pink" = "Розовый"
+"Placed on the current page" = "Размещено на текущей странице"
 "Pages: {pages}" = "Страницы: {pages}"
 "Paint bucket" = "Заливка области"
 "Pan the canvas" = "Перемещение по холсту"
@@ -931,6 +985,7 @@ name = "Русский"
 "Paste a team library link (a view link)" = "Вставьте ссылку на командную библиотеку (для просмотра)"
 "Paste here" = "Вставить здесь"
 "Paste to replace" = "Вставить с заменой"
+"Pasted design layers; {n} kinds of content were left out" = { one = "Слои дизайна вставлены; пропущен {n} тип содержимого", few = "Слои дизайна вставлены; пропущены {n} типа содержимого", many = "Слои дизайна вставлены; пропущено {n} типов содержимого", other = "Слои дизайна вставлены; пропущено {n} типа содержимого" }
 "Pattern" = "Паттерн"
 "Pattern alignment" = "Выравнивание паттерна"
 "Pattern scale" = "Масштаб паттерна"
@@ -953,10 +1008,13 @@ name = "Русский"
 "Place a shape or frame (its tool chosen)" = "Разместить фигуру или Frame (выбранным инструментом)"
 "Place automatically" = "Разместить автоматически"
 "Place image" = "Разместить изображение"
+"Plugin" = "Плагин"
+"Plugins & widgets" = "Плагины и виджеты"
 "Plugins run in FigCraft's sandbox, without files, network or clock. Install only plugins you trust." = "Плагины работают в песочнице FigCraft без доступа к файлам, сети и часам. Устанавливайте только плагины, которым доверяете."
 "Plugins" = "Плагины"
 "Plus darker" = "Линейное затемнение"
 "Plus lighter" = "Линейное осветление"
+"Plus one" = "Плюс один"
 "Point" = "Точка"
 "Points" = "Точки"
 "Polygon" = "Многоугольник"
@@ -984,6 +1042,7 @@ name = "Русский"
 "Preview" = "Предпросмотр"
 "Preview this flow" = "Предпросмотр этого сценария"
 "Preview this frame" = "Предпросмотр этого Frame"
+"Previous frame" = "Предыдущий Frame"
 "Previous ready for dev" = "Предыдущий готовый к разработке"
 "Progressive" = "Прогрессивный"
 "Properties" = "Свойства"
@@ -1004,6 +1063,7 @@ name = "Русский"
 "Push" = "Вытеснение"
 "Push changes to main component" = "Перенести изменения в основной компонент"
 "Put text on path" = "Разместить текст на пути"
+"Question" = "Вопрос"
 "R" = "R"
 "Radial" = "Радиальный"
 "Radius" = "Радиус"
@@ -1021,6 +1081,7 @@ name = "Русский"
 "Reduce motion" = "Уменьшить движение"
 "Refraction" = "Преломление"
 "Regular expression" = "Регулярное выражение"
+"Relative to your system's display scaling (100% is the system's own size). Document zoom is separate." = "Относительно масштаба экрана в системе (100% — собственный размер системы). Масштаб документа задаётся отдельно."
 "Remove" = "Удалить"
 "Remove all" = "Удалить всё"
 "Remove annotation" = "Удалить аннотацию"
@@ -1044,6 +1105,7 @@ name = "Русский"
 "Remove the else and its actions" = "Удалить «Иначе» и его действия"
 "Remove this condition and its actions" = "Удалить это условие и его действия"
 "Remove this file from the server? It can't be shared or opened from there again. Your copy stays open here." = "Удалить файл с сервера? Его больше нельзя будет открывать и публиковать оттуда. Ваша копия останется открытой здесь."
+"Remove {name} from session" = "Убрать {name} из сессии"
 "Remove {name} from {server}?" = "Удалить {name} с {server}?"
 "Removed" = "Удалено"
 "Removed from the server" = "Удалено с сервера"
@@ -1058,6 +1120,7 @@ name = "Русский"
 "Rename on the server…" = "Переименовать на сервере…"
 "Rename page" = "Переименовать страницу"
 "Rename to" = "Новое имя"
+"Reorder selection" = "Изменить порядок выделения"
 "Replace all" = "Заменить всё"
 "Replace mixed export settings" = "Заменить разные настройки экспорта"
 "Replace with" = "Заменить на"
@@ -1077,6 +1140,7 @@ name = "Русский"
 "Resize by the nudge amount" = "Изменить размер на шаг сдвига"
 "Resize frames to the device's screen (or the window without a device): their constraints and auto layout respond" = "Менять размер Frame под экран устройства (или окно, если устройство не выбрано): ограничения и автолейаут подстраиваются"
 "Resize to fit" = "Подогнать размер"
+"Resizing" = "Изменение размера"
 "Resolve" = "Решить"
 "Resolve change" = "Разрешить изменение"
 "Resolved" = "Решённые"
@@ -1092,6 +1156,7 @@ name = "Русский"
 "Review and merge" = "Проверить и объединить"
 "Ribbon" = "Лента"
 "Right" = "Справа"
+"Right padding" = "Правый внутренний отступ"
 "Right side" = "Правая сторона"
 "Right side width" = "Ширина правой стороны"
 "Rotate 90°" = "Повернуть на 90°"
@@ -1102,6 +1167,7 @@ name = "Русский"
 "Rotation jitter" = "Колебание угла"
 "Round" = "Круглое"
 "Rounded" = "Скруглённый"
+"Rounded rectangle" = "Скруглённый прямоугольник"
 "Row" = "Строка"
 "Row gap" = "Интервал между строками"
 "Row sizes" = "Размеры строк"
@@ -1111,6 +1177,8 @@ name = "Русский"
 "Rulers" = "Линейки"
 "Run" = "Запустить"
 "Run {label}" = "Запустить {label}"
+"Save files automatically" = "Автоматически сохранять файлы"
+"Search pages" = "Поиск страниц"
 "Search templates" = "Поиск шаблонов"
 "See all templates" = "Все шаблоны"
 "Select layers and they space themselves as their content changes" = "Выделите слои: интервалы между ними будут подстраиваться при изменении содержимого"
@@ -1137,6 +1205,8 @@ name = "Русский"
 "Search actions, layers and tools" = "Поиск действий, слоёв и инструментов"
 "Search assets" = "Поиск ресурсов"
 "Search comments" = "Поиск комментариев"
+"Search files and templates" = "Поиск файлов и шаблонов"
+"Search results" = "Результаты поиска"
 "Search fonts" = "Поиск шрифтов"
 "Search layers" = "Поиск слоёв"
 "Search shortcuts" = "Поиск сочетаний клавиш"
@@ -1150,12 +1220,14 @@ name = "Русский"
 "Select all with same" = "Выделить всё с одинаковым"
 "Select layer" = "Выделить слой"
 "Select layers to apply the style to" = "Выделите слои для применения стиля"
+"Select layers with this color" = "Выделить слои с этим цветом"
 "Select overlapping shapes" = "Выделите пересекающиеся фигуры"
 "Select points to edit their position, radius and mirroring" = "Выделите точки для изменения положения, радиуса и зеркальности"
 "Select slot" = "Выделить слот"
 "Selection" = "Выделение"
 "Selection box, {w} by {h} at {x}, {y}: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "Область выделения {w} на {h} в {x}, {y}: стрелки — перемещение, Shift+стрелки или {cmd}+стрелки — размер, Enter — выделить, Escape — отменить"
 "Selection box: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "Область выделения: стрелки — перемещение, Shift+стрелки или {cmd}+стрелки — размер, Enter — выделить, Escape — отменить"
+"Selection colors" = "Цвета выделения"
 "Send backward" = "На уровень назад"
 "Send report" = "Отправить жалобу"
 "Send to back" = "На задний план"
@@ -1172,6 +1244,7 @@ name = "Русский"
 "Shape" = "Фигура"
 "Shape builder" = "Конструктор фигур"
 "Shape tools" = "Инструменты фигур"
+"Shapes" = "Фигуры"
 "Share" = "Поделиться"
 "Share this file" = "Поделиться файлом"
 "Share with a code" = "Поделиться по коду"
@@ -1238,10 +1311,13 @@ name = "Русский"
 "Space+drag" = "Пробел+перетаскивание"
 "Spacing" = "Интервал"
 "Spam, stolen work, abuse…" = "Спам, украденные работы, оскорбления…"
+"Speech bubble" = "Выноска"
 "Splay" = "Расхождение"
 "Spotlight me" = "Показывать мой экран всем"
 "Spread" = "Размах"
 "Square" = "Квадрат"
+"Stamp" = "Штамп"
+"Stamps" = "Штампы"
 "Standard" = "Стандартный"
 "Standard ligatures" = "Стандартные лигатуры"
 "Star" = "Звезда"
@@ -1251,18 +1327,23 @@ name = "Русский"
 "Start from a blank canvas" = "Начать с пустого холста"
 "Start from a template" = "Начать с шаблона"
 "Start on path" = "Начало на пути"
+"Start on the Home screen" = "Начинать с главной"
 "Start point" = "Начальная точка"
 "Start sharing" = "Включить общий доступ"
 "Start sharing with the Share button, then pass on the code it gives" = "Включите общий доступ кнопкой «Поделиться», затем передайте полученный код"
 "Starting to share…" = "Включение общего доступа…"
 "Status" = "Статус"
 "Sticky" = "Закреплённый"
+"Sticky note" = "Стикер"
+"Sticky note colors" = "Цвета стикеров"
+"Sticky notes, shapes and connectors" = "Стикеры, фигуры и соединители"
 "Stop" = "Остановить"
 "Stop following {name}" = "Перестать следить за {name}"
 "Stop session" = "Завершить сессию"
 "Stop sharing" = "Остановить общий доступ"
 "Stop spotlighting" = "Прекратить показ всем"
 "Stop {n}  {hex}" = "Точка {n}  {hex}"
+"Straight" = "Прямая"
 "Stretch" = "Растянуть"
 "Strikethrough" = "Зачёркивание"
 "String" = "Строка"
@@ -1307,11 +1388,15 @@ name = "Русский"
 "Text" = "Текст"
 "Text align" = "Выравнивание текста"
 "Text content" = "Содержимое текста"
+"Text size" = "Размер текста"
 "Text style" = "Текстовый стиль"
 "Text styles" = "Текстовые стили"
 "Texts" = "Тексты"
 "Texture" = "Текстура"
 "The canvas previews colors in sRGB; exported PNG, JPG and WebP files are tagged Display P3." = "На холсте цвета отображаются в sRGB; экспортированные PNG, JPG и WebP помечены профилем Display P3."
+"The destination document is unavailable. Nothing was imported." = "Документ назначения недоступен. Ничего не импортировано."
+"The destination document was closed. Nothing was imported." = "Документ назначения закрыт. Ничего не импортировано."
+"The destination page was removed. Nothing was imported." = "Страница назначения удалена. Ничего не импортировано."
 "The file is deleted from the server: nobody can open or join it from there again, and this can't be undone. Copies that are open stay with whoever has them." = "Файл удаляется с сервера: его больше нельзя будет открыть или подключиться к нему оттуда. Отменить это нельзя. Уже открытые копии остаются у участников."
 "The file now holds another library" = "Теперь файл содержит другую библиотеку"
 "The file now holds another library (\"{name}\")" = "Теперь файл содержит другую библиотеку («{name}»)"
@@ -1321,6 +1406,7 @@ name = "Русский"
 "The selection uses several text styles: click to apply one" = "В выделении несколько текстовых стилей: нажмите, чтобы применить один"
 "The server deletes this file if nobody opens it before {date}." = "Сервер удалит файл, если никто не откроет его до {date}."
 "The whole file" = "Весь файл"
+"The window is too small for {size}%, so the interface is drawn at {drawn}%. Make the window larger to use {size}%." = "Окно слишком мало для {size}%, поэтому интерфейс отрисовывается в масштабе {drawn}%. Увеличьте окно, чтобы использовать {size}%."
 "Theme" = "Тема"
 "There's no destination for that action" = "Для этого действия не задано назначение"
 "Thickness" = "Толщина"
@@ -1332,11 +1418,14 @@ name = "Русский"
 "This file" = "Этот файл"
 "This file has unsaved changes" = "В файле есть несохранённые изменения"
 "This file is on {server}, open only to you. Share it to let others in with a new code." = "Файл находится на {server} и доступен только вам. Включите общий доступ, чтобы пригласить других по новому коду."
+"This file is too large to join here (up to {mb} MB)" = "Этот файл слишком большой, чтобы подключиться здесь (до {mb} МБ)"
+"This file uses fonts that aren't installed on this computer. Their text is drawn in a fallback font until you install them." = "В этом файле используются шрифты, не установленные на этом компьютере. Их текст отрисовывается запасным шрифтом, пока вы их не установите."
 "This frame is new on the branch." = "Этот Frame добавлен в ветке."
 "This frame isn't on the branch." = "Этого Frame нет в ветке."
 "This server is open to the public: no key needed." = "Сервер общедоступен: ключ не нужен."
 "This server needs its key: add ?key=… to the address (`figcraft-server key` prints it on the server's machine)." = "Сервер требует ключ: добавьте ?key=… к адресу (`figcraft-server key` выводит его на компьютере сервера)."
 "This server takes files only with its key: see Advanced." = "Сервер принимает файлы только с ключом: см. «Дополнительно»."
+"Thumbs up" = "Палец вверх"
 "Tidy up" = "Упорядочить"
 "Tile" = "Повторение"
 "Tile type" = "Тип повторения"
@@ -1351,8 +1440,10 @@ name = "Русский"
 "Top" = "Сверху"
 "Top & bottom" = "Сверху и снизу"
 "Top left radius" = "Радиус верхнего левого угла"
+"Top padding" = "Верхний внутренний отступ"
 "Top right radius" = "Радиус верхнего правого угла"
 "Transform" = "Трансформация"
+"Triangle" = "Треугольник"
 "Triangle arrow" = "Треугольная стрелка"
 "Trigger" = "Триггер"
 "True" = "Истина"
@@ -1360,6 +1451,7 @@ name = "Русский"
 "Truncate with an ellipsis" = "Обрезать с многоточием"
 "Try again" = "Повторить"
 "Try another search or filter." = "Попробуйте другой запрос или фильтр."
+"Try another search, or browse templates." = "Попробуйте другой запрос или просмотрите шаблоны."
 "Try another word, or look at every kind." = "Попробуйте другое слово или посмотрите все категории."
 "Turn a layer into a component, reuse it, and change every copy at once" = "Превратите слой в компонент, используйте повторно и изменяйте все копии сразу"
 "Two digits" = "Две цифры"
@@ -1377,7 +1469,7 @@ name = "Русский"
 "Unread" = "Непрочитанные"
 "Unresolve" = "Снова открыть"
 "Unsaved changes" = "Несохранённые изменения"
-"Unsaved changes in {names}. Close the window and lose them?" = "Несохранённые изменения в {names}. Закрыть окно и потерять их?"
+"Unsaved changes in {names}. Save them before closing?" = "Несохранённые изменения в {names}. Сохранить их перед закрытием?"
 "Unsaved changes: save first ({save}), or close the tab with {alt}-click to discard" = "Есть несохранённые изменения: сохраните ({save}) или закройте вкладку нажатием с {alt}, чтобы отбросить их"
 "Unsaved changes: save first, or close again with {key} to discard" = "Есть несохранённые изменения: сохраните или закройте ещё раз с {key}, чтобы отбросить их"
 "Up" = "Вверх"
@@ -1387,6 +1479,8 @@ name = "Русский"
 "Update from selection" = "Обновить из выделения"
 "Updated {components} and {styles}" = "Обновлено: {components} и {styles}"
 "Updated {name}" = "Обновлено: {name}"
+"Updating the graphics driver often helps. To use OpenGL only, start FigCraft from a Command Prompt with:" = "Часто помогает обновление драйвера видеокарты. Чтобы использовать только OpenGL, запустите FigCraft из командной строки с параметром:"
+"Updating the graphics driver often helps. WGPU_BACKEND (vulkan, gl, metal) names another graphics API to try." = "Часто помогает обновление драйвера видеокарты. Переменная WGPU_BACKEND (vulkan, gl, metal) задаёт другой графический API, который можно попробовать."
 "Uploads this file to a FigCraft server and keeps this tab in sync with it. You get a link to edit and a link to view." = "Загружает файл на сервер FigCraft и синхронизирует эту вкладку с ним. Вы получите ссылки для редактирования и просмотра."
 "Uppercase" = "Прописные"
 "Use a fixed value" = "Использовать фиксированное значение"
@@ -1394,7 +1488,9 @@ name = "Русский"
 "Use as mask" = "Использовать как маску"
 "Use auto layout" = "Использовать автолейаут"
 "Use number keys for opacity" = "Задавать непрозрачность цифровыми клавишами"
+"Use the .figcraft or .fig extension." = "Используйте расширение .figcraft или .fig."
 "Use the layer's fill" = "Использовать заливку слоя"
+"Use your browser's zoom to change the interface size." = "Изменяйте размер интерфейса масштабом браузера."
 "Used in {files} · {instances}" = "Используется в {files} · {instances}"
 "Username" = "Имя пользователя"
 "Value" = "Значение"
@@ -1429,6 +1525,7 @@ name = "Русский"
 "Visibility" = "Видимость"
 "Visible" = "Видимый"
 "Vivid" = "Яркий"
+"WGPU_BACKEND is set and names the graphics API to use; unsetting it lets FigCraft choose." = "Переменная WGPU_BACKEND задана и указывает используемый графический API; если её убрать, FigCraft выберет сам."
 "Warm" = "Тёплый"
 "Watch" = "Часы"
 "Wavy" = "Волнистый"
@@ -1448,6 +1545,7 @@ name = "Русский"
 "White" = "Белый"
 "Who runs it, its terms and how long it keeps files" = "Оператор, условия и срок хранения файлов"
 "Why it changed" = "Причина изменения"
+"Widget" = "Виджет"
 "Widgets" = "Виджеты"
 "Width" = "Ширина"
 "Width point" = "Точка ширины"
@@ -1486,26 +1584,121 @@ name = "Русский"
 "call any command its access allows" = "вызывать любые команды в рамках разрешений"
 "call only: {commands}" = "вызывать только: {commands}"
 "can edit the document" = "может редактировать документ"
+"conditional prototype actions nested too deeply were skipped" = "условные действия прототипа со слишком глубокой вложенностью пропущены"
+"conditional prototype actions with conditions that can't be evaluated were skipped" = "условные действия прототипа с условиями, которые нельзя вычислить, пропущены"
+"connector label background was skipped: style data is missing" = "фон подписи соединительной линии пропущен: нет данных стиля"
+"connector label was skipped: background bounds are invalid" = "подпись соединительной линии пропущена: недопустимые границы фона"
+"connector label was skipped: background transform is invalid" = "подпись соединительной линии пропущена: недопустимая трансформация фона"
+"connector label was skipped: composed text transform is invalid" = "подпись соединительной линии пропущена: недопустимая составная трансформация текста"
+"connector label was skipped: derived background bounds are missing" = "подпись соединительной линии пропущена: нет вычисленных границ фона"
+"connector label was skipped: derived text bounds are missing" = "подпись соединительной линии пропущена: нет вычисленных границ текста"
+"connector label was skipped: text bounds are invalid" = "подпись соединительной линии пропущена: недопустимые границы текста"
+"connector label was skipped: text style data is missing" = "подпись соединительной линии пропущена: нет данных стиля текста"
+"connector label was skipped: text transform is invalid" = "подпись соединительной линии пропущена: недопустимая трансформация текста"
+"connector labels were skipped" = "подписи соединительных линий пропущены"
+"connector layers import as static frame/vector snapshots with labels when present; live endpoint bindings are not retained" = "соединительные линии импортируются как статичные снимки фреймов или векторов, с подписями, если они есть; динамические привязки концов не сохраняются"
+"connector snapshot vector data is missing; connector was left empty" = "нет векторных данных снимка соединительной линии; соединительная линия оставлена пустой"
+"connectors whose ends can't be placed are empty" = "соединительные линии, концы которых нельзя разместить, пусты"
 "crop marks" = "метки обреза"
+"damaged vector geometry was skipped" = "повреждённая векторная геометрия пропущена"
+"damaged vector networks import as outlines" = "повреждённые векторные сети импортируются как контуры"
 "development: {path}" = "разработка: {path}"
+"document children other than pages were skipped" = "дочерние элементы документа, не являющиеся страницами, пропущены"
+"duplicate grid track sizing entries use equal tracks" = "для повторяющихся записей размеров треков сетки используются равные треки"
 "e.g. count + 1" = "например, count + 1"
 "e.g. count >= 3 and not done" = "например, count >= 3 and not done"
+"elbowed and curved connectors without a saved path import as straight lines" = "ломаные и изогнутые соединительные линии без сохранённого пути импортируются как прямые"
+"entries without a node type were skipped" = "записи без типа узла пропущены"
 "figcraft:// links from a browser, chat or email open this app and join the session." = "Ссылки figcraft:// из браузера, чата или почты открывают это приложение и подключают к сессии."
+"filled areas of a vector with their own fill use the layer's fill" = "залитые области вектора с собственной заливкой используют заливку слоя"
 "from {server}" = "с {server}"
+"gamepad triggers without exactly one known controller button were skipped" = "триггеры геймпада без ровно одной известной кнопки контроллера пропущены"
+"grid track list exceeds 1000 entries; the tracks use the default equal sizing" = "список треков сетки превышает 1000 записей; треки получают стандартный равный размер"
+"grid track sizing is unsupported or malformed; affected tracks use equal sizing" = "размеры треков сетки не поддерживаются или повреждены; затронутые треки получают равный размер"
+"grid track sizing list exceeds 1000 entries; the tracks use the default equal sizing" = "список размеров треков сетки превышает 1000 записей; треки получают стандартный равный размер"
 "hidden" = "скрыто"
 "iOS" = "iOS"
+"image filters are ambiguous because both filter containers are present; filter conversion was skipped" = "фильтры изображения неоднозначны, так как есть оба контейнера фильтров; преобразование фильтров пропущено"
+"image filters use FigCraft's approximate renderer" = "фильтры изображения отрисовываются приблизительно средствами FigCraft"
+"instance swap properties whose default component isn't in the file were skipped" = "свойства замены экземпляра, компонент по умолчанию которых отсутствует в файле, пропущены"
+"instances inside their own main component were imported as frames" = "экземпляры внутри собственного основного компонента импортированы как фреймы"
+"instances of components that aren't in the file show no layers" = "экземпляры компонентов, которых нет в файле, не показывают слоёв"
+"instances of components that aren't in the file were imported as frames" = "экземпляры компонентов, которых нет в файле, импортированы как фреймы"
+"instances that would nest a component inside itself were imported as frames" = "экземпляры, которые вложили бы компонент в самого себя, импортированы как фреймы"
+"instances without a main component were imported as empty frames" = "экземпляры без основного компонента импортированы как пустые фреймы"
+"invalid internal .fig text path data was ignored" = "недопустимые внутренние данные текста на пути из .fig проигнорированы"
+"invalid or oversized vector networks import as outlines" = "недопустимые или слишком большие векторные сети импортируются как контуры"
+"invalid or oversized vector path data was skipped" = "недопустимые или слишком большие данные векторных путей пропущены"
 "just now" = "только что"
+"key triggers without a supported key were skipped" = "триггеры клавиш без поддерживаемой клавиши пропущены"
+"key up triggers import as key presses" = "триггеры отпускания клавиши импортируются как нажатия клавиши"
+"layers without a position were placed at their parent's origin" = "слои без положения размещены в начале координат родителя"
+"layers without a type were skipped" = "слои без типа пропущены"
+"legacy image filter container is unsupported; filter conversion was skipped" = "устаревший контейнер фильтров изображения не поддерживается; преобразование фильтров пропущено"
 "locked" = "заблокировано"
+"malformed image filters container was skipped" = "повреждённый контейнер фильтров изображения пропущен"
+"malformed image paintFilter container was skipped" = "повреждённый контейнер paintFilter изображения пропущен"
+"malformed slot content assignment was skipped" = "повреждённое назначение содержимого слота пропущено"
 "no bleed" = "без вылета"
 "nobody else here yet" = "здесь пока больше никого нет"
+"non-default slot settings are not represented and were skipped" = "нестандартные настройки слотов не передаются и пропущены"
 "now" = "сейчас"
+"only in a text style or variable" = "только в текстовом стиле или переменной"
 "or" = "или"
+"point stroke joins were preserved; dashed or variable-width strokes render with the layer join" = "соединения обводки в точках сохранены; пунктирные обводки и обводки переменной ширины рисуются с соединением слоя"
+"preferred slot component keys cannot be resolved to file nodes and were skipped" = "ключи предпочтительных компонентов слотов не удалось сопоставить со слоями файла, они пропущены"
+"prototype actions of unknown types were skipped" = "действия прототипа неизвестных типов пропущены"
+"prototype actions without a destination in the file were skipped" = "действия прототипа без цели в файле пропущены"
+"prototype expressions on variables that aren't in the variables JSON were skipped" = "выражения прототипа с переменными, которых нет в JSON переменных, пропущены"
+"prototype expressions with unsupported functions were skipped" = "выражения прототипа с неподдерживаемыми функциями пропущены"
+"prototype interactions without supported actions were skipped" = "взаимодействия прототипа без поддерживаемых действий пропущены"
+"prototype navigations of unknown types were skipped" = "действия навигации прототипа неизвестных типов пропущены"
+"prototype transitions of unknown types play instantly" = "переходы прототипа неизвестных типов выполняются мгновенно"
+"prototype triggers of unknown types were skipped" = "триггеры прототипа неизвестных типов пропущены"
 "put a widget on the canvas" = "размещать виджет на холсте"
 "read and edit the document" = "читать и редактировать документ"
 "read the document" = "читать документ"
 "reads the document" = "читает документ"
+"set-variable actions on variables that aren't in the variables JSON were skipped" = "действия «Задать переменную» для переменных, которых нет в JSON переменных, пропущены"
+"set-variable actions with values that can't be evaluated were skipped" = "действия «Задать переменную» со значениями, которые нельзя вычислить, пропущены"
+"set-variable actions with values that don't fit the variable were skipped" = "действия «Задать переменную» со значениями, не подходящими переменной, пропущены"
+"set-variable actions without a value were skipped" = "действия «Задать переменную» без значения пропущены"
+"set-variable-mode actions on collections or modes that aren't in the variables JSON were skipped" = "действия смены режима переменных для коллекций или режимов, которых нет в JSON переменных, пропущены"
+"slot content assignment target is missing or is not slot content" = "цель назначения содержимого слота отсутствует или не является содержимым слота"
+"slot content assignment uses the empty GUID sentinel and was skipped" = "назначение содержимого слота использует пустой GUID-маркер и пропущено"
+"slot layers without a matching slot property were imported as frames" = "слои слотов без подходящего свойства слота импортированы как фреймы"
+"some vector points refer to point settings missing from the file; they use the layer's joins and plain corners" = "некоторые векторные точки ссылаются на настройки точек, которых нет в файле; они используют соединения слоя и обычные углы"
+"some vector segments refer to style settings missing from the file; they use the layer's stroke" = "некоторые векторные сегменты ссылаются на настройки стиля, которых нет в файле; они используют обводку слоя"
+"stale or invalid grid track sizing entries were ignored" = "устаревшие или недопустимые записи размеров треков сетки проигнорированы"
+"stars and polygons without point counts or geometry use the default point count" = "звёзды и многоугольники без числа вершин или геометрии используют число вершин по умолчанию"
+"style settings of some vector segments aren't supported; those segments use the layer's stroke" = "настройки стиля некоторых векторных сегментов не поддерживаются; эти сегменты используют обводку слоя"
+"text path underline or strikethrough decoration is not rendered" = "подчёркивание и зачёркивание текста на пути не отображаются"
+"text style overrides refer to missing table entries" = "переопределения текстовых стилей ссылаются на отсутствующие записи таблицы"
+"the file has no pages" = "в файле нет страниц"
 "the plugin" = "плагин"
+"the variables JSON has no `variableCollections` (expected the local variables response) and was ignored" = "в JSON переменных нет `variableCollections` (ожидался ответ с локальными переменными), он проигнорирован"
 "this session only" = "только эта сессия"
+"unknown component property types were skipped" = "неизвестные типы свойств компонентов пропущены"
+"variable aliases to variables that aren't in the variables JSON (or of another type) were skipped" = "псевдонимы переменных, которых нет в JSON переменных (или другого типа), пропущены"
+"variable bindings to properties the layer doesn't have were skipped" = "привязки переменных к свойствам, которых нет у слоя, пропущены"
+"variable bindings to variables that aren't in the variables JSON (library variables) were skipped" = "привязки к переменным, которых нет в JSON переменных (переменные библиотеки), пропущены"
+"variable bindings were skipped: the file JSON has no variable definitions (pass the local variables JSON as `variables`, or embed its `meta` next to the file JSON)" = "привязки переменных пропущены: в JSON файла нет определений переменных (передайте JSON локальных переменных как `variables` или вложите его `meta` рядом с JSON файла)"
+"variable bindings whose variable type doesn't fit the property were skipped" = "привязки переменных, тип которых не подходит свойству, пропущены"
+"variable collections without modes were skipped" = "коллекции переменных без режимов пропущены"
+"variable mode lookups in prototype expressions that aren't a variable and one of its modes were skipped" = "обращения к режимам переменных в выражениях прототипа, не состоящие из переменной и одного из её режимов, пропущены"
+"variable modes of collections that aren't in the file were skipped" = "режимы переменных коллекций, которых нет в файле, пропущены"
+"variable modes of collections that aren't in the variables JSON were skipped" = "режимы переменных коллекций, которых нет в JSON переменных, пропущены"
+"variable values that don't match their type (or composed colours) were skipped" = "значения переменных, не соответствующие своему типу (или составные цвета), пропущены"
+"variables of unknown types were skipped" = "переменные неизвестных типов пропущены"
+"variables whose collection isn't in the variables JSON were skipped" = "переменные, коллекции которых нет в JSON переменных, пропущены"
+"variables without readable values were skipped" = "переменные без читаемых значений пропущены"
+"vector points with unknown stroke joins use the layer join" = "векторные точки с неизвестными соединениями обводки используют соединение слоя"
+"vectors without geometry are empty" = "векторы без геометрии пусты"
+"vectors without geometry are empty (export the file JSON with geometry=paths)" = "векторы без геометрии пусты (экспортируйте JSON файла с geometry=paths)"
+"very long text was cut to 1,048,576 characters" = "очень длинный текст обрезан до 1 048 576 символов"
+"very long vector paths were skipped" = "очень длинные векторные пути пропущены"
+"video actions are not supported and were skipped" = "действия с видео не поддерживаются и пропущены"
+"video triggers are not supported and were skipped" = "триггеры видео не поддерживаются и пропущены"
 "yesterday" = "вчера"
 "{instances} in {files}" = "{instances} в {files}"
 "{language}: draft translation, waiting for a native speaker's review." = "{language}: черновой перевод, ожидает проверки носителем языка."
@@ -1515,6 +1708,7 @@ name = "Русский"
 "{name} is forgotten on this computer; the file stays on {server}" = "{name} забыт на этом компьютере; файл остаётся на {server}"
 "{name} is on the server." = "{name} находится на сервере."
 "{name} is spotlighting" = "{name} показывает экран всем"
+"{name} is too large to open in the browser (over 512 MB)." = "Файл {name} слишком велик для открытия в браузере (больше 512 МБ)."
 "{name}\nClick to apply to the selection" = "{name}\nНажмите, чтобы применить к выделению"
 "{name}\nDrag onto the canvas, or click to place in the middle of the view.\nHold Alt (Option) while dropping onto an instance to swap it." = "{name}\nПеретащите на холст или нажмите, чтобы разместить в центре вида.\nУдерживайте Alt (Option) при переносе на экземпляр, чтобы заменить его."
 "{name} (from {library})" = "{name} (из {library})"
@@ -1550,6 +1744,7 @@ name = "Русский"
 "{n} matches" = { one = "{n} совпадение", few = "{n} совпадения", many = "{n} совпадений", other = "{n} совпадения" }
 "{n} minutes ago" = { one = "{n} минуту назад", few = "{n} минуты назад", many = "{n} минут назад", other = "{n} минуты назад" }
 "{n} months ago" = { one = "{n} месяц назад", few = "{n} месяца назад", many = "{n} месяцев назад", other = "{n} месяца назад" }
+"{n} more notes omitted from this report" = { one = "Ещё {n} замечание не включено в этот отчёт", few = "Ещё {n} замечания не включены в этот отчёт", many = "Ещё {n} замечаний не включено в этот отчёт", other = "Ещё {n} замечания не включено в этот отчёт" }
 "{n} of {total}" = "{n} из {total}"
 "{n} people joined" = { one = "Подключился {n} участник", few = "Подключились {n} участника", many = "Подключились {n} участников", other = "Подключилось {n} участника" }
 "{n} preferred components" = { one = "{n} предпочтительный компонент", few = "{n} предпочтительных компонента", many = "{n} предпочтительных компонентов", other = "{n} предпочтительного компонента" }
@@ -1558,6 +1753,7 @@ name = "Русский"
 "{n} replies" = { one = "{n} ответ", few = "{n} ответа", many = "{n} ответов", other = "{n} ответа" }
 "{n} rows" = { one = "{n} строка", few = "{n} строки", many = "{n} строк", other = "{n} строки" }
 "{n} styles" = { one = "{n} стиль", few = "{n} стиля", many = "{n} стилей", other = "{n} стиля" }
+"{n} text layers" = { one = "{n} текстовый слой", few = "{n} текстовых слоя", many = "{n} текстовых слоёв", other = "{n} текстовых слоя" }
 "{n} variables" = { one = "{n} переменная", few = "{n} переменные", many = "{n} переменных", other = "{n} переменной" }
 "{n} weeks ago" = { one = "{n} неделю назад", few = "{n} недели назад", many = "{n} недель назад", other = "{n} недели назад" }
 "{n} years ago" = { one = "{n} год назад", few = "{n} года назад", many = "{n} лет назад", other = "{n} года назад" }
@@ -1566,6 +1762,7 @@ name = "Русский"
 "{n}m" = "{n} мин"
 "{n}w" = "{n} нед"
 "{page}, nothing selected" = "{page}, ничего не выделено"
+"{percent}%" = "{percent}%"
 "{profile} (current)" = "{profile} (текущий)"
 "{property} is its value; {property ? \"a\" : \"b\"} picks a string. Other {…} stays as written." = "{property} — значение свойства; {property ? \"a\" : \"b\"} выбирает строку. Другие {…} остаются как есть."
 "{server} can't say what became of your files (it is older than this app)." = "{server} не может сообщить, что стало с вашими файлами (версия сервера старее приложения)."
@@ -1608,8 +1805,19 @@ name = "Русский"
 "arrange.front" = "На передний план"
 "arrange.packH" = "Уплотнить по горизонтали"
 "arrange.packV" = "Уплотнить по вертикали"
+"arrange.reorder" = "Изменить порядок выделения"
 "arrange.roundToPixels" = "Округлить до пикселей"
+"arrange.spacing" = "Интервал"
 "arrange.tidy" = "Упорядочить"
+"board.connector" = "Соединитель"
+"board.ink" = "Штрих маркера"
+"board.label" = "Подпись соединителя"
+"board.nextSticky" = "Следующий стикер"
+"board.setColor" = "Цвет на доске"
+"board.setStyle" = "Стиль на доске"
+"board.shape" = "Фигура с текстом"
+"board.stamp" = "Штамп"
+"board.sticky" = "Стикер"
 "bool.exclude" = "Исключить выделение"
 "bool.flatten" = "Свести булеву группу"
 "bool.intersect" = "Пересечь выделение"
@@ -1641,6 +1849,7 @@ name = "Русский"
 "collab.publish" = "Опубликовать на сервере"
 "collab.recoverFile" = "Восстановить онлайн-файл"
 "collab.registerLinks" = "Открывать ссылки приглашения в FigCraft"
+"collab.removePerson" = "Убрать из сессии"
 "collab.report" = "Пожаловаться на файл оператору сервера"
 "collab.serverInfo" = "Информация о сервере"
 "collab.share" = "Поделиться по коду подключения"
@@ -1709,6 +1918,7 @@ name = "Русский"
 "edit.duplicate" = "Дублировать"
 "edit.findReplace" = "Найти и заменить"
 "edit.paste" = "Вставить"
+"edit.pasteDesignLayers" = "Вставить слои дизайна"
 "edit.pasteOver" = "Вставить поверх выделения"
 "edit.pasteProperties" = "Вставить свойства"
 "edit.pasteReplace" = "Вставить с заменой"
@@ -1732,7 +1942,9 @@ name = "Русский"
 "file.exportLayers" = "Экспортировать слои"
 "file.exportSvg" = "Экспортировать выделение в SVG"
 "file.import" = "Импорт"
+"file.moveTab" = "Переместить вкладку"
 "file.new" = "Новый файл дизайна"
+"file.newBoard" = "Новая доска"
 "file.newFromTemplate" = "Создать из шаблона"
 "file.open" = "Открыть"
 "file.openRecent" = "Открыть недавние"
@@ -1817,6 +2029,7 @@ name = "Русский"
 "object.batchRename" = "Массовое переименование"
 "object.convertToFrame" = "Преобразовать во Frame"
 "object.convertToGroup" = "Преобразовать в группу"
+"object.convertToSection" = "Преобразовать в секцию"
 "object.flipH" = "Отразить по горизонтали"
 "object.flipV" = "Отразить по вертикали"
 "object.frameSelection" = "Поместить выделение во Frame"
@@ -1863,6 +2076,7 @@ name = "Русский"
 "plugin.ui" = "Панель плагина"
 "plugins.manage" = "Управление плагинами…"
 "plugins.runLast" = "Запустить последний плагин"
+"pref.autoSave" = "Автоматически сохранять файлы"
 "pref.highlightHover" = "Подсвечивать слои при наведении"
 "pref.keepTool" = "Оставлять инструмент выбранным после использования"
 "pref.language" = "Язык интерфейса"
@@ -1872,6 +2086,8 @@ name = "Русский"
 "pref.reduceMotion" = "Уменьшить движение"
 "pref.renameDuplicates" = "Переименовывать дубликаты слоёв"
 "pref.showDimensions" = "Показать размеры объектов"
+"pref.startOnHome" = "Начинать с главной"
+"pref.uiScale" = "Размер интерфейса"
 "pref.userName" = "Ваше имя в комментариях"
 "proto.action.add" = "Добавить действие прототипа"
 "proto.action.move" = "Изменить порядок действия прототипа"
@@ -1915,6 +2131,10 @@ name = "Русский"
 "select.sameStroke" = "Выделить с одинаковой обводкой"
 "select.sameText" = "Выделить с одинаковыми свойствами текста"
 "select.set" = "Выделить"
+"selection.applyColorStyle" = "Применить цветовой стиль к выделению"
+"selection.colors" = "Цвета выделения"
+"selection.selectColor" = "Выделить слои с этим цветом"
+"selection.setPaint" = "Изменить цвет выделения"
 "shape.arrow" = "Стрелка"
 "shape.ellipse" = "Эллипс"
 "shape.line" = "Линия"
@@ -1973,14 +2193,18 @@ name = "Русский"
 "text.listIndent" = "Увеличить отступ списка"
 "text.listOutdent" = "Уменьшить отступ списка"
 "text.listStyle" = "Стиль списка"
+"text.loadFont" = "Загрузить файл шрифта"
 "text.maxLines" = "Максимум строк"
+"text.missingFonts" = "Отсутствующие шрифты"
 "text.numberList" = "Нумерованный список"
 "text.onPath" = "Текст на пути"
 "text.paragraphIndent" = "Абзацный отступ"
 "text.paragraphSpacing" = "Интервал между абзацами"
 "text.pathOptions" = "Параметры текста на пути"
 "text.preview" = "Предпросмотр изменения текста"
+"text.refit" = "Подогнать текст под шрифты"
 "text.removeFromPath" = "Снять текст с пути"
+"text.rescanFonts" = "Повторно найти установленные шрифты"
 "text.set" = "Задать текст"
 "text.setFeatures" = "Функции OpenType"
 "text.setVariations" = "Оси вариативного шрифта"
@@ -1995,10 +2219,14 @@ name = "Русский"
 "text.weightUp" = "Увеличить толщину шрифта"
 "tool.arrow" = "Стрелка"
 "tool.comment" = "Комментарий"
+"tool.connector" = "Соединитель"
 "tool.ellipse" = "Эллипс"
+"tool.eraser" = "Ластик"
 "tool.frame" = "Frame"
 "tool.hand" = "Рука"
+"tool.highlighter" = "Текстовыделитель"
 "tool.line" = "Линия"
+"tool.marker" = "Маркер"
 "tool.move" = "Перемещение"
 "tool.pen" = "Перо"
 "tool.pencil" = "Карандаш"
@@ -2010,9 +2238,12 @@ name = "Русский"
 "tool.scaleAnchor" = "Центр масштабирования"
 "tool.section" = "Секция"
 "tool.set" = "Выбрать инструмент"
+"tool.shape" = "Фигуры"
 "tool.shapeBuilder" = "Конструктор фигур"
 "tool.slice" = "Срез"
+"tool.stamp" = "Штамп"
 "tool.star" = "Звезда"
+"tool.sticky" = "Стикер"
 "tool.text" = "Текст"
 "transform.move" = "Перемещение"
 "transform.moveTo" = "Переместить в"
@@ -2074,11 +2305,13 @@ name = "Русский"
 "vector.edit.tool" = "Инструмент редактирования вектора"
 "vector.edit.transform" = "Трансформировать точки"
 "vector.edit.widthPoint" = "Точка ширины"
+"vector.fillRule" = "Задать правило заливки"
 "vector.flatten" = "Свести"
 "vector.join" = "Соединить выделение"
 "vector.offset" = "Сместить путь"
 "vector.outlineStroke" = "Преобразовать обводку в контур"
 "vector.reverse" = "Обратить направление пути"
+"vector.reverseLoop" = "Развернуть контур"
 "vector.simplify" = "Упростить вектор"
 "vector.smoothJoin" = "Плавно соединить выделение"
 "version.autosave" = "Автосохранить версию"
diff --git a/crates/ui-egui/locales/sv.toml b/crates/ui-egui/locales/sv.toml
index f7b2999d6..be25d38e2 100644
--- a/crates/ui-egui/locales/sv.toml
+++ b/crates/ui-egui/locales/sv.toml
@@ -16,6 +16,8 @@ name = "Svenska"
 "1…9, 0" = "1…9, 0"
 "@{login}: {prs} PRs, {commits} commits, +{added} / −{deleted} lines (Δ {delta}), +{bin_added} / −{bin_deleted} binary assets, {first} – {last}" = "@{login}: {prs} PR:er, {commits} commits, +{added} / −{deleted} rader (Δ {delta}), +{bin_added} / −{bin_deleted} binära tillgångar, {first} – {last}"
 "A collection of this file with these modes and variables: override their values per mode and add variables of its own" = "En samling i den här filen med dessa lägen och variabler: åsidosätt deras värden per läge och lägg till egna variabler"
+"A .figcraft file with this name already exists. Choose its full name to confirm replacement." = "Det finns redan en .figcraft-fil med det här namnet. Välj dess fullständiga namn för att bekräfta att den ersätts."
+"A layer on its own aligns to its frame: select more layers, or one in a frame" = "Ett ensamt lager justeras mot sin ram: markera fler lager, eller ett lager i en ram"
 "A responsive product page: hero, features, figures, a quote and a footer" = "En responsiv produktsida: toppsektion, funktioner, figurer, ett citat och en sidfot"
 "A spring plays until it settles: its mass, stiffness and damping set how long" = "En fjäder spelas tills den stannar: dess massa, styvhet och dämpning avgör hur länge"
 "A title, an agenda, a big figure, a chart and a closing slide" = "En titel, en agenda, en stor figur, ett diagram och en avslutande bild"
@@ -65,6 +67,7 @@ name = "Svenska"
 "Add variant with a new value" = "Lägg till variant med ett nytt värde"
 "Added" = "Tillagd"
 "Added the library \"{name}\"" = "Biblioteket ”{name}” har lagts till"
+"Adding to {name}" = "Lägger till i {name}"
 "Adjust" = "Justera"
 "Adjustment presets" = "Justeringsförinställningar"
 "Advanced" = "Avancerat"
@@ -121,6 +124,7 @@ name = "Svenska"
 "Archived" = "Arkiverad"
 "Arrange" = "Ordna"
 "Arrow" = "Pil"
+"Arrow at the end" = "Pil i slutet"
 "As typed" = "Som inskrivet"
 "Asking the server…" = "Frågar servern…"
 "Assets" = "Tillgångar"
@@ -194,7 +198,9 @@ name = "Svenska"
 "C or ⇧C" = "C eller ⇧C"
 "CMYK colour" = "CMYK-färg"
 "Can view" = "Kan visa"
+"Check" = "Bock"
 "Checking the server…" = "Kontrollerar servern…"
+"Chevron" = "Vinkel"
 "Clear from this list" = "Ta bort från listan"
 "Code or invite link" = "Kod eller inbjudningslänk"
 "Color profile: {name}" = "Färgprofil: {name}"
@@ -241,7 +247,6 @@ name = "Svenska"
 "Close tab" = "Stäng flik"
 "Close version history" = "Stäng versionshistorik"
 "Close when clicking outside" = "Stäng vid klick utanför"
-"Close without saving" = "Stäng utan att spara"
 "Code" = "Kod"
 "Code syntax" = "Kodsyntax"
 "Collapse" = "Komprimera"
@@ -268,6 +273,7 @@ name = "Svenska"
 "Commits" = "Commits"
 "Company" = "Företag"
 "Compare changes" = "Jämför ändringar"
+"Compatibility notes" = "Kompatibilitetsanteckningar"
 "Completed" = "Slutförd"
 "Component" = "Komponent"
 "Component name" = "Komponentnamn"
@@ -282,6 +288,7 @@ name = "Svenska"
 "Connected" = "Kopplad"
 "Connected to code: {from}" = "Kopplad till kod: {from}"
 "Connection lost, reconnecting (attempt {attempt})…" = "Anslutningen bröts, återansluter (försök {attempt})…"
+"Connector" = "Koppling"
 "Constrain proportions" = "Behåll proportioner"
 "Constraints" = "Begränsningar"
 "Content" = "Innehåll"
@@ -309,7 +316,10 @@ name = "Svenska"
 "Copy {value}" = "Kopiera {value}"
 "Corner radius" = "Hörnradie"
 "Corner smoothing" = "Hörnutjämning"
+"Couldn't download the variables" = "Det gick inte att hämta variablerna"
 "Couldn't reach {server}: showing what this computer remembers." = "Det gick inte att nå {server}: visar det som den här datorn minns."
+"Couldn't read {name}." = "Det gick inte att läsa {name}."
+"Couldn't save automatically: {error}" = "Det gick inte att spara automatiskt: {error}"
 "Count" = "Antal"
 "Create" = "Skapa"
 "Create a variable collection first" = "Skapa en variabelsamling först"
@@ -333,6 +343,7 @@ name = "Svenska"
 "Current version" = "Aktuell version"
 "Cursor chat" = "Markörchatt"
 "Custom" = "Anpassad"
+"Custom size" = "Anpassad storlek"
 "Cut" = "Klipp ut"
 "Dark" = "Mörk"
 "Darken" = "Mörkare"
@@ -366,6 +377,7 @@ name = "Svenska"
 "Description" = "Beskrivning"
 "Description (optional)" = "Beskrivning (valfritt)"
 "Design" = "Design"
+"Design panel" = "Designpanel"
 "Design system starter" = "Startmall för designsystem"
 "Desktop" = "Skrivbord"
 "Destination" = "Mål"
@@ -393,6 +405,7 @@ name = "Svenska"
 "Distribute horizontal spacing" = "Fördela horisontellt avstånd"
 "Distribute vertical spacing" = "Fördela vertikalt avstånd"
 "Divider" = "Avdelare"
+"Don't Save" = "Spara inte"
 "Don't truncate" = "Korta inte av"
 "Done" = "Klart"
 "Done editing" = "Klar med redigeringen"
@@ -404,6 +417,9 @@ name = "Svenska"
 "Draw" = "Rita"
 "Draw a frame" = "Rita en ram"
 "Drawing tools" = "Ritverktyg"
+"Drop a .figcraft, .fig, .json, .svg or image file." = "Släpp en .figcraft-, .fig-, .json- eller .svg-fil eller en bildfil."
+"Drop to import" = "Släpp för att importera"
+"Drop to open" = "Släpp för att öppna"
 "Drop shadow" = "Släppskugga"
 "Dual-licensed MIT OR Apache-2.0. Made by the ArtCraft team and community." = "Dubbellicensierad under MIT OR Apache-2.0. Skapad av ArtCraft-teamet och gemenskapen."
 "Duo" = "Duo"
@@ -425,6 +441,7 @@ name = "Svenska"
 "Effect settings" = "Effektinställningar"
 "Effect styles" = "Effektstilar"
 "Effects" = "Effekter"
+"Elbow" = "Vinklad"
 "Ellipse" = "Ellips"
 "Ellipses" = "Ellipser"
 "Else" = "Annars"
@@ -474,6 +491,8 @@ name = "Svenska"
 "False" = "Falskt"
 "Feb" = "feb"
 "Fetching from the server…" = "Hämtar från servern…"
+"FigCraft couldn't open its window: {error}" = "FigCraft kunde inte öppna sitt fönster: {error}"
+"FigCraft doesn't support every feature of these files yet. The notes list what was left out or changed in the imported copy; the original file is unchanged." = "FigCraft stöder ännu inte alla funktioner i de här filerna. Anteckningarna visar vad som utelämnades eller ändrades i den importerade kopian; originalfilen är oförändrad."
 "File" = "Fil"
 "File name" = "Filnamn"
 "File not found" = "Filen hittades inte"
@@ -559,6 +578,7 @@ name = "Svenska"
 "Hanging list" = "Hängande lista"
 "Hanging punctuation" = "Hängande skiljetecken"
 "Hard light" = "Hårt ljus"
+"Heart" = "Hjärta"
 "Height" = "Höjd"
 "Help" = "Hjälp"
 "Help and resources" = "Hjälp och resurser"
@@ -571,6 +591,7 @@ name = "Svenska"
 "Hide these tips (Getting started in the Help menu shows them again)" = "Dölj de här tipsen (Kom igång i Hjälp-menyn visar dem igen)"
 "Hide when publishing" = "Dölj vid publicering"
 "Highlight layers on hover" = "Framhäv lager vid hovring"
+"Highlighter" = "Överstrykningspenna"
 "Highlights" = "Högdagrar"
 "Hold Alt" = "Håll ned Alt"
 "Hold Alt+Z" = "Håll ned Alt+Z"
@@ -593,15 +614,19 @@ name = "Svenska"
 "Hug contents" = "Omslut innehåll"
 "Icon components on a 24 px grid with keylines and a size preview" = "Ikonkomponenter på ett 24 px-rutnät med hjälplinjer och en förhandsgranskning av storlekar"
 "Icon set starter" = "Startpaket för ikonuppsättning"
+"If it keeps happening, please report it at {link} with this message." = "Om det fortsätter att hända kan du rapportera det på {link} och bifoga det här meddelandet."
 "If" = "Om"
 "If {condition}" = "Om {condition}"
 "Ignore auto layout (absolute position)" = "Ignorera automatisk layout (absolut position)"
 "Image" = "Bild"
+"Images" = "Bilder"
 "Import" = "Importera"
 "Import path" = "Importsökväg"
 "Import plugin from manifest" = "Importera plugin från manifest"
 "Import plugin from manifest…" = "Importera plugin från manifest…"
+"Import report" = "Importrapport"
 "Import variables" = "Importera variabler"
+"Imported document" = "Importerat dokument"
 "Imported {name}" = "Importerade {name}"
 "Imported {n} new variables, updated {updated}" = { one = "Importerade {n} ny variabel, uppdaterade {updated}", other = "Importerade {n} nya variabler, uppdaterade {updated}" }
 "Import…" = "Importera…"
@@ -629,11 +654,13 @@ name = "Svenska"
 "Instance swap (no other component)" = "Instansbyte (ingen annan komponent)"
 "Instances" = "Instanser"
 "Instant" = "Direkt"
+"Intensity" = "Intensitet"
 "Interaction" = "Interaktion"
 "Interactions" = "Interaktioner"
 "Interface design and prototyping. A free, open-source, clean-room design tool written from scratch in Rust, part of the ArtCraft Crafting Apps." = "Gränssnittsdesign och prototyper. Ett fritt clean-room-designverktyg med öppen källkod, skrivet från grunden i Rust och en del av ArtCraft Crafting Apps."
 "Intersect" = "Skärning"
 "Intersects" = "Skär"
+"Invalid color" = "Ogiltig färg"
 "Invite link" = "Inbjudningslänk"
 "Invite link copied" = "Inbjudningslänken har kopierats"
 "It asks permission to:" = "Den ber om behörighet att:"
@@ -731,6 +758,7 @@ name = "Svenska"
 "Mark as resolved" = "Märk som löst"
 "Mark as unread" = "Märk som oläst"
 "Mark as unresolved" = "Märk som olöst"
+"Marker" = "Märkpenna"
 "Mask" = "Mask"
 "Mass · Stiffness · Damping" = "Massa · Styvhet · Dämpning"
 "Match (empty: the whole name)" = "Matcha (tomt: hela namnet)"
@@ -789,8 +817,10 @@ name = "Svenska"
 "Named instance" = "Namngiven instans"
 "Navigate to" = "Navigera till"
 "Nested instance" = "Kapslad instans"
+"New board" = "Ny whiteboard"
 "New design file" = "Ny designfil"
 "Newest first" = "Nyaste först"
+"Next frame" = "Nästa ram"
 "Next or previous control in the focused region" = "Nästa eller föregående kontroll i den fokuserade regionen"
 "Next ready for dev" = "Nästa redo för utveckling"
 "Next size option" = "Nästa storleksalternativ"
@@ -800,12 +830,15 @@ name = "Svenska"
 "No branches. A branch is a copy of the file to try changes in, then review and merge." = "Inga grenar. En gren är en kopia av filen där du kan prova ändringar och sedan granska och sammanfoga dem."
 "No category" = "Ingen kategori"
 "No changes" = "Inga ändringar"
+"No color styles" = "Inga färgformatmallar"
 "No colour variables fit here." = "Inga färgvariabler passar här."
 "No colour variables yet. Create them in Local variables." = "Inga färgvariabler än. Skapa dem i Lokala variabler."
 "No comments yet" = "Inga kommentarer än"
+"No compatibility warnings reported" = "Inga kompatibilitetsvarningar rapporterades"
 "No components yet. Select layers and press {keys}." = "Inga komponenter än. Markera lager och tryck på {keys}."
 "No conflicts." = "Inga konflikter."
 "No contributor data was built into this copy." = "Inga uppgifter om bidragsgivare finns inbyggda i den här kopian."
+"No device" = "Ingen enhet"
 "No fonts match" = "Inga typsnitt matchar"
 "No join code here (the server is older than join codes, or this address can't be put in one): share the link instead." = "Ingen anslutningskod här (servern är äldre än anslutningskoder, eller så kan den här adressen inte göras om till en): dela länken i stället."
 "No layer changes to show." = "Inga lagerändringar att visa."
@@ -886,6 +919,7 @@ name = "Svenska"
 "Open branch" = "Öppna gren"
 "Open file" = "Öppna fil"
 "Open files" = "Öppna filer"
+"Open presentations" = "Öppna presentationer"
 "Open in focus view" = "Öppna i fokusvy"
 "Open in new window" = "Öppna i nytt fönster"
 "Open invite links in FigCraft" = "Öppna inbjudningslänkar i FigCraft"
@@ -894,7 +928,10 @@ name = "Svenska"
 "Open overlay" = "Öppna överlägg"
 "Open prototype preview" = "Öppna prototypförhandsgranskning"
 "Open variables ({count})" = "Öppna variabler ({count})"
+"Opened as a new document" = "Öppnat som ett nytt dokument"
 "Opened “{name}” in a new tab" = "Öppnade ”{name}” i en ny flik"
+"Opening the file…" = "Öppnar filen…"
+"Opening {n} files as new files" = { one = "Öppnar som en ny fil", other = "Öppnar {n} filer som nya filer" }
 "Open|comments" = "Öppna"
 "Options" = "Alternativ"
 "Orange" = "Orange"
@@ -917,7 +954,11 @@ name = "Svenska"
 "PDF print settings" = "PDF-utskriftsinställningar"
 "Padding" = "Utfyllnad"
 "Page" = "Sida"
+"Page deleted" = "Sidan har raderats"
 "Pages" = "Sidor"
+"Pages added to the document" = "Sidor tillagda i dokumentet"
+"Pink" = "Rosa"
+"Placed on the current page" = "Placerat på den aktuella sidan"
 "Pages: {pages}" = "Sidor: {pages}"
 "Paint bucket" = "Färghink"
 "Pan the canvas" = "Panorera arbetsytan"
@@ -932,6 +973,7 @@ name = "Svenska"
 "Paste a team library link (a view link)" = "Klistra in en länk till ett teambibliotek (en visningslänk)"
 "Paste here" = "Klistra in här"
 "Paste to replace" = "Klistra in och ersätt"
+"Pasted design layers; {n} kinds of content were left out" = { one = "Designlager inklistrade; {n} typ av innehåll utelämnades", other = "Designlager inklistrade; {n} typer av innehåll utelämnades" }
 "Pattern" = "Mönster"
 "Pattern alignment" = "Mönsterjustering"
 "Pattern scale" = "Mönsterskala"
@@ -958,6 +1000,7 @@ name = "Svenska"
 "Plugins" = "Plugin-program"
 "Plus darker" = "Plus mörkare"
 "Plus lighter" = "Plus ljusare"
+"Plus one" = "Plus ett"
 "Point" = "Punkt"
 "Points" = "Punkter"
 "Polygon" = "Polygon"
@@ -985,6 +1028,7 @@ name = "Svenska"
 "Preview" = "Förhandsgranskning"
 "Preview this flow" = "Förhandsgranska det här flödet"
 "Preview this frame" = "Förhandsgranska den här ramen"
+"Previous frame" = "Föregående ram"
 "Previous ready for dev" = "Föregående redo för utveckling"
 "Progressive" = "Progressiv"
 "Properties" = "Egenskaper"
@@ -1005,6 +1049,7 @@ name = "Svenska"
 "Push" = "Skjut"
 "Push changes to main component" = "Skicka ändringar till huvudkomponenten"
 "Put text on path" = "Placera text på bana"
+"Question" = "Fråga"
 "R" = "R"
 "Radial" = "Radiell"
 "Radius" = "Radie"
@@ -1045,6 +1090,7 @@ name = "Svenska"
 "Remove the else and its actions" = "Ta bort else-grenen och dess åtgärder"
 "Remove this condition and its actions" = "Ta bort det här villkoret och dess åtgärder"
 "Remove this file from the server? It can't be shared or opened from there again. Your copy stays open here." = "Vill du ta bort den här filen från servern? Den kan inte längre delas eller öppnas därifrån. Din kopia förblir öppen här."
+"Remove {name} from session" = "Ta bort {name} från sessionen"
 "Remove {name} from {server}?" = "Vill du ta bort {name} från {server}?"
 "Removed" = "Borttaget"
 "Removed from the server" = "Borttagen från servern"
@@ -1078,6 +1124,7 @@ name = "Svenska"
 "Resize by the nudge amount" = "Ändra storlek med knuffavståndet"
 "Resize frames to the device's screen (or the window without a device): their constraints and auto layout respond" = "Ändra storlek på ramar efter enhetens skärm (eller fönstret utan enhet): deras begränsningar och automatiska layout anpassas"
 "Resize to fit" = "Anpassa storlek"
+"Resizing" = "Storleksändring"
 "Resolve" = "Lös"
 "Resolve change" = "Lös ändring"
 "Resolved" = "Löst"
@@ -1103,6 +1150,7 @@ name = "Svenska"
 "Rotation jitter" = "Rotationsdarr"
 "Round" = "Rund"
 "Rounded" = "Rundad"
+"Rounded rectangle" = "Rundad rektangel"
 "Row" = "Rad"
 "Row gap" = "Radmellanrum"
 "Row sizes" = "Radstorlekar"
@@ -1112,6 +1160,7 @@ name = "Svenska"
 "Rulers" = "Linjaler"
 "Run" = "Kör"
 "Run {label}" = "Kör {label}"
+"Save files automatically" = "Spara filer automatiskt"
 "Search templates" = "Sök mallar"
 "See all templates" = "Se alla mallar"
 "Select layers and they space themselves as their content changes" = "Markera lager så fördelar de avståndet själva när innehållet ändras"
@@ -1151,12 +1200,14 @@ name = "Svenska"
 "Select all with same" = "Markera alla med samma"
 "Select layer" = "Markera lager"
 "Select layers to apply the style to" = "Markera de lager som formatmallen ska användas på"
+"Select layers with this color" = "Markera lager med den här färgen"
 "Select overlapping shapes" = "Markera överlappande former"
 "Select points to edit their position, radius and mirroring" = "Markera punkter för att redigera deras position, radie och spegling"
 "Select slot" = "Markera plats"
 "Selection" = "Markering"
 "Selection box, {w} by {h} at {x}, {y}: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "Markeringsruta, {w} gånger {h} vid {x}, {y}: piltangenterna flyttar den, Shift+pilar eller {cmd}+pilar ändrar storleken, Enter markerar, Escape avbryter"
 "Selection box: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "Markeringsruta: piltangenterna flyttar den, Shift+pilar eller {cmd}+pilar ändrar storleken, Enter markerar, Escape avbryter"
+"Selection colors" = "Markeringsfärger"
 "Send backward" = "Flytta bakåt"
 "Send report" = "Skicka rapport"
 "Send to back" = "Flytta längst bak"
@@ -1173,6 +1224,7 @@ name = "Svenska"
 "Shape" = "Form"
 "Shape builder" = "Formbyggare"
 "Shape tools" = "Formverktyg"
+"Shapes" = "Former"
 "Share" = "Dela"
 "Share this file" = "Dela den här filen"
 "Share with a code" = "Dela med en kod"
@@ -1239,10 +1291,13 @@ name = "Svenska"
 "Space+drag" = "Blanksteg+dra"
 "Spacing" = "Avstånd"
 "Spam, stolen work, abuse…" = "Skräppost, stulet material, kränkningar…"
+"Speech bubble" = "Pratbubbla"
 "Splay" = "Utbredning"
 "Spotlight me" = "Rikta strålkastaren mot mig"
 "Spread" = "Spridning"
 "Square" = "Kvadrat"
+"Stamp" = "Stämpel"
+"Stamps" = "Stämplar"
 "Standard" = "Standard"
 "Standard ligatures" = "Standardligaturer"
 "Star" = "Stjärna"
@@ -1252,18 +1307,23 @@ name = "Svenska"
 "Start from a blank canvas" = "Börja med en tom arbetsyta"
 "Start from a template" = "Börja med en mall"
 "Start on path" = "Början på banan"
+"Start on the Home screen" = "Börja på Start"
 "Start point" = "Startpunkt"
 "Start sharing" = "Börja dela"
 "Start sharing with the Share button, then pass on the code it gives" = "Börja dela med knappen Dela och skicka sedan vidare koden du får"
 "Starting to share…" = "Börjar dela…"
 "Status" = "Status"
 "Sticky" = "Fast"
+"Sticky note" = "Lapp"
+"Sticky note colors" = "Lappfärger"
+"Sticky notes, shapes and connectors" = "Lappar, former och kopplingar"
 "Stop" = "Stoppa"
 "Stop following {name}" = "Sluta följa {name}"
 "Stop session" = "Avsluta session"
 "Stop sharing" = "Sluta dela"
 "Stop spotlighting" = "Sluta använda strålkastaren"
 "Stop {n}  {hex}" = "Stopp {n}  {hex}"
+"Straight" = "Rak"
 "Stretch" = "Sträck"
 "Strikethrough" = "Genomstruken"
 "String" = "Sträng"
@@ -1308,11 +1368,15 @@ name = "Svenska"
 "Text" = "Text"
 "Text align" = "Textjustering"
 "Text content" = "Textinnehåll"
+"Text size" = "Textstorlek"
 "Text style" = "Textstil"
 "Text styles" = "Textstilar"
 "Texts" = "Texter"
 "Texture" = "Textur"
 "The canvas previews colors in sRGB; exported PNG, JPG and WebP files are tagged Display P3." = "Arbetsytan förhandsgranskar färger i sRGB; exporterade PNG-, JPG- och WebP-filer märks med Display P3."
+"The destination document is unavailable. Nothing was imported." = "Måldokumentet är inte tillgängligt. Ingenting importerades."
+"The destination document was closed. Nothing was imported." = "Måldokumentet stängdes. Ingenting importerades."
+"The destination page was removed. Nothing was imported." = "Målsidan togs bort. Ingenting importerades."
 "The file is deleted from the server: nobody can open or join it from there again, and this can't be undone. Copies that are open stay with whoever has them." = "Filen raderas från servern: ingen kan längre öppna eller ansluta till den därifrån, och detta kan inte ångras. Kopior som är öppna finns kvar hos dem som har dem."
 "The file now holds another library" = "Filen innehåller nu ett annat bibliotek"
 "The file now holds another library (\"{name}\")" = "Filen innehåller nu ett annat bibliotek (\"{name}\")"
@@ -1338,6 +1402,7 @@ name = "Svenska"
 "This server is open to the public: no key needed." = "Servern är öppen för alla: ingen nyckel behövs."
 "This server needs its key: add ?key=… to the address (`figcraft-server key` prints it on the server's machine)." = "Servern kräver sin nyckel: lägg till ?key=… i adressen (`figcraft-server key` skriver ut den på serverns dator)."
 "This server takes files only with its key: see Advanced." = "Servern tar bara emot filer med sin nyckel: se Avancerat."
+"Thumbs up" = "Tummen upp"
 "Tidy up" = "Snygga till"
 "Tile" = "Sida vid sida"
 "Tile type" = "Upprepningstyp"
@@ -1354,6 +1419,7 @@ name = "Svenska"
 "Top left radius" = "Radie uppe till vänster"
 "Top right radius" = "Radie uppe till höger"
 "Transform" = "Transformera"
+"Triangle" = "Triangel"
 "Triangle arrow" = "Triangelpil"
 "Trigger" = "Utlösare"
 "True" = "Sant"
@@ -1378,7 +1444,7 @@ name = "Svenska"
 "Unread" = "Olästa"
 "Unresolve" = "Markera som olöst"
 "Unsaved changes" = "Osparade ändringar"
-"Unsaved changes in {names}. Close the window and lose them?" = "Osparade ändringar i {names}. Vill du stänga fönstret och förlora dem?"
+"Unsaved changes in {names}. Save them before closing?" = "Osparade ändringar i {names}. Vill du spara dem innan du stänger?"
 "Unsaved changes: save first ({save}), or close the tab with {alt}-click to discard" = "Osparade ändringar: spara först ({save}), eller stäng fliken med {alt}-klick för att slänga dem"
 "Unsaved changes: save first, or close again with {key} to discard" = "Osparade ändringar: spara först, eller stäng igen med {key} för att slänga dem"
 "Up" = "Upp"
@@ -1388,6 +1454,8 @@ name = "Svenska"
 "Update from selection" = "Uppdatera från markering"
 "Updated {components} and {styles}" = "{components} och {styles} har uppdaterats"
 "Updated {name}" = "{name} har uppdaterats"
+"Updating the graphics driver often helps. To use OpenGL only, start FigCraft from a Command Prompt with:" = "Det hjälper ofta att uppdatera grafikdrivrutinen. Om du bara vill använda OpenGL startar du FigCraft från en kommandotolk med:"
+"Updating the graphics driver often helps. WGPU_BACKEND (vulkan, gl, metal) names another graphics API to try." = "Det hjälper ofta att uppdatera grafikdrivrutinen. WGPU_BACKEND (vulkan, gl, metal) anger ett annat grafik-API att prova."
 "Uploads this file to a FigCraft server and keeps this tab in sync with it. You get a link to edit and a link to view." = "Laddar upp filen till en FigCraft-server och håller fliken synkroniserad med den. Du får en länk för redigering och en för visning."
 "Uppercase" = "Versaler"
 "Use a fixed value" = "Använd ett fast värde"
@@ -1395,6 +1463,7 @@ name = "Svenska"
 "Use as mask" = "Använd som mask"
 "Use auto layout" = "Använd automatisk layout"
 "Use number keys for opacity" = "Använd siffertangenterna för opacitet"
+"Use the .figcraft or .fig extension." = "Använd filändelsen .figcraft eller .fig."
 "Use the layer's fill" = "Använd lagrets fyllning"
 "Used in {files} · {instances}" = "Används i {files} · {instances}"
 "Username" = "Användarnamn"
@@ -1430,6 +1499,7 @@ name = "Svenska"
 "Visibility" = "Synlighet"
 "Visible" = "Synlig"
 "Vivid" = "Livfull"
+"WGPU_BACKEND is set and names the graphics API to use; unsetting it lets FigCraft choose." = "WGPU_BACKEND är satt och anger vilket grafik-API som ska användas; tar du bort den väljer FigCraft själv."
 "Warm" = "Varm"
 "Watch" = "Bevaka"
 "Wavy" = "Vågig"
@@ -1487,26 +1557,119 @@ name = "Svenska"
 "call any command its access allows" = "anropa alla kommandon som dess åtkomst tillåter"
 "call only: {commands}" = "anropa endast: {commands}"
 "can edit the document" = "kan redigera dokumentet"
+"conditional prototype actions nested too deeply were skipped" = "villkorliga prototypåtgärder som var nästlade för djupt hoppades över"
+"conditional prototype actions with conditions that can't be evaluated were skipped" = "villkorliga prototypåtgärder med villkor som inte kan utvärderas hoppades över"
+"connector label background was skipped: style data is missing" = "bakgrunden till etiketten på en kopplingslinje hoppades över: stildata saknas"
+"connector label was skipped: background bounds are invalid" = "etiketten på en kopplingslinje hoppades över: bakgrundens gränser är ogiltiga"
+"connector label was skipped: background transform is invalid" = "etiketten på en kopplingslinje hoppades över: bakgrundens transformering är ogiltig"
+"connector label was skipped: composed text transform is invalid" = "etiketten på en kopplingslinje hoppades över: textens sammansatta transformering är ogiltig"
+"connector label was skipped: derived background bounds are missing" = "etiketten på en kopplingslinje hoppades över: bakgrundens härledda gränser saknas"
+"connector label was skipped: derived text bounds are missing" = "etiketten på en kopplingslinje hoppades över: textens härledda gränser saknas"
+"connector label was skipped: text bounds are invalid" = "etiketten på en kopplingslinje hoppades över: textens gränser är ogiltiga"
+"connector label was skipped: text style data is missing" = "etiketten på en kopplingslinje hoppades över: textens stildata saknas"
+"connector label was skipped: text transform is invalid" = "etiketten på en kopplingslinje hoppades över: textens transformering är ogiltig"
+"connector labels were skipped" = "etiketter på kopplingslinjer hoppades över"
+"connector layers import as static frame/vector snapshots with labels when present; live endpoint bindings are not retained" = "kopplingslinjelager importeras som statiska ögonblicksbilder av ramar eller vektorer, med etiketter om de finns; dynamiska bindningar av ändpunkterna behålls inte"
+"connector snapshot vector data is missing; connector was left empty" = "vektordata för kopplingslinjens ögonblicksbild saknas; kopplingslinjen lämnades tom"
+"connectors whose ends can't be placed are empty" = "kopplingslinjer vars ändar inte kan placeras är tomma"
 "crop marks" = "skärmärken"
+"damaged vector geometry was skipped" = "skadad vektorgeometri hoppades över"
+"damaged vector networks import as outlines" = "skadade vektornätverk importeras som former"
 "development: {path}" = "utveckling: {path}"
+"document children other than pages were skipped" = "underordnade objekt i dokumentet som inte är sidor hoppades över"
+"duplicate grid track sizing entries use equal tracks" = "dubbla storleksposter för rutnätsspår använder lika stora spår"
 "e.g. count + 1" = "t.ex. count + 1"
 "e.g. count >= 3 and not done" = "t.ex. count >= 3 and not done"
+"elbowed and curved connectors without a saved path import as straight lines" = "vinklade och böjda kopplingslinjer utan sparad bana importeras som raka linjer"
+"entries without a node type were skipped" = "poster utan nodtyp hoppades över"
 "figcraft:// links from a browser, chat or email open this app and join the session." = "figcraft://-länkar från en webbläsare, chatt eller e-post öppnar den här appen och ansluter till sessionen."
+"filled areas of a vector with their own fill use the layer's fill" = "fyllda områden i en vektor med egen fyllning använder lagrets fyllning"
 "from {server}" = "från {server}"
+"gamepad triggers without exactly one known controller button were skipped" = "spelkontrollsutlösare utan exakt en känd kontrollknapp hoppades över"
+"grid track list exceeds 1000 entries; the tracks use the default equal sizing" = "listan över rutnätsspår har fler än 1000 poster; spåren får standardstorleken med lika stora spår"
+"grid track sizing is unsupported or malformed; affected tracks use equal sizing" = "storleken på rutnätsspår stöds inte eller är felaktig; berörda spår blir lika stora"
+"grid track sizing list exceeds 1000 entries; the tracks use the default equal sizing" = "listan över storlekar på rutnätsspår har fler än 1000 poster; spåren får standardstorleken med lika stora spår"
 "hidden" = "dold"
 "iOS" = "iOS"
+"image filters are ambiguous because both filter containers are present; filter conversion was skipped" = "bildfiltren är tvetydiga eftersom båda filterbehållarna finns; filterkonverteringen hoppades över"
+"image filters use FigCraft's approximate renderer" = "bildfilter använder FigCrafts ungefärliga rendering"
+"instance swap properties whose default component isn't in the file were skipped" = "egenskaper för instansbyte vars standardkomponent inte finns i filen hoppades över"
+"instances inside their own main component were imported as frames" = "instanser inuti sin egen huvudkomponent importerades som ramar"
+"instances of components that aren't in the file show no layers" = "instanser av komponenter som inte finns i filen visar inga lager"
+"instances of components that aren't in the file were imported as frames" = "instanser av komponenter som inte finns i filen importerades som ramar"
+"instances that would nest a component inside itself were imported as frames" = "instanser som skulle nästla en komponent i sig själv importerades som ramar"
+"instances without a main component were imported as empty frames" = "instanser utan huvudkomponent importerades som tomma ramar"
+"invalid internal .fig text path data was ignored" = "ogiltiga interna .fig-data för text på bana ignorerades"
+"invalid or oversized vector networks import as outlines" = "ogiltiga eller för stora vektornätverk importeras som former"
+"invalid or oversized vector path data was skipped" = "ogiltiga eller för stora vektorbanedata hoppades över"
 "just now" = "nyss"
+"key triggers without a supported key were skipped" = "tangentutlösare utan en tangent som stöds hoppades över"
+"key up triggers import as key presses" = "utlösare för släppt tangent importeras som tangenttryckningar"
+"layers without a position were placed at their parent's origin" = "lager utan position placerades i det överordnade objektets origo"
+"layers without a type were skipped" = "lager utan typ hoppades över"
+"legacy image filter container is unsupported; filter conversion was skipped" = "den äldre bildfilterbehållaren stöds inte; filterkonverteringen hoppades över"
 "locked" = "låst"
+"malformed image filters container was skipped" = "en felaktig bildfilterbehållare hoppades över"
+"malformed image paintFilter container was skipped" = "en felaktig paintFilter-behållare för bild hoppades över"
+"malformed slot content assignment was skipped" = "en felaktig tilldelning av fackinnehåll hoppades över"
 "no bleed" = "inget utfall"
 "nobody else here yet" = "ingen annan här än"
+"non-default slot settings are not represented and were skipped" = "fackinställningar som avviker från standard återges inte och hoppades över"
 "now" = "nu"
 "or" = "eller"
+"point stroke joins were preserved; dashed or variable-width strokes render with the layer join" = "punkternas hörntyper behölls; streckade konturer och konturer med variabel bredd ritas med lagrets hörntyp"
+"preferred slot component keys cannot be resolved to file nodes and were skipped" = "nycklar för föredragna komponenter i fack kan inte kopplas till lager i filen och hoppades över"
+"prototype actions of unknown types were skipped" = "prototypåtgärder av okända typer hoppades över"
+"prototype actions without a destination in the file were skipped" = "prototypåtgärder utan mål i filen hoppades över"
+"prototype expressions on variables that aren't in the variables JSON were skipped" = "prototyputtryck med variabler som inte finns i variabel-JSON:en hoppades över"
+"prototype expressions with unsupported functions were skipped" = "prototyputtryck med funktioner som inte stöds hoppades över"
+"prototype interactions without supported actions were skipped" = "prototypinteraktioner utan åtgärder som stöds hoppades över"
+"prototype navigations of unknown types were skipped" = "prototypnavigeringar av okända typer hoppades över"
+"prototype transitions of unknown types play instantly" = "prototypövergångar av okända typer spelas upp direkt"
+"prototype triggers of unknown types were skipped" = "prototyputlösare av okända typer hoppades över"
 "put a widget on the canvas" = "placera en widget på arbetsytan"
 "read and edit the document" = "läsa och redigera dokumentet"
 "read the document" = "läsa dokumentet"
 "reads the document" = "läser dokumentet"
+"set-variable actions on variables that aren't in the variables JSON were skipped" = "åtgärder för att ange variabel på variabler som inte finns i variabel-JSON:en hoppades över"
+"set-variable actions with values that can't be evaluated were skipped" = "åtgärder för att ange variabel med värden som inte kan utvärderas hoppades över"
+"set-variable actions with values that don't fit the variable were skipped" = "åtgärder för att ange variabel med värden som inte passar variabeln hoppades över"
+"set-variable actions without a value were skipped" = "åtgärder för att ange variabel utan värde hoppades över"
+"set-variable-mode actions on collections or modes that aren't in the variables JSON were skipped" = "åtgärder för att ange variabelläge på samlingar eller lägen som inte finns i variabel-JSON:en hoppades över"
+"slot content assignment target is missing or is not slot content" = "målet för tilldelningen av fackinnehåll saknas eller är inte fackinnehåll"
+"slot content assignment uses the empty GUID sentinel and was skipped" = "tilldelningen av fackinnehåll använder det tomma GUID:t som markörvärde och hoppades över"
+"some vector points refer to point settings missing from the file; they use the layer's joins and plain corners" = "vissa vektorpunkter hänvisar till punktinställningar som saknas i filen; de använder lagrets hörntyper och vanliga hörn"
+"some vector segments refer to style settings missing from the file; they use the layer's stroke" = "vissa vektorsegment hänvisar till stilinställningar som saknas i filen; de använder lagrets kontur"
+"stale or invalid grid track sizing entries were ignored" = "inaktuella eller ogiltiga storleksposter för rutnätsspår ignorerades"
+"stars and polygons without point counts or geometry use the default point count" = "stjärnor och polygoner utan antal punkter eller geometri använder standardantalet punkter"
+"style settings of some vector segments aren't supported; those segments use the layer's stroke" = "stilinställningar för vissa vektorsegment stöds inte; de segmenten använder lagrets kontur"
+"text path underline or strikethrough decoration is not rendered" = "understrykning eller genomstrykning av text på bana ritas inte"
+"text style overrides refer to missing table entries" = "åsidosättningar av textstilar hänvisar till tabellposter som saknas"
+"the file has no pages" = "filen har inga sidor"
 "the plugin" = "pluginet"
+"the variables JSON has no `variableCollections` (expected the local variables response) and was ignored" = "variabel-JSON:en har inga `variableCollections` (svaret med lokala variabler väntades) och ignorerades"
 "this session only" = "endast den här sessionen"
+"unknown component property types were skipped" = "okända typer av komponentegenskaper hoppades över"
+"variable aliases to variables that aren't in the variables JSON (or of another type) were skipped" = "alias till variabler som inte finns i variabel-JSON:en (eller är av en annan typ) hoppades över"
+"variable bindings to properties the layer doesn't have were skipped" = "variabelbindningar till egenskaper som lagret inte har hoppades över"
+"variable bindings to variables that aren't in the variables JSON (library variables) were skipped" = "bindningar till variabler som inte finns i variabel-JSON:en (biblioteksvariabler) hoppades över"
+"variable bindings were skipped: the file JSON has no variable definitions (pass the local variables JSON as `variables`, or embed its `meta` next to the file JSON)" = "variabelbindningar hoppades över: fil-JSON:en har inga variabeldefinitioner (skicka den lokala variabel-JSON:en som `variables`, eller bädda in dess `meta` bredvid fil-JSON:en)"
+"variable bindings whose variable type doesn't fit the property were skipped" = "variabelbindningar vars variabeltyp inte passar egenskapen hoppades över"
+"variable collections without modes were skipped" = "variabelsamlingar utan lägen hoppades över"
+"variable mode lookups in prototype expressions that aren't a variable and one of its modes were skipped" = "uppslag av variabellägen i prototyputtryck som inte är en variabel och ett av dess lägen hoppades över"
+"variable modes of collections that aren't in the file were skipped" = "variabellägen för samlingar som inte finns i filen hoppades över"
+"variable modes of collections that aren't in the variables JSON were skipped" = "variabellägen för samlingar som inte finns i variabel-JSON:en hoppades över"
+"variable values that don't match their type (or composed colours) were skipped" = "variabelvärden som inte matchar sin typ (eller sammansatta färger) hoppades över"
+"variables of unknown types were skipped" = "variabler av okända typer hoppades över"
+"variables whose collection isn't in the variables JSON were skipped" = "variabler vars samling inte finns i variabel-JSON:en hoppades över"
+"variables without readable values were skipped" = "variabler utan läsbara värden hoppades över"
+"vector points with unknown stroke joins use the layer join" = "vektorpunkter med okända hörntyper använder lagrets hörntyp"
+"vectors without geometry are empty" = "vektorer utan geometri är tomma"
+"vectors without geometry are empty (export the file JSON with geometry=paths)" = "vektorer utan geometri är tomma (exportera fil-JSON:en med geometry=paths)"
+"very long text was cut to 1,048,576 characters" = "mycket lång text kortades till 1 048 576 tecken"
+"very long vector paths were skipped" = "mycket långa vektorbanor hoppades över"
+"video actions are not supported and were skipped" = "videoåtgärder stöds inte och hoppades över"
+"video triggers are not supported and were skipped" = "videoutlösare stöds inte och hoppades över"
 "yesterday" = "i går"
 "{instances} in {files}" = "{instances} i {files}"
 "{language}: draft translation, waiting for a native speaker's review." = "{language}: utkast till översättning, väntar på granskning av en modersmålstalare."
@@ -1516,6 +1679,7 @@ name = "Svenska"
 "{name} is forgotten on this computer; the file stays on {server}" = "{name} har glömts på den här datorn; filen finns kvar på {server}"
 "{name} is on the server." = "{name} finns på servern."
 "{name} is spotlighting" = "{name} har spotlight"
+"{name} is too large to open in the browser (over 512 MB)." = "{name} är för stor för att öppnas i webbläsaren (över 512 MB)."
 "{name}\nClick to apply to the selection" = "{name}\nKlicka för att använda på markeringen"
 "{name}\nDrag onto the canvas, or click to place in the middle of the view.\nHold Alt (Option) while dropping onto an instance to swap it." = "{name}\nDra till arbetsytan, eller klicka för att placera i mitten av vyn.\nHåll ned Alt (Option) när du släpper på en instans för att byta ut den."
 "{name} (from {library})" = "{name} (från {library})"
@@ -1551,6 +1715,7 @@ name = "Svenska"
 "{n} matches" = { one = "{n} träff", other = "{n} träffar" }
 "{n} minutes ago" = { one = "för {n} minut sedan", other = "för {n} minuter sedan" }
 "{n} months ago" = { one = "för {n} månad sedan", other = "för {n} månader sedan" }
+"{n} more notes omitted from this report" = { one = "{n} anteckning till utelämnades i den här rapporten", other = "{n} anteckningar till utelämnades i den här rapporten" }
 "{n} of {total}" = "{n} av {total}"
 "{n} people joined" = { one = "{n} person anslöt", other = "{n} personer anslöt" }
 "{n} preferred components" = { one = "{n} föredragen komponent", other = "{n} föredragna komponenter" }
@@ -1588,9 +1753,141 @@ name = "Svenska"
 
 [commands]
 
+"align.bottom" = "Justera nederkant"
+"align.hcenter" = "Justera horisontella mittpunkter"
+"align.left" = "Justera vänster"
+"align.right" = "Justera höger"
+"align.top" = "Justera överkant"
+"align.vcenter" = "Justera vertikala mittpunkter"
+"annotation.add" = "Lägg till anteckning"
+"annotation.addCategory" = "Lägg till anteckningskategori"
+"annotation.categories" = "Anteckningskategorier"
+"annotation.edit" = "Redigera anteckning"
+"annotation.editCategory" = "Redigera anteckningskategori"
+"annotation.list" = "Lista anteckningar"
+"annotation.remove" = "Ta bort anteckning"
+"annotation.removeCategory" = "Radera anteckningskategori"
+"app.actions" = "Åtgärder"
+"app.preferences" = "Inställningar"
+"arrange.back" = "Flytta längst bak"
+"arrange.backward" = "Flytta bakåt"
+"arrange.forward" = "Flytta framåt"
+"arrange.front" = "Flytta längst fram"
+"arrange.packH" = "Packa horisontellt"
+"arrange.packV" = "Packa vertikalt"
+"arrange.roundToPixels" = "Avrunda till pixlar"
+"arrange.spacing" = "Avstånd"
+"arrange.tidy" = "Snygga till"
+"board.connector" = "Koppling"
+"board.ink" = "Märkpennsdrag"
+"board.label" = "Kopplingsetikett"
+"board.nextSticky" = "Nästa lapp"
+"board.setColor" = "Whiteboardfärg"
+"board.setStyle" = "Whiteboardstil"
+"board.shape" = "Form med text"
+"board.stamp" = "Stämpel"
+"board.sticky" = "Lapp"
+"bool.exclude" = "Uteslut markering"
+"bool.flatten" = "Platta till boolesk form"
+"bool.intersect" = "Skärning av markering"
+"bool.subtract" = "Subtrahera markering"
+"bool.union" = "Förena markering"
+"branch.archive" = "Arkivera gren"
+"branch.create" = "Skapa gren"
+"branch.list" = "Lista grenar"
+"branch.merge" = "Sammanfoga gren"
+"branch.open" = "Öppna gren"
+"branch.review" = "Granska gren"
+"branch.updateFromMain" = "Uppdatera från main"
+"codeConnect.export" = "Exportera kodkopplingar"
+"codeConnect.import" = "Importera kodkopplingar"
+"codeConnect.remove" = "Koppla från koden"
+"codeConnect.set" = "Koppla till kod"
+"collab.cursor" = "Visa markör vid"
+"collab.cursorChat" = "Markörchatt"
+"collab.diff" = "Visa synkändringar"
+"collab.files" = "Dina onlinefiler"
+"collab.follow" = "Följ"
+"collab.forgetFile" = "Glöm onlinefil"
+"collab.host" = "Starta livesession"
+"collab.join" = "Gå med i livesession"
+"collab.leave" = "Lämna livesession"
+"collab.manageFile" = "Hantera publicerad fil"
+"collab.openFile" = "Öppna onlinefil"
+"collab.peers" = "Personer i den här filen"
+"collab.publish" = "Publicera på server"
+"collab.recoverFile" = "Återställ onlinefil"
+"collab.registerLinks" = "Öppna inbjudningslänkar i FigCraft"
+"collab.removePerson" = "Ta bort från session"
+"collab.report" = "Rapportera filen till serveroperatören"
+"collab.serverInfo" = "Serverinfo"
+"collab.share" = "Dela med en anslutningskod"
+"collab.spotlight" = "Rikta strålkastaren mot mig"
+"collab.stop" = "Stoppa livesession"
+"command.batch" = "Kör flera kommandon"
+"comment.add" = "Lägg till kommentar"
+"comment.delete" = "Ta bort kommentar"
+"comment.edit" = "Redigera kommentar"
+"comment.link" = "Kopiera länk till kommentar"
+"comment.list" = "Lista kommentarer"
+"comment.markRead" = "Markera kommentar som läst"
+"comment.move" = "Flytta kommentar"
+"comment.next" = "Nästa kommentar"
+"comment.open" = "Öppna kommentar"
+"comment.people" = "Personer i kommentarer"
+"comment.react" = "Reagera på kommentar"
+"comment.reply" = "Svara på kommentar"
+"comment.resolve" = "Lös kommentar"
+"comment.zoom" = "Zooma till kommentarer"
+"component.addProperty" = "Lägg till komponentegenskap"
+"component.addVariant" = "Lägg till variant"
+"component.bindProperty" = "Koppla lager till egenskap"
+"component.combineVariants" = "Kombinera som varianter"
+"component.create" = "Skapa komponent"
+"component.createMultiple" = "Skapa flera komponenter"
+"component.deleteProperty" = "Radera komponentegenskap"
+"component.detach" = "Koppla bort instans"
+"component.editProperty" = "Redigera komponentegenskap"
+"component.exposeInstance" = "Exponera kapslad instans"
+"component.goToMain" = "Gå till huvudkomponent"
+"component.hideWhenPublishing" = "Dölj vid publicering"
+"component.list" = "Lista komponenter"
+"component.makeSlot" = "Gör till plats"
+"component.playground" = "Komponenttestyta"
+"component.properties" = "Komponentegenskaper"
+"component.pushChanges" = "Skicka ändringar till huvudkomponenten"
+"component.removeSlot" = "Ta bort plats"
+"component.resetInstance" = "Återställ alla ändringar"
+"component.resetOverride" = "Återställ åsidosättning"
+"component.restoreMain" = "Återställ huvudkomponent"
+"dev.compare" = "Jämför ändringar"
+"dev.focus" = "Fokusvy"
+"dev.resolveChange" = "Lös ändring"
+"dev.unfocus" = "Lämna fokusvy"
+"devResource.add" = "Lägg till utvecklarresurs"
+"devResource.edit" = "Redigera utvecklarresurs"
+"devResource.list" = "Lista utvecklarresurser"
+"devResource.remove" = "Ta bort utvecklarresurs"
+"distribute.horizontal" = "Fördela horisontellt avstånd"
+"distribute.vertical" = "Fördela vertikalt avstånd"
+"doc.home" = "Start"
+"doc.list" = "Lista dokument"
+"doc.nextTab" = "Nästa flik"
+"doc.previousTab" = "Föregående flik"
+"doc.switch" = "Byt dokument"
+"edit.copy" = "Kopiera"
+"edit.copyAsCss" = "Kopiera som CSS"
+"edit.copyAsPng" = "Kopiera som PNG"
+"edit.copyAsSvg" = "Kopiera som SVG"
+"edit.copyAsText" = "Kopiera som text"
+"edit.copyLink" = "Kopiera länk till markering"
+"edit.copyProperties" = "Kopiera egenskaper"
+"edit.cut" = "Klipp ut"
+"edit.delete" = "Radera"
 "edit.duplicate" = "Duplicera"
 "edit.findReplace" = "Sök och ersätt"
 "edit.paste" = "Klistra in"
+"edit.pasteDesignLayers" = "Klistra in designlager"
 "edit.pasteOver" = "Klistra in över"
 "edit.pasteProperties" = "Klistra in egenskaper"
 "edit.pasteReplace" = "Klistra in och ersätt"
@@ -1614,7 +1911,9 @@ name = "Svenska"
 "file.exportLayers" = "Exportera lager"
 "file.exportSvg" = "Exportera som SVG"
 "file.import" = "Importera"
+"file.moveTab" = "Flytta flik"
 "file.new" = "Nytt"
+"file.newBoard" = "Ny whiteboard"
 "file.newFromTemplate" = "Nytt från mall"
 "file.open" = "Öppna"
 "file.openRecent" = "Öppna senaste"
@@ -1708,6 +2007,369 @@ name = "Svenska"
 "object.moveToPage" = "Flytta till sida"
 "object.opacityKeys" = "Nyckelbildrutor för opacitet"
 "object.rasterize" = "Rastrera"
+"object.releaseMask" = "Frigör mask"
+"object.removeFill" = "Ta bort fyllning"
+"object.removeFrame" = "Ta bort ram"
+"object.removeStroke" = "Ta bort kontur"
+"object.rename" = "Byt namn"
+"object.resizeToFit" = "Anpassa storlek"
+"object.rotate180" = "Rotera 180°"
+"object.rotateLeft" = "Rotera 90° åt vänster"
+"object.rotateRight" = "Rotera 90° åt höger"
+"object.setThumbnail" = "Ange som miniatyr"
+"object.swapFillStroke" = "Byt plats på fyllning och kontur"
+"object.toggleLock" = "Lås/lås upp markering"
+"object.toggleVisible" = "Visa/dölj markering"
+"object.ungroup" = "Dela upp markerade grupper"
+"object.wrapInSection" = "Lägg i nytt avsnitt"
+"page.add" = "Lägg till sida"
+"page.delete" = "Radera sida"
+"page.duplicate" = "Duplicera sida"
+"page.list" = "Lista sidor"
+"page.move" = "Flytta sida"
+"page.rename" = "Byt namn på sida"
+"page.select" = "Gå till sida"
+"page.setBackground" = "Sidbakgrund"
+"paint.documentColors" = "Dokumentfärger"
+"plugin.close" = "Stäng plugin-panelen"
+"plugin.directory.install" = "Installera plugin från katalogen"
+"plugin.directory.list" = "Bläddra i plugin-katalogen"
+"plugin.directory.publish" = "Publicera plugin i katalogen"
+"plugin.directory.unpublish" = "Avpublicera plugin från katalogen"
+"plugin.event" = "Använd kontroll i plugin-panelen"
+"plugin.import" = "Importera plugin från manifest…"
+"plugin.list" = "Lista plugin-program"
+"plugin.remove" = "Ta bort plugin"
+"plugin.run" = "Kör plugin"
+"plugin.ui" = "Plugin-panel"
+"plugins.manage" = "Hantera plugin-program…"
+"plugins.runLast" = "Kör senaste plugin"
+"pref.autoSave" = "Spara filer automatiskt"
+"pref.highlightHover" = "Framhäv lager vid hovring"
+"pref.keepTool" = "Behåll verktyget markerat efter användning"
+"pref.language" = "Gränssnittsspråk"
+"pref.nudge" = "Knuffavstånd"
+"pref.numberKeysOpacity" = "Använd siffertangenterna för opacitet"
+"pref.publishServer" = "Server för delning online"
+"pref.reduceMotion" = "Minska rörelse"
+"pref.renameDuplicates" = "Byt namn på duplicerade lager"
+"pref.showDimensions" = "Visa dimensioner på objekt"
+"pref.startOnHome" = "Börja på Start"
+"pref.userName" = "Ditt namn i kommentarer"
+"proto.action.add" = "Lägg till prototypåtgärd"
+"proto.action.move" = "Ändra ordning på prototypåtgärd"
+"proto.action.remove" = "Ta bort prototypåtgärd"
+"proto.action.set" = "Redigera prototypåtgärd"
+"proto.closePreview" = "Stäng prototypförhandsgranskning"
+"proto.conditional.addBlock" = "Lägg till annars om / annars"
+"proto.conditional.removeBlock" = "Ta bort om / annars om / annars"
+"proto.conditional.setCondition" = "Redigera villkor"
+"proto.evaluate" = "Beräkna prototyputtryck"
+"proto.flow.add" = "Lägg till startpunkt för flöde"
+"proto.flow.remove" = "Ta bort flöde"
+"proto.flow.rename" = "Byt namn på flöde"
+"proto.interaction.add" = "Lägg till interaktion"
+"proto.interaction.clear" = "Ta bort alla interaktioner"
+"proto.interaction.remove" = "Ta bort interaktion"
+"proto.interaction.set" = "Redigera interaktion"
+"proto.present" = "Presentera"
+"proto.presentOptions" = "Presentationsalternativ"
+"proto.preview" = "Öppna prototypförhandsgranskning"
+"proto.settings" = "Prototypinställningar"
+"section.toggleContents" = "Dölj/visa avsnittets innehåll"
+"select.add" = "Lägg till i markering"
+"select.all" = "Markera alla"
+"select.area" = "Markera område"
+"select.byName" = "Markera lager efter namn"
+"select.children" = "Markera underordnade"
+"select.inverse" = "Invertera markering"
+"select.layersAt" = "Lager vid en punkt"
+"select.matching" = "Markera matchande lager"
+"select.next" = "Markera nästa syskon"
+"select.none" = "Markera inga"
+"select.parent" = "Markera överordnad"
+"select.previous" = "Markera föregående syskon"
+"select.remove" = "Ta bort från markering"
+"select.sameEffect" = "Markera samma effekt"
+"select.sameFill" = "Markera samma fyllning"
+"select.sameFont" = "Markera samma teckensnitt"
+"select.sameInstance" = "Markera samma instans"
+"select.sameProperties" = "Markera samma egenskaper"
+"select.sameStroke" = "Markera samma kontur"
+"select.sameText" = "Markera samma textegenskaper"
+"select.set" = "Markera"
+"selection.applyColorStyle" = "Använd färgformatmall på markeringen"
+"selection.colors" = "Markeringsfärger"
+"selection.selectColor" = "Markera lager med den här färgen"
+"selection.setPaint" = "Ändra markeringens färg"
+"shape.arrow" = "Pil"
+"shape.ellipse" = "Ellips"
+"shape.line" = "Linje"
+"shape.polygon" = "Polygon"
+"shape.rectangle" = "Rektangel"
+"shape.star" = "Stjärna"
+"shapeBuilder.merge" = "Sammanfoga områden"
+"shapeBuilder.mode" = "Formbyggarläge"
+"shapeBuilder.regions" = "Formbyggarområden"
+"shapeBuilder.remove" = "Ta bort områden"
+"stroke.add" = "Lägg till kontur"
+"stroke.brush" = "Pensel"
+"stroke.move" = "Flytta kontur"
+"stroke.remove" = "Ta bort kontur"
+"stroke.set" = "Ange kontur"
+"stroke.widthProfile" = "Breddprofil"
+"style.apply" = "Använd stil"
+"style.bind" = "Bind variabel i stil"
+"style.create" = "Skapa stil"
+"style.delete" = "Ta bort stil"
+"style.detach" = "Koppla bort stil"
+"style.duplicate" = "Duplicera stil"
+"style.list" = "Lista stilar"
+"style.move" = "Flytta stilar"
+"style.renameFolder" = "Byt namn på stilmapp"
+"style.update" = "Redigera stil"
+"template.list" = "Lista mallar"
+"text.alignCenter" = "Centrera"
+"text.alignJustify" = "Marginaljustera"
+"text.alignLeft" = "Justera vänster"
+"text.alignRight" = "Justera höger"
+"text.bold" = "Fet"
+"text.bulletList" = "Punktlista"
+"text.case" = "Skiftläge"
+"text.caseLower" = "Gemener"
+"text.caseOriginal" = "Ursprungligt skiftläge"
+"text.caseSmallCaps" = "Kapitäler"
+"text.caseTitle" = "Inledande versaler"
+"text.caseUpper" = "Versaler"
+"text.create" = "Text"
+"text.decoration" = "Dekoration"
+"text.edit.begin" = "Redigera text"
+"text.edit.caret" = "Placera markören"
+"text.edit.end" = "Sluta redigera text"
+"text.edit.insert" = "Skriv text"
+"text.edit.key" = "Texttangent"
+"text.edit.preedit" = "Komponera text (IME)"
+"text.edit.selectLine" = "Markera textrad"
+"text.edit.selectWord" = "Markera ord"
+"text.edit.selection" = "Textmarkering"
+"text.endPreview" = "Avsluta förhandsgranskning av text"
+"text.fonts" = "Lista teckensnitt"
+"text.italic" = "Kursiv"
+"text.lineHeightDown" = "Minska radhöjden"
+"text.lineHeightUp" = "Öka radhöjden"
+"text.link" = "Skapa länk"
+"text.listIndent" = "Öka listindrag"
+"text.listOutdent" = "Minska listindrag"
+"text.listStyle" = "Liststil"
+"text.maxLines" = "Max antal rader"
+"text.numberList" = "Numrerad lista"
+"text.onPath" = "Text på bana"
+"text.paragraphIndent" = "Styckeindrag"
+"text.paragraphSpacing" = "Styckeavstånd"
+"text.pathOptions" = "Alternativ för textbana"
+"text.preview" = "Förhandsgranska textändring"
+"text.removeFromPath" = "Ta bort text från bana"
+"text.set" = "Ange text"
+"text.setFeatures" = "OpenType-funktioner"
+"text.setVariations" = "Axlar för variabla teckensnitt"
+"text.sizeDown" = "Minska teckenstorleken"
+"text.sizeUp" = "Öka teckenstorleken"
+"text.strikethrough" = "Genomstruken"
+"text.style" = "Formatera textomfång"
+"text.trackingDown" = "Minska teckenavståndet"
+"text.trackingUp" = "Öka teckenavståndet"
+"text.underline" = "Understrykning"
+"text.weightDown" = "Minska teckenvikten"
+"text.weightUp" = "Öka teckenvikten"
+"tool.arrow" = "Pil"
+"tool.comment" = "Kommentar"
+"tool.connector" = "Koppling"
+"tool.ellipse" = "Ellips"
+"tool.eraser" = "Suddgummi"
+"tool.frame" = "Ram"
+"tool.hand" = "Hand"
+"tool.highlighter" = "Överstrykningspenna"
+"tool.line" = "Linje"
+"tool.marker" = "Märkpenna"
+"tool.move" = "Flytta"
+"tool.pen" = "Penna"
+"tool.pencil" = "Blyertspenna"
+"tool.pencilBrush" = "Blyertspensel"
+"tool.place" = "Placera med verktyget"
+"tool.polygon" = "Polygon"
+"tool.rectangle" = "Rektangel"
+"tool.scale" = "Skala"
+"tool.scaleAnchor" = "Skalningsankare"
+"tool.section" = "Avsnitt"
+"tool.set" = "Välj verktyg"
+"tool.shape" = "Former"
+"tool.shapeBuilder" = "Formbyggare"
+"tool.slice" = "Skiva"
+"tool.stamp" = "Stämpel"
+"tool.star" = "Stjärna"
+"tool.sticky" = "Lapp"
+"tool.text" = "Text"
+"transform.move" = "Flytta"
+"transform.moveTo" = "Flytta till"
+"transform.nudge" = "Knuffa"
+"transform.nudgeSize" = "Ändra storlek genom att knuffa"
+"transform.resize" = "Ändra storlek"
+"transform.rotate" = "Rotera"
+"transform.rotationOrigin" = "Flytta rotationspunkt"
+"transform.scale" = "Skala"
+"transform.setRotationOrigin" = "Ange rotationspunkt"
+"variable.addMode" = "Lägg till läge"
+"variable.bind" = "Bind variabel"
+"variable.create" = "Skapa variabel"
+"variable.createCollection" = "Skapa variabelsamling"
+"variable.delete" = "Radera variabel"
+"variable.deleteCollection" = "Radera samling"
+"variable.duplicate" = "Duplicera variabel"
+"variable.export" = "Exportera variabler"
+"variable.import" = "Importera variabler"
+"variable.list" = "Lista variabler"
+"variable.moveMode" = "Flytta läge"
+"variable.removeMode" = "Radera läge"
+"variable.renameCollection" = "Byt namn på samling"
+"variable.renameMode" = "Byt namn på läge"
+"variable.resetOverride" = "Återställ åsidosatt variabel"
+"variable.set" = "Ange variabelvärde"
+"variable.setMode" = "Ange variabelläge"
+"variable.update" = "Redigera variabel"
+"vector.create" = "Vektor"
+"vector.deleteHeal" = "Radera och läk markering"
+"vector.edit.addVertex" = "Lägg till punkt"
+"vector.edit.begin" = "Redigera vektor"
+"vector.edit.bend" = "Böj segment"
+"vector.edit.bounds" = "Markerade punkters gränser"
+"vector.edit.connect" = "Koppla ihop punkter"
+"vector.edit.cornerRadius" = "Hörnradie för punkt"
+"vector.edit.cut" = "Dela bana"
+"vector.edit.delete" = "Radera punkter"
+"vector.edit.end" = "Klar med redigeringen"
+"vector.edit.erase" = "Radera"
+"vector.edit.lasso" = "Lassomarkering"
+"vector.edit.mirroring" = "Handtagsspegling"
+"vector.edit.moveHandles" = "Flytta handtag"
+"vector.edit.moveVertices" = "Flytta punkter"
+"vector.edit.nudge" = "Knuffa punkter"
+"vector.edit.paint" = "Färghink"
+"vector.edit.pen" = "Pennpunkt"
+"vector.edit.penEnd" = "Avsluta pennbana"
+"vector.edit.position" = "Punktposition"
+"vector.edit.resize" = "Ändra storlek på punkter"
+"vector.edit.rotate" = "Rotera punkter"
+"vector.edit.select" = "Markera punkter"
+"vector.edit.selectAll" = "Markera alla punkter"
+"vector.edit.setHandle" = "Ange handtag"
+"vector.edit.smooth" = "Gör punkter mjuka eller skarpa"
+"vector.edit.state" = "Tillstånd för vektorredigering"
+"vector.edit.strokeCap" = "Konturände för punkt"
+"vector.edit.strokeJoin" = "Konturhörn för punkt"
+"vector.edit.tool" = "Vektorredigeringsverktyg"
+"vector.edit.transform" = "Transformera punkter"
+"vector.edit.widthPoint" = "Breddpunkt"
+"vector.fillRule" = "Ange fyllnadsregel"
+"vector.flatten" = "Platta till"
+"vector.join" = "Sammanfoga markering"
+"vector.offset" = "Förskjut bana"
+"vector.outlineStroke" = "Konvertera kontur till form"
+"vector.reverse" = "Vänd banans riktning"
+"vector.reverseLoop" = "Vänd slinga"
+"vector.simplify" = "Förenkla vektor"
+"vector.smoothJoin" = "Sammanfoga markering mjukt"
+"version.autosave" = "Autospara version"
+"version.delete" = "Radera version"
+"version.duplicate" = "Duplicera version"
+"version.exitPreview" = "Tillbaka till aktuell version"
+"version.list" = "Lista versioner"
+"version.preview" = "Visa version"
+"version.rename" = "Byt namn på version"
+"version.restore" = "Återställ version"
+"view.assets" = "Panelen Tillgångar"
+"view.comments" = "Kommentarer"
+"view.contextMenu" = "Visa snabbmeny"
+"view.design" = "Panelen Design"
+"view.designPrototype" = "Växla mellan Design och Prototyp"
+"view.devMode" = "Utvecklarläge"
+"view.frameOutlines" = "Konturlinjer för ramar"
+"view.fullscreen" = "Helskärm"
+"view.get" = "Hämta vy"
+"view.layers" = "Panelen Lager"
+"view.layoutGrids" = "Layoutrutnät"
+"view.leftSidebar" = "Visa/dölj vänster sidofält"
+"view.maskOutlines" = "Konturlinjer för masker"
+"view.multiplayerCursors" = "Samarbetsmarkörer"
+"view.nextFrame" = "Zooma till nästa ram"
+"view.nextPage" = "Nästa sida"
+"view.nextRegion" = "Fokusera nästa region"
+"view.outlines" = "Konturlinjer"
+"view.outlinesHiddenLayers" = "Inkludera dolda lager i konturlinjer"
+"view.outlinesObjectBounds" = "Inkludera objektgränser i konturlinjer"
+"view.outlinesSelection" = "Konturlinjer för markering"
+"view.pan" = "Panorera vyn"
+"view.panelWidths" = "Återställ panelbredder"
+"view.pixelGrid" = "Pixelrutnät"
+"view.pixelPreview" = "Pixelförhandsgranskning"
+"view.prevFrame" = "Zooma till föregående ram"
+"view.prevPage" = "Föregående sida"
+"view.previousRegion" = "Fokusera föregående region"
+"view.proofSrgb" = "Skärmkorrektur i sRGB"
+"view.prototype" = "Panelen Prototyp"
+"view.rulers" = "Linjaler"
+"view.set" = "Ange vy"
+"view.slices" = "Skivor"
+"view.snapGeometry" = "Fäst mot geometri"
+"view.snapObjects" = "Fäst mot objekt"
+"view.snapPixel" = "Fäst mot pixelrutnät"
+"view.themeDark" = "Mörkt tema"
+"view.themeLight" = "Ljust tema"
+"view.themeSystem" = "Följ systemets tema"
+"view.toggleUi" = "Visa/dölj gränssnitt"
+"view.zoom100" = "Zooma till 100 %"
+"view.zoom200" = "Zooma till 200 %"
+"view.zoom50" = "Zooma till 50 %"
+"view.zoomAt" = "Zoomverktyg"
+"view.zoomFit" = "Zooma för att anpassa"
+"view.zoomIn" = "Zooma in"
+"view.zoomOut" = "Zooma ut"
+"view.zoomSelection" = "Zooma till markering"
+"widget.click" = "Klicka på widget"
+"widget.insert" = "Infoga widget"
+"widget.list" = "Lista widgetar"
+"window.focus" = "Placera fönstret längst fram"
+"window.new" = "Nytt fönster"
 
 [menu]
 
+"bool.exclude" = "Uteslut"
+"bool.flatten" = "Platta till"
+"bool.intersect" = "Skärning"
+"bool.subtract" = "Subtrahera"
+"bool.union" = "Förena"
+"file.duplicate" = "Duplicera"
+"file.import" = "Importera från fil…"
+"file.rename" = "Byt namn"
+"libraries.open" = "Öppna bibliotek"
+"select.sameEffect" = "Effekt"
+"select.sameFill" = "Fyllning"
+"select.sameFont" = "Teckensnitt"
+"select.sameInstance" = "Instans"
+"select.sameProperties" = "Egenskaper"
+"select.sameStroke" = "Kontur"
+"select.sameText" = "Textegenskaper"
+"text.alignCenter" = "Centrera text"
+"text.alignJustify" = "Marginaljustera text"
+"text.alignLeft" = "Vänsterjustera text"
+"text.alignRight" = "Högerjustera text"
+"view.assets" = "Tillgångar"
+"view.design" = "Design"
+"view.layers" = "Lager"
+"view.outlines" = "Visa konturlinjer"
+"view.outlinesHiddenLayers" = "Inkludera dolda lager"
+"view.outlinesObjectBounds" = "Inkludera objektgränser"
+"view.outlinesSelection" = "Visa konturlinjer för markering"
+"view.prototype" = "Prototyp"
+"view.themeDark" = "Mörk"
+"view.themeLight" = "Ljus"
+"view.themeSystem" = "Följ systemet"
diff --git a/crates/ui-egui/locales/tr.toml b/crates/ui-egui/locales/tr.toml
index a2be6b99c..5d15c9c9d 100644
--- a/crates/ui-egui/locales/tr.toml
+++ b/crates/ui-egui/locales/tr.toml
@@ -18,6 +18,7 @@ name = "Türkçe"
 "1…9, 0" = "1…9, 0"
 "@{login}: {prs} PRs, {commits} commits, +{added} / −{deleted} lines (Δ {delta}), +{bin_added} / −{bin_deleted} binary assets, {first} – {last}" = "@{login}: {prs} PR, {commits} commit, +{added} / −{deleted} satır (Δ {delta}), +{bin_added} / −{bin_deleted} ikili varlık, {first} – {last}"
 "A collection of this file with these modes and variables: override their values per mode and add variables of its own" = "Bu dosyanın bu modları ve değişkenleri içeren bir koleksiyonu: değerlerini mod başına geçersiz kılın ve kendi değişkenlerinizi ekleyin"
+"A .figcraft file with this name already exists. Choose its full name to confirm replacement." = "Bu adda bir .figcraft dosyası zaten var. Değiştirmeyi onaylamak için tam adını seçin."
 "A responsive product page: hero, features, figures, a quote and a footer" = "Duyarlı bir ürün sayfası: giriş bölümü, özellikler, rakamlar, bir alıntı ve bir alt bilgi"
 "A spring plays until it settles: its mass, stiffness and damping set how long" = "Yay, durulana kadar oynar: kütlesi, sertliği ve sönümü ne kadar süreceğini belirler"
 "A title, an agenda, a big figure, a chart and a closing slide" = "Bir başlık, bir gündem, büyük bir rakam, bir grafik ve bir kapanış slaydı"
@@ -123,6 +124,7 @@ name = "Türkçe"
 "Archived" = "Arşivlendi"
 "Arrange" = "Konumlandır"
 "Arrow" = "Ok"
+"Arrow at the end" = "Sonda ok"
 "As typed" = "Yazıldığı gibi"
 "Asking the server…" = "Sunucuya soruluyor…"
 "Assets" = "Varlıklar"
@@ -196,7 +198,9 @@ name = "Türkçe"
 "C or ⇧C" = "C veya ⇧C"
 "CMYK colour" = "CMYK rengi"
 "Can view" = "Görüntüleyebilir"
+"Check" = "Onay"
 "Checking the server…" = "Sunucu denetleniyor…"
+"Chevron" = "Şerit ok"
 "Clear from this list" = "Bu listeden kaldır"
 "Code or invite link" = "Kod veya davet bağlantısı"
 "Color profile: {name}" = "Renk profili: {name}"
@@ -243,7 +247,6 @@ name = "Türkçe"
 "Close tab" = "Sekmeyi kapat"
 "Close version history" = "Sürüm geçmişini kapat"
 "Close when clicking outside" = "Dışarı tıklanınca kapat"
-"Close without saving" = "Kaydetmeden kapat"
 "Code" = "Kod"
 "Code syntax" = "Kod söz dizimi"
 "Collapse" = "Daralt"
@@ -270,6 +273,7 @@ name = "Türkçe"
 "Commits" = "Commit'ler"
 "Company" = "Şirket"
 "Compare changes" = "Değişiklikleri karşılaştır"
+"Compatibility notes" = "Uyumluluk notları"
 "Completed" = "Tamamlandı"
 "Component" = "Bileşen"
 "Component name" = "Bileşen adı"
@@ -284,6 +288,7 @@ name = "Türkçe"
 "Connected" = "Bağlandı"
 "Connected to code: {from}" = "Koda bağlı: {from}"
 "Connection lost, reconnecting (attempt {attempt})…" = "Bağlantı koptu, yeniden bağlanılıyor (deneme {attempt})…"
+"Connector" = "Bağlayıcı"
 "Constrain proportions" = "Oranları koru"
 "Constraints" = "Kısıtlamalar"
 "Content" = "İçerik"
@@ -312,6 +317,7 @@ name = "Türkçe"
 "Corner radius" = "Köşe yarıçapı"
 "Corner smoothing" = "Köşe yumuşatma"
 "Couldn't reach {server}: showing what this computer remembers." = "{server} sunucusuna ulaşılamadı: bu bilgisayarın hatırladıkları gösteriliyor."
+"Couldn't read {name}." = "{name} okunamadı."
 "Count" = "Sayı"
 "Create" = "Oluştur"
 "Create a variable collection first" = "Önce bir değişken koleksiyonu oluşturun"
@@ -335,6 +341,7 @@ name = "Türkçe"
 "Current version" = "Geçerli sürüm"
 "Cursor chat" = "İmleç sohbeti"
 "Custom" = "Özel"
+"Custom size" = "Özel boyut"
 "Cut" = "Kes"
 "Dark" = "Koyu"
 "Darken" = "Koyulaştır"
@@ -368,6 +375,7 @@ name = "Türkçe"
 "Description" = "Açıklama"
 "Description (optional)" = "Açıklama (isteğe bağlı)"
 "Design" = "Tasarım"
+"Design panel" = "Tasarım paneli"
 "Design system starter" = "Tasarım sistemi başlangıç seti"
 "Desktop" = "Masaüstü"
 "Destination" = "Hedef"
@@ -395,6 +403,7 @@ name = "Türkçe"
 "Distribute horizontal spacing" = "Yatay aralığı dağıt"
 "Distribute vertical spacing" = "Dikey aralığı dağıt"
 "Divider" = "Ayırıcı"
+"Don't Save" = "Kaydetme"
 "Don't truncate" = "Kısaltma yapma"
 "Done" = "Bitti"
 "Done editing" = "Düzenlemeyi bitir"
@@ -427,6 +436,7 @@ name = "Türkçe"
 "Effect settings" = "Efekt ayarları"
 "Effect styles" = "Efekt stilleri"
 "Effects" = "Efektler"
+"Elbow" = "Dirsekli"
 "Ellipse" = "Elips"
 "Ellipses" = "Elipsler"
 "Else" = "Değilse"
@@ -476,6 +486,7 @@ name = "Türkçe"
 "False" = "Yanlış"
 "Feb" = "Şub"
 "Fetching from the server…" = "Sunucudan getiriliyor…"
+"FigCraft doesn't support every feature of these files yet. The notes list what was left out or changed in the imported copy; the original file is unchanged." = "FigCraft bu dosyaların tüm özelliklerini henüz desteklemiyor. Notlar, içe aktarılan kopyada nelerin dışarıda bırakıldığını veya değiştirildiğini listeler; özgün dosya değişmez."
 "File" = "Dosya"
 "File name" = "Dosya adı"
 "File not found" = "Dosya bulunamadı"
@@ -561,6 +572,7 @@ name = "Türkçe"
 "Hanging list" = "Asılı liste"
 "Hanging punctuation" = "Asılı noktalama"
 "Hard light" = "Sert ışık"
+"Heart" = "Kalp"
 "Height" = "Yükseklik"
 "Help" = "Yardım"
 "Help and resources" = "Yardım ve kaynaklar"
@@ -573,6 +585,7 @@ name = "Türkçe"
 "Hide these tips (Getting started in the Help menu shows them again)" = "Bu ipuçlarını gizle (Yardım menüsündeki Başlarken onları yeniden gösterir)"
 "Hide when publishing" = "Yayımlarken gizle"
 "Highlight layers on hover" = "Üzerine gelince katmanları vurgula"
+"Highlighter" = "Fosforlu kalem"
 "Highlights" = "Açık tonlar"
 "Hold Alt" = "Alt tuşunu basılı tutun"
 "Hold Alt+Z" = "Alt+Z tuşlarını basılı tutun"
@@ -599,11 +612,14 @@ name = "Türkçe"
 "If {condition}" = "Eğer {condition}"
 "Ignore auto layout (absolute position)" = "Otomatik yerleşimi yok say (mutlak konum)"
 "Image" = "Görüntü"
+"Images" = "Görüntüler"
 "Import" = "İçe aktar"
 "Import path" = "İçe aktarma yolu"
 "Import plugin from manifest" = "Eklentiyi manifestten içe aktar"
 "Import plugin from manifest…" = "Eklentiyi manifestten içe aktar…"
+"Import report" = "İçe aktarma raporu"
 "Import variables" = "Değişkenleri içe aktar"
+"Imported document" = "İçe aktarılan belge"
 "Imported {name}" = "İçe aktarıldı: {name}"
 "Imported {n} new variables, updated {updated}" = { other = "{n} yeni değişken içe aktarıldı, {updated} güncellendi" }
 "Import…" = "İçe aktar…"
@@ -631,11 +647,13 @@ name = "Türkçe"
 "Instance swap (no other component)" = "Örnek değiştirme (başka bileşen yok)"
 "Instances" = "Örnekler"
 "Instant" = "Anında"
+"Intensity" = "Yoğunluk"
 "Interaction" = "Etkileşim"
 "Interactions" = "Etkileşimler"
 "Interface design and prototyping. A free, open-source, clean-room design tool written from scratch in Rust, part of the ArtCraft Crafting Apps." = "Arayüz tasarımı ve prototipleme. Rust ile sıfırdan yazılmış, ücretsiz, açık kaynaklı, temiz oda yöntemiyle geliştirilmiş bir tasarım aracı; ArtCraft Crafting Apps ailesinin bir parçası."
 "Intersect" = "Kesiştir"
 "Intersects" = "Kesişir"
+"Invalid color" = "Geçersiz renk"
 "Invite link" = "Davet bağlantısı"
 "Invite link copied" = "Davet bağlantısı kopyalandı"
 "It asks permission to:" = "Şunlar için izin istiyor:"
@@ -733,6 +751,7 @@ name = "Türkçe"
 "Mark as resolved" = "Çözüldü olarak işaretle"
 "Mark as unread" = "Okunmadı olarak işaretle"
 "Mark as unresolved" = "Çözülmedi olarak işaretle"
+"Marker" = "Keçeli kalem"
 "Mask" = "Maske"
 "Mass · Stiffness · Damping" = "Kütle · Sertlik · Sönüm"
 "Match (empty: the whole name)" = "Eşleşme (boş: adın tamamı)"
@@ -791,8 +810,10 @@ name = "Türkçe"
 "Named instance" = "Adlandırılmış örnek"
 "Navigate to" = "Şuraya git"
 "Nested instance" = "İç içe örnek"
+"New board" = "Yeni pano"
 "New design file" = "Yeni tasarım dosyası"
 "Newest first" = "Önce en yeni"
+"Next frame" = "Sonraki çerçeve"
 "Next or previous control in the focused region" = "Odaklanılan bölgedeki sonraki veya önceki denetim"
 "Next ready for dev" = "Sonraki geliştirmeye hazır"
 "Next size option" = "Sonraki boyut seçeneği"
@@ -802,12 +823,15 @@ name = "Türkçe"
 "No branches. A branch is a copy of the file to try changes in, then review and merge." = "Dal yok. Dal, değişiklikleri denemek, sonra gözden geçirip birleştirmek için dosyanın bir kopyasıdır."
 "No category" = "Kategori yok"
 "No changes" = "Değişiklik yok"
+"No color styles" = "Renk stili yok"
 "No colour variables fit here." = "Buraya uyan renk değişkeni yok."
 "No colour variables yet. Create them in Local variables." = "Henüz renk değişkeni yok. Onları Yerel değişkenler'de oluşturun."
 "No comments yet" = "Henüz yorum yok"
+"No compatibility warnings reported" = "Uyumluluk uyarısı bildirilmedi"
 "No components yet. Select layers and press {keys}." = "Henüz bileşen yok. Katmanları seçip {keys} tuşlarına basın."
 "No conflicts." = "Çakışma yok."
 "No contributor data was built into this copy." = "Bu kopyaya katkıda bulunan verisi eklenmemiş."
+"No device" = "Cihaz yok"
 "No fonts match" = "Eşleşen yazı tipi yok"
 "No join code here (the server is older than join codes, or this address can't be put in one): share the link instead." = "Burada katılma kodu yok (sunucu katılma kodlarından eski veya bu adres bir koda sığmıyor): bunun yerine bağlantıyı paylaşın."
 "No layer changes to show." = "Gösterilecek katman değişikliği yok."
@@ -888,6 +912,7 @@ name = "Türkçe"
 "Open branch" = "Dalı aç"
 "Open file" = "Dosya aç"
 "Open files" = "Dosyaları aç"
+"Open presentations" = "Açık sunumlar"
 "Open in focus view" = "Odak görünümünde aç"
 "Open in new window" = "Yeni pencerede aç"
 "Open invite links in FigCraft" = "Davet bağlantılarını FigCraft'ta aç"
@@ -896,6 +921,7 @@ name = "Türkçe"
 "Open overlay" = "Bindirmeyi aç"
 "Open prototype preview" = "Prototip önizlemesini aç"
 "Open variables ({count})" = "Açık değişkenler ({count})"
+"Opened as a new document" = "Yeni belge olarak açıldı"
 "Opened “{name}” in a new tab" = "“{name}” yeni sekmede açıldı"
 "Open|comments" = "Açık"
 "Options" = "Seçenekler"
@@ -919,7 +945,11 @@ name = "Türkçe"
 "PDF print settings" = "PDF baskı ayarları"
 "Padding" = "İç boşluk"
 "Page" = "Sayfa"
+"Page deleted" = "Sayfa silindi"
 "Pages" = "Sayfalar"
+"Pages added to the document" = "Sayfalar belgeye eklendi"
+"Pink" = "Pembe"
+"Placed on the current page" = "Geçerli sayfaya yerleştirildi"
 "Pages: {pages}" = "Sayfalar: {pages}"
 "Paint bucket" = "Boya kovası"
 "Pan the canvas" = "Tuvali kaydır"
@@ -934,6 +964,7 @@ name = "Türkçe"
 "Paste a team library link (a view link)" = "Bir ekip kitaplığı bağlantısı yapıştırın (görüntüleme bağlantısı)"
 "Paste here" = "Buraya yapıştır"
 "Paste to replace" = "Değiştirmek için yapıştır"
+"Pasted design layers; {n} kinds of content were left out" = { other = "Tasarım katmanları yapıştırıldı; {n} tür içerik dışarıda bırakıldı" }
 "Pattern" = "Desen"
 "Pattern alignment" = "Desen hizalaması"
 "Pattern scale" = "Desen ölçeği"
@@ -960,6 +991,7 @@ name = "Türkçe"
 "Plugins" = "Eklentiler"
 "Plus darker" = "Artı koyu"
 "Plus lighter" = "Artı açık"
+"Plus one" = "Artı bir"
 "Point" = "Nokta"
 "Points" = "Noktalar"
 "Polygon" = "Çokgen"
@@ -987,6 +1019,7 @@ name = "Türkçe"
 "Preview" = "Önizleme"
 "Preview this flow" = "Bu akışı önizle"
 "Preview this frame" = "Bu çerçeveyi önizle"
+"Previous frame" = "Önceki çerçeve"
 "Previous ready for dev" = "Önceki geliştirmeye hazır"
 "Progressive" = "Aşamalı"
 "Properties" = "Özellikler"
@@ -1007,6 +1040,7 @@ name = "Türkçe"
 "Push" = "İt"
 "Push changes to main component" = "Değişiklikleri ana bileşene gönder"
 "Put text on path" = "Metni yola yerleştir"
+"Question" = "Soru"
 "R" = "R"
 "Radial" = "Dairesel"
 "Radius" = "Yarıçap"
@@ -1080,6 +1114,7 @@ name = "Türkçe"
 "Resize by the nudge amount" = "Kaydırma miktarı kadar yeniden boyutlandır"
 "Resize frames to the device's screen (or the window without a device): their constraints and auto layout respond" = "Çerçeveleri cihazın ekranına (veya cihaz yoksa pencereye) göre yeniden boyutlandır: kısıtlamaları ve otomatik yerleşimleri tepki verir"
 "Resize to fit" = "Sığacak şekilde yeniden boyutlandır"
+"Resizing" = "Yeniden boyutlandırma"
 "Resolve" = "Çöz"
 "Resolve change" = "Değişikliği çöz"
 "Resolved" = "Çözüldü"
@@ -1105,6 +1140,7 @@ name = "Türkçe"
 "Rotation jitter" = "Döndürme titreşimi"
 "Round" = "Yuvarlak"
 "Rounded" = "Yuvarlatılmış"
+"Rounded rectangle" = "Yuvarlatılmış dikdörtgen"
 "Row" = "Satır"
 "Row gap" = "Satır aralığı"
 "Row sizes" = "Satır boyutları"
@@ -1153,12 +1189,14 @@ name = "Türkçe"
 "Select all with same" = "Aynı olanların tümünü seç"
 "Select layer" = "Katman seç"
 "Select layers to apply the style to" = "Stilin uygulanacağı katmanları seçin"
+"Select layers with this color" = "Bu renkteki katmanları seç"
 "Select overlapping shapes" = "Çakışan şekilleri seç"
 "Select points to edit their position, radius and mirroring" = "Konumlarını, yarıçaplarını ve yansıtmalarını düzenlemek için noktaları seçin"
 "Select slot" = "Yuvayı seç"
 "Selection" = "Seçim"
 "Selection box, {w} by {h} at {x}, {y}: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "Seçim kutusu, {x}, {y} konumunda {w} × {h}: oklar onu taşır, Shift+oklar veya {cmd}+oklar boyutlandırır, Enter seçer, Escape iptal eder"
 "Selection box: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "Seçim kutusu: oklar onu taşır, Shift+oklar veya {cmd}+oklar boyutlandırır, Enter seçer, Escape iptal eder"
+"Selection colors" = "Seçim renkleri"
 "Send backward" = "Geriye gönder"
 "Send report" = "Raporu gönder"
 "Send to back" = "En arkaya gönder"
@@ -1175,6 +1213,7 @@ name = "Türkçe"
 "Shape" = "Şekil"
 "Shape builder" = "Şekil oluşturucu"
 "Shape tools" = "Şekil araçları"
+"Shapes" = "Şekiller"
 "Share" = "Paylaş"
 "Share this file" = "Bu dosyayı paylaş"
 "Share with a code" = "Kodla paylaş"
@@ -1241,10 +1280,13 @@ name = "Türkçe"
 "Space+drag" = "Boşluk+sürükle"
 "Spacing" = "Aralık"
 "Spam, stolen work, abuse…" = "İstenmeyen içerik, çalıntı iş, kötüye kullanım…"
+"Speech bubble" = "Konuşma balonu"
 "Splay" = "Açılma"
 "Spotlight me" = "Beni öne çıkar"
 "Spread" = "Yayılma"
 "Square" = "Kare"
+"Stamp" = "Damga"
+"Stamps" = "Damgalar"
 "Standard" = "Standart"
 "Standard ligatures" = "Standart bitişik harfler"
 "Star" = "Yıldız"
@@ -1260,12 +1302,16 @@ name = "Türkçe"
 "Starting to share…" = "Paylaşım başlatılıyor…"
 "Status" = "Durum"
 "Sticky" = "Yapışkan"
+"Sticky note" = "Yapışkan not"
+"Sticky note colors" = "Yapışkan not renkleri"
+"Sticky notes, shapes and connectors" = "Yapışkan notlar, şekiller ve bağlayıcılar"
 "Stop" = "Durdur"
 "Stop following {name}" = "{name} takibini bırak"
 "Stop session" = "Oturumu durdur"
 "Stop sharing" = "Paylaşmayı durdur"
 "Stop spotlighting" = "Öne çıkarmayı durdur"
 "Stop {n}  {hex}" = "Durak {n}  {hex}"
+"Straight" = "Düz"
 "Stretch" = "Uzat"
 "Strikethrough" = "Üstü çizili"
 "String" = "Metin"
@@ -1310,6 +1356,7 @@ name = "Türkçe"
 "Text" = "Metin"
 "Text align" = "Metin hizalaması"
 "Text content" = "Metin içeriği"
+"Text size" = "Metin boyutu"
 "Text style" = "Metin stili"
 "Text styles" = "Metin stilleri"
 "Texts" = "Metinler"
@@ -1340,6 +1387,7 @@ name = "Türkçe"
 "This server is open to the public: no key needed." = "Bu sunucu herkese açık: anahtar gerekmez."
 "This server needs its key: add ?key=… to the address (`figcraft-server key` prints it on the server's machine)." = "Bu sunucu anahtarını istiyor: adrese ?key=… ekleyin (`figcraft-server key` anahtarı sunucunun makinesinde yazdırır)."
 "This server takes files only with its key: see Advanced." = "Bu sunucu dosyaları yalnızca anahtarıyla kabul ediyor: Gelişmiş'e bakın."
+"Thumbs up" = "Başparmak yukarı"
 "Tidy up" = "Toparla"
 "Tile" = "Döşe"
 "Tile type" = "Döşeme türü"
@@ -1356,6 +1404,7 @@ name = "Türkçe"
 "Top left radius" = "Sol üst yarıçap"
 "Top right radius" = "Sağ üst yarıçap"
 "Transform" = "Dönüştür"
+"Triangle" = "Üçgen"
 "Triangle arrow" = "Üçgen ok"
 "Trigger" = "Tetikleyici"
 "True" = "Doğru"
@@ -1380,7 +1429,7 @@ name = "Türkçe"
 "Unread" = "Okunmamış"
 "Unresolve" = "Çözülmedi yap"
 "Unsaved changes" = "Kaydedilmemiş değişiklikler"
-"Unsaved changes in {names}. Close the window and lose them?" = "{names} içinde kaydedilmemiş değişiklikler var. Pencere kapatılıp bunlar kaybedilsin mi?"
+"Unsaved changes in {names}. Save them before closing?" = "{names} içinde kaydedilmemiş değişiklikler var. Kapatmadan önce kaydedilsin mi?"
 "Unsaved changes: save first ({save}), or close the tab with {alt}-click to discard" = "Kaydedilmemiş değişiklikler: önce kaydedin ({save}) veya atmak için sekmeyi {alt}-tıklamayla kapatın"
 "Unsaved changes: save first, or close again with {key} to discard" = "Kaydedilmemiş değişiklikler: önce kaydedin veya atmak için {key} ile yeniden kapatın"
 "Up" = "Yukarı"
@@ -1397,6 +1446,7 @@ name = "Türkçe"
 "Use as mask" = "Maske olarak kullan"
 "Use auto layout" = "Otomatik yerleşim kullan"
 "Use number keys for opacity" = "Opaklık için rakam tuşlarını kullan"
+"Use the .figcraft or .fig extension." = ".figcraft veya .fig uzantısını kullanın."
 "Use the layer's fill" = "Katmanın dolgusunu kullan"
 "Used in {files} · {instances}" = "Kullanıldığı yer: {files} · {instances}"
 "Username" = "Kullanıcı adı"
@@ -1489,26 +1539,119 @@ name = "Türkçe"
 "call any command its access allows" = "erişiminin izin verdiği her komutu çağırmak"
 "call only: {commands}" = "yalnızca şunları çağırmak: {commands}"
 "can edit the document" = "belgeyi düzenleyebilir"
+"conditional prototype actions nested too deeply were skipped" = "çok derin iç içe geçmiş koşullu prototip eylemleri atlandı"
+"conditional prototype actions with conditions that can't be evaluated were skipped" = "değerlendirilemeyen koşullara sahip koşullu prototip eylemleri atlandı"
+"connector label background was skipped: style data is missing" = "bağlayıcı etiketinin arka planı atlandı: stil verileri eksik"
+"connector label was skipped: background bounds are invalid" = "bağlayıcı etiketi atlandı: arka plan sınırları geçersiz"
+"connector label was skipped: background transform is invalid" = "bağlayıcı etiketi atlandı: arka plan dönüşümü geçersiz"
+"connector label was skipped: composed text transform is invalid" = "bağlayıcı etiketi atlandı: birleştirilmiş metin dönüşümü geçersiz"
+"connector label was skipped: derived background bounds are missing" = "bağlayıcı etiketi atlandı: türetilmiş arka plan sınırları eksik"
+"connector label was skipped: derived text bounds are missing" = "bağlayıcı etiketi atlandı: türetilmiş metin sınırları eksik"
+"connector label was skipped: text bounds are invalid" = "bağlayıcı etiketi atlandı: metin sınırları geçersiz"
+"connector label was skipped: text style data is missing" = "bağlayıcı etiketi atlandı: metin stili verileri eksik"
+"connector label was skipped: text transform is invalid" = "bağlayıcı etiketi atlandı: metin dönüşümü geçersiz"
+"connector labels were skipped" = "bağlayıcı etiketleri atlandı"
+"connector layers import as static frame/vector snapshots with labels when present; live endpoint bindings are not retained" = "bağlayıcı katmanları, varsa etiketleriyle birlikte statik çerçeve/vektör anlık görüntüleri olarak içe aktarılır; uç noktaların dinamik bağlantıları korunmaz"
+"connector snapshot vector data is missing; connector was left empty" = "bağlayıcı anlık görüntüsünün vektör verileri eksik; bağlayıcı boş bırakıldı"
+"connectors whose ends can't be placed are empty" = "uçları yerleştirilemeyen bağlayıcılar boş"
 "crop marks" = "kesim işaretleri"
+"damaged vector geometry was skipped" = "hasarlı vektör geometrisi atlandı"
+"damaged vector networks import as outlines" = "hasarlı vektör ağları ana hat olarak içe aktarılır"
 "development: {path}" = "geliştirme: {path}"
+"document children other than pages were skipped" = "belgenin sayfa olmayan alt öğeleri atlandı"
+"duplicate grid track sizing entries use equal tracks" = "yinelenen ızgara izi boyutlandırma girdileri eşit izler kullanır"
 "e.g. count + 1" = "ör. count + 1"
 "e.g. count >= 3 and not done" = "ör. count >= 3 and not done"
+"elbowed and curved connectors without a saved path import as straight lines" = "kaydedilmiş yolu olmayan dirsekli ve eğri bağlayıcılar düz çizgi olarak içe aktarılır"
+"entries without a node type were skipped" = "düğüm türü olmayan girdiler atlandı"
 "figcraft:// links from a browser, chat or email open this app and join the session." = "Bir tarayıcıdan, sohbetten veya e-postadan gelen figcraft:// bağlantıları bu uygulamayı açar ve oturuma katılır."
+"filled areas of a vector with their own fill use the layer's fill" = "kendi dolgusu olan vektör dolgu alanları katmanın dolgusunu kullanır"
 "from {server}" = "kaynak: {server}"
+"gamepad triggers without exactly one known controller button were skipped" = "tam olarak bir bilinen kumanda düğmesi olmayan oyun kumandası tetikleyicileri atlandı"
+"grid track list exceeds 1000 entries; the tracks use the default equal sizing" = "ızgara izi listesi 1000 girdiyi aşıyor; izler varsayılan eşit boyutlandırmayı kullanır"
+"grid track sizing is unsupported or malformed; affected tracks use equal sizing" = "ızgara izi boyutlandırması desteklenmiyor veya bozuk; etkilenen izler eşit boyutlandırma kullanır"
+"grid track sizing list exceeds 1000 entries; the tracks use the default equal sizing" = "ızgara izi boyutlandırma listesi 1000 girdiyi aşıyor; izler varsayılan eşit boyutlandırmayı kullanır"
 "hidden" = "gizli"
 "iOS" = "iOS"
+"image filters are ambiguous because both filter containers are present; filter conversion was skipped" = "iki filtre kapsayıcısı da bulunduğu için görüntü filtreleri belirsiz; filtre dönüştürme atlandı"
+"image filters use FigCraft's approximate renderer" = "görüntü filtreleri FigCraft'ın yaklaşık işlemesini kullanır"
+"instance swap properties whose default component isn't in the file were skipped" = "varsayılan bileşeni dosyada olmayan örnek değiştirme özellikleri atlandı"
+"instances inside their own main component were imported as frames" = "kendi ana bileşeninin içindeki örnekler çerçeve olarak içe aktarıldı"
+"instances of components that aren't in the file show no layers" = "dosyada olmayan bileşenlerin örnekleri katman göstermez"
+"instances of components that aren't in the file were imported as frames" = "dosyada olmayan bileşenlerin örnekleri çerçeve olarak içe aktarıldı"
+"instances that would nest a component inside itself were imported as frames" = "bir bileşeni kendi içine yerleştirecek örnekler çerçeve olarak içe aktarıldı"
+"instances without a main component were imported as empty frames" = "ana bileşeni olmayan örnekler boş çerçeve olarak içe aktarıldı"
+"invalid internal .fig text path data was ignored" = "yol üzerindeki metne ait geçersiz dahili .fig verileri yok sayıldı"
+"invalid or oversized vector networks import as outlines" = "geçersiz veya çok büyük vektör ağları ana hat olarak içe aktarılır"
+"invalid or oversized vector path data was skipped" = "geçersiz veya çok büyük vektör yolu verileri atlandı"
 "just now" = "az önce"
+"key triggers without a supported key were skipped" = "desteklenen bir tuşu olmayan tuş tetikleyicileri atlandı"
+"key up triggers import as key presses" = "tuş bırakma tetikleyicileri tuşa basma olarak içe aktarılır"
+"layers without a position were placed at their parent's origin" = "konumu olmayan katmanlar üst öğelerinin başlangıç noktasına yerleştirildi"
+"layers without a type were skipped" = "türü olmayan katmanlar atlandı"
+"legacy image filter container is unsupported; filter conversion was skipped" = "eski görüntü filtresi kapsayıcısı desteklenmiyor; filtre dönüştürme atlandı"
 "locked" = "kilitli"
+"malformed image filters container was skipped" = "bozuk görüntü filtreleri kapsayıcısı atlandı"
+"malformed image paintFilter container was skipped" = "bozuk görüntü paintFilter kapsayıcısı atlandı"
+"malformed slot content assignment was skipped" = "bozuk yuva içeriği ataması atlandı"
 "no bleed" = "taşma payı yok"
 "nobody else here yet" = "burada henüz başka kimse yok"
+"non-default slot settings are not represented and were skipped" = "varsayılan dışındaki yuva ayarları aktarılamıyor ve atlandı"
 "now" = "şimdi"
 "or" = "veya"
+"point stroke joins were preserved; dashed or variable-width strokes render with the layer join" = "nokta başına kontur birleşimleri korundu; kesikli veya değişken genişlikli konturlar katmanın birleşimiyle çizilir"
+"preferred slot component keys cannot be resolved to file nodes and were skipped" = "yuvaların tercih edilen bileşen anahtarları dosyadaki katmanlarla eşleştirilemedi ve atlandı"
+"prototype actions of unknown types were skipped" = "bilinmeyen türdeki prototip eylemleri atlandı"
+"prototype actions without a destination in the file were skipped" = "dosyada hedefi olmayan prototip eylemleri atlandı"
+"prototype expressions on variables that aren't in the variables JSON were skipped" = "değişken JSON'unda olmayan değişkenler üzerindeki prototip ifadeleri atlandı"
+"prototype expressions with unsupported functions were skipped" = "desteklenmeyen işlevler içeren prototip ifadeleri atlandı"
+"prototype interactions without supported actions were skipped" = "desteklenen eylemi olmayan prototip etkileşimleri atlandı"
+"prototype navigations of unknown types were skipped" = "bilinmeyen türdeki prototip gezinmeleri atlandı"
+"prototype transitions of unknown types play instantly" = "bilinmeyen türdeki prototip geçişleri anında oynatılır"
+"prototype triggers of unknown types were skipped" = "bilinmeyen türdeki prototip tetikleyicileri atlandı"
 "put a widget on the canvas" = "tuvale bir widget koymak"
 "read and edit the document" = "belgeyi okumak ve düzenlemek"
 "read the document" = "belgeyi okumak"
 "reads the document" = "belgeyi okur"
+"set-variable actions on variables that aren't in the variables JSON were skipped" = "değişken JSON'unda olmayan değişkenler üzerindeki değişken ayarlama eylemleri atlandı"
+"set-variable actions with values that can't be evaluated were skipped" = "değerlendirilemeyen değerlere sahip değişken ayarlama eylemleri atlandı"
+"set-variable actions with values that don't fit the variable were skipped" = "değişkene uymayan değerlere sahip değişken ayarlama eylemleri atlandı"
+"set-variable actions without a value were skipped" = "değeri olmayan değişken ayarlama eylemleri atlandı"
+"set-variable-mode actions on collections or modes that aren't in the variables JSON were skipped" = "değişken JSON'unda olmayan koleksiyonlar veya modlar üzerindeki değişken modu ayarlama eylemleri atlandı"
+"slot content assignment target is missing or is not slot content" = "yuva içeriği atamasının hedefi eksik veya yuva içeriği değil"
+"slot content assignment uses the empty GUID sentinel and was skipped" = "yuva içeriği ataması boş GUID'i işaretçi olarak kullanıyor ve atlandı"
+"some vector points refer to point settings missing from the file; they use the layer's joins and plain corners" = "bazı vektör noktaları dosyada eksik olan nokta ayarlarına başvuruyor; bu noktalar katmanın birleşimlerini ve düz köşeleri kullanır"
+"some vector segments refer to style settings missing from the file; they use the layer's stroke" = "bazı vektör segmentleri dosyada eksik olan stil ayarlarına başvuruyor; bu segmentler katmanın konturunu kullanır"
+"stale or invalid grid track sizing entries were ignored" = "eski veya geçersiz ızgara izi boyutlandırma girdileri yok sayıldı"
+"stars and polygons without point counts or geometry use the default point count" = "nokta sayısı veya geometrisi olmayan yıldızlar ve çokgenler varsayılan nokta sayısını kullanır"
+"style settings of some vector segments aren't supported; those segments use the layer's stroke" = "bazı vektör segmentlerinin stil ayarları desteklenmiyor; bu segmentler katmanın konturunu kullanır"
+"text path underline or strikethrough decoration is not rendered" = "yol üzerindeki metinde altı çizili veya üstü çizili süsleme çizilmez"
+"text style overrides refer to missing table entries" = "metin stili geçersiz kılmaları eksik tablo girdilerine başvuruyor"
+"the file has no pages" = "dosyada sayfa yok"
 "the plugin" = "eklenti"
+"the variables JSON has no `variableCollections` (expected the local variables response) and was ignored" = "değişken JSON'unda `variableCollections` yok (yerel değişkenler yanıtı bekleniyordu) ve yok sayıldı"
 "this session only" = "yalnızca bu oturum"
+"unknown component property types were skipped" = "bilinmeyen bileşen özelliği türleri atlandı"
+"variable aliases to variables that aren't in the variables JSON (or of another type) were skipped" = "değişken JSON'unda olmayan (veya başka türdeki) değişkenlere yönelik takma adlar atlandı"
+"variable bindings to properties the layer doesn't have were skipped" = "katmanda olmayan özelliklere yönelik değişken bağlamaları atlandı"
+"variable bindings to variables that aren't in the variables JSON (library variables) were skipped" = "değişken JSON'unda olmayan değişkenlere (kitaplık değişkenleri) yönelik bağlamalar atlandı"
+"variable bindings were skipped: the file JSON has no variable definitions (pass the local variables JSON as `variables`, or embed its `meta` next to the file JSON)" = "değişken bağlamaları atlandı: dosya JSON'unda değişken tanımı yok (yerel değişken JSON'unu `variables` olarak verin veya `meta` alanını dosya JSON'unun yanına gömün)"
+"variable bindings whose variable type doesn't fit the property were skipped" = "değişken türü özelliğe uymayan değişken bağlamaları atlandı"
+"variable collections without modes were skipped" = "modu olmayan değişken koleksiyonları atlandı"
+"variable mode lookups in prototype expressions that aren't a variable and one of its modes were skipped" = "prototip ifadelerinde bir değişken ve onun modlarından biri olmayan değişken modu aramaları atlandı"
+"variable modes of collections that aren't in the file were skipped" = "dosyada olmayan koleksiyonların değişken modları atlandı"
+"variable modes of collections that aren't in the variables JSON were skipped" = "değişken JSON'unda olmayan koleksiyonların değişken modları atlandı"
+"variable values that don't match their type (or composed colours) were skipped" = "türüyle eşleşmeyen değişken değerleri (veya birleşik renkler) atlandı"
+"variables of unknown types were skipped" = "bilinmeyen türdeki değişkenler atlandı"
+"variables whose collection isn't in the variables JSON were skipped" = "koleksiyonu değişken JSON'unda olmayan değişkenler atlandı"
+"variables without readable values were skipped" = "okunabilir değeri olmayan değişkenler atlandı"
+"vector points with unknown stroke joins use the layer join" = "bilinmeyen kontur birleşimleri olan vektör noktaları katmanın birleşimini kullanır"
+"vectors without geometry are empty" = "geometrisi olmayan vektörler boş"
+"vectors without geometry are empty (export the file JSON with geometry=paths)" = "geometrisi olmayan vektörler boş (dosya JSON'unu geometry=paths ile dışa aktarın)"
+"very long text was cut to 1,048,576 characters" = "çok uzun metin 1.048.576 karaktere kısaltıldı"
+"very long vector paths were skipped" = "çok uzun vektör yolları atlandı"
+"video actions are not supported and were skipped" = "video eylemleri desteklenmiyor ve atlandı"
+"video triggers are not supported and were skipped" = "video tetikleyicileri desteklenmiyor ve atlandı"
 "yesterday" = "dün"
 "{instances} in {files}" = "{instances}, {files} içinde"
 "{language}: draft translation, waiting for a native speaker's review." = "{language}: taslak çeviri, ana dili konuşan birinin incelemesini bekliyor."
@@ -1518,6 +1661,7 @@ name = "Türkçe"
 "{name} is forgotten on this computer; the file stays on {server}" = "{name} bu bilgisayarda unutuldu; dosya {server} üzerinde kalır"
 "{name} is on the server." = "{name} sunucuda."
 "{name} is spotlighting" = "{name} öne çıkarıyor"
+"{name} is too large to open in the browser (over 512 MB)." = "{name}, tarayıcıda açılamayacak kadar büyük (512 MB'tan fazla)."
 "{name}\nClick to apply to the selection" = "{name}\nSeçime uygulamak için tıklayın"
 "{name}\nDrag onto the canvas, or click to place in the middle of the view.\nHold Alt (Option) while dropping onto an instance to swap it." = "{name}\nTuvale sürükleyin veya görünümün ortasına yerleştirmek için tıklayın.\nBir örneği değiştirmek için üzerine bırakırken Alt (Option) tuşunu basılı tutun."
 "{name} (from {library})" = "{name} ({library} kitaplığından)"
@@ -1553,6 +1697,7 @@ name = "Türkçe"
 "{n} matches" = { other = "{n} eşleşme" }
 "{n} minutes ago" = { other = "{n} dakika önce" }
 "{n} months ago" = { other = "{n} ay önce" }
+"{n} more notes omitted from this report" = { other = "{n} not daha bu rapora alınmadı" }
 "{n} of {total}" = "{n} / {total}"
 "{n} people joined" = { other = "{n} kişi katıldı" }
 "{n} preferred components" = { other = "{n} tercih edilen bileşen" }
@@ -1612,7 +1757,17 @@ name = "Türkçe"
 "arrange.packH" = "Yatay sıkıştır"
 "arrange.packV" = "Dikey sıkıştır"
 "arrange.roundToPixels" = "Piksellere yuvarla"
+"arrange.spacing" = "Aralık"
 "arrange.tidy" = "Toparla"
+"board.connector" = "Bağlayıcı"
+"board.ink" = "Keçeli kalem çizgisi"
+"board.label" = "Bağlayıcı etiketi"
+"board.nextSticky" = "Sonraki yapışkan not"
+"board.setColor" = "Pano rengi"
+"board.setStyle" = "Pano stili"
+"board.shape" = "Metinli şekil"
+"board.stamp" = "Damga"
+"board.sticky" = "Yapışkan not"
 "bool.exclude" = "Seçimi hariç tut"
 "bool.flatten" = "Boolean'ı düzleştir"
 "bool.intersect" = "Seçimi kesiştir"
@@ -1712,6 +1867,7 @@ name = "Türkçe"
 "edit.duplicate" = "Çoğalt"
 "edit.findReplace" = "Bul ve değiştir"
 "edit.paste" = "Yapıştır"
+"edit.pasteDesignLayers" = "Tasarım katmanlarını yapıştır"
 "edit.pasteOver" = "Seçimin üzerine yapıştır"
 "edit.pasteProperties" = "Özellikleri yapıştır"
 "edit.pasteReplace" = "Değiştirmek için yapıştır"
@@ -1735,7 +1891,9 @@ name = "Türkçe"
 "file.exportLayers" = "Katmanları dışa aktar"
 "file.exportSvg" = "Seçimi SVG olarak dışa aktar"
 "file.import" = "İçe aktar"
+"file.moveTab" = "Sekmeyi taşı"
 "file.new" = "Yeni tasarım dosyası"
+"file.newBoard" = "Yeni pano"
 "file.newFromTemplate" = "Şablondan yeni"
 "file.open" = "Aç"
 "file.openRecent" = "Son kullanılanı aç"
@@ -1918,6 +2076,10 @@ name = "Türkçe"
 "select.sameStroke" = "Aynı konturu seç"
 "select.sameText" = "Aynı metin özelliklerini seç"
 "select.set" = "Seç"
+"selection.applyColorStyle" = "Seçime renk stili uygula"
+"selection.colors" = "Seçim renkleri"
+"selection.selectColor" = "Bu renkteki katmanları seç"
+"selection.setPaint" = "Seçimin rengini değiştir"
 "shape.arrow" = "Ok"
 "shape.ellipse" = "Elips"
 "shape.line" = "Çizgi"
@@ -1998,10 +2160,14 @@ name = "Türkçe"
 "text.weightUp" = "Yazı tipi kalınlığını artır"
 "tool.arrow" = "Ok"
 "tool.comment" = "Yorum"
+"tool.connector" = "Bağlayıcı"
 "tool.ellipse" = "Elips"
+"tool.eraser" = "Silgi"
 "tool.frame" = "Çerçeve"
 "tool.hand" = "El"
+"tool.highlighter" = "Fosforlu kalem"
 "tool.line" = "Çizgi"
+"tool.marker" = "Keçeli kalem"
 "tool.move" = "Taşı"
 "tool.pen" = "Kalem"
 "tool.pencil" = "Kurşun kalem"
@@ -2013,9 +2179,12 @@ name = "Türkçe"
 "tool.scaleAnchor" = "Ölçekleme bağlantı noktası"
 "tool.section" = "Bölüm"
 "tool.set" = "Araç seç"
+"tool.shape" = "Şekiller"
 "tool.shapeBuilder" = "Şekil oluşturucu"
 "tool.slice" = "Dilim"
+"tool.stamp" = "Damga"
 "tool.star" = "Yıldız"
+"tool.sticky" = "Yapışkan not"
 "tool.text" = "Metin"
 "transform.move" = "Taşı"
 "transform.moveTo" = "Şuraya taşı"
@@ -2077,11 +2246,13 @@ name = "Türkçe"
 "vector.edit.tool" = "Vektör düzenleme aracı"
 "vector.edit.transform" = "Noktaları dönüştür"
 "vector.edit.widthPoint" = "Genişlik noktası"
+"vector.fillRule" = "Dolgu kuralını ayarla"
 "vector.flatten" = "Düzleştir"
 "vector.join" = "Seçimi birleştir"
 "vector.offset" = "Yolu ötele"
 "vector.outlineStroke" = "Konturu ana hatlara dönüştür"
 "vector.reverse" = "Yol yönünü ters çevir"
+"vector.reverseLoop" = "Döngüyü çevir"
 "vector.simplify" = "Vektörü sadeleştir"
 "vector.smoothJoin" = "Seçimi yumuşak birleştir"
 "version.autosave" = "Otomatik kayıt sürümü"
diff --git a/crates/ui-egui/locales/zh-Hans.toml b/crates/ui-egui/locales/zh-Hans.toml
index af4cf6534..7add99c5d 100644
--- a/crates/ui-egui/locales/zh-Hans.toml
+++ b/crates/ui-egui/locales/zh-Hans.toml
@@ -19,6 +19,7 @@ status = "draft — needs native review"
 "1…9, 0" = "1…9, 0"
 "@{login}: {prs} PRs, {commits} commits, +{added} / −{deleted} lines (Δ {delta}), +{bin_added} / −{bin_deleted} binary assets, {first} – {last}" = "@{login}：{prs} 个 PR，{commits} 次提交，+{added} / −{deleted} 行（Δ {delta}），二进制资源 +{bin_added} / −{bin_deleted}，{first} – {last}"
 "A collection of this file with these modes and variables: override their values per mode and add variables of its own" = "本文件中带有这些模式和变量的集合：可按模式覆盖其值，并添加自己的变量"
+"A .figcraft file with this name already exists. Choose its full name to confirm replacement." = "已存在同名的 .figcraft 文件。请选择其完整名称以确认替换。"
 "A layer on its own aligns to its frame: select more layers, or one in a frame" = "单个图层与其所在画框对齐：请再选择其他图层，或选择画框内的图层"
 "A spring plays until it settles: its mass, stiffness and damping set how long" = "弹簧动画播放至静止，时长由质量、刚度和阻尼决定"
 "About" = "关于"
@@ -118,6 +119,7 @@ status = "draft — needs native review"
 "Archived" = "已归档"
 "Arrange" = "排列"
 "Arrow" = "箭头"
+"Arrow at the end" = "末端箭头"
 "As typed" = "原样"
 "Asking the server…" = "正在询问服务器…"
 "Assets" = "资源"
@@ -189,7 +191,9 @@ status = "draft — needs native review"
 "C or ⇧C" = "C 或 ⇧C"
 "CMYK colour" = "CMYK 颜色"
 "Can view" = "可查看"
+"Check" = "对勾"
 "Checking the server…" = "正在检查服务器…"
+"Chevron" = "箭头形"
 "Clear from this list" = "从此列表中清除"
 "Code or invite link" = "代码或邀请链接"
 "Color profile: {name}" = "颜色配置文件：{name}"
@@ -235,7 +239,6 @@ status = "draft — needs native review"
 "Close tab" = "关闭标签页"
 "Close version history" = "关闭版本历史"
 "Close when clicking outside" = "点击外部时关闭"
-"Close without saving" = "关闭但不保存"
 "Code" = "代码"
 "Code syntax" = "代码语法"
 "Collapse" = "折叠"
@@ -262,6 +265,8 @@ status = "draft — needs native review"
 "Commits" = "提交"
 "Company" = "公司"
 "Compare changes" = "比较更改"
+"Compare with" = "比较对象"
+"Compatibility notes" = "兼容性说明"
 "Completed" = "已完成"
 "Component" = "组件"
 "Component name" = "组件名称"
@@ -276,6 +281,7 @@ status = "draft — needs native review"
 "Connected" = "已连接"
 "Connected to code: {from}" = "已关联代码：{from}"
 "Connection lost, reconnecting (attempt {attempt})…" = "连接已断开，正在重新连接（第 {attempt} 次尝试）…"
+"Connector" = "连接线"
 "Constrain proportions" = "锁定比例"
 "Constraints" = "约束"
 "Content" = "内容"
@@ -304,6 +310,7 @@ status = "draft — needs native review"
 "Corner radius" = "圆角半径"
 "Corner smoothing" = "圆角平滑"
 "Couldn't reach {server}: showing what this computer remembers." = "无法连接 {server}：显示的是这台电脑记录的内容。"
+"Couldn't read {name}." = "无法读取 {name}。"
 "Couldn't save automatically: {error}" = "无法自动保存：{error}"
 "Count" = "数量"
 "Create" = "创建"
@@ -327,6 +334,7 @@ status = "draft — needs native review"
 "Current version" = "当前版本"
 "Cursor chat" = "光标聊天"
 "Custom" = "自定义"
+"Custom size" = "自定义大小"
 "Cut" = "剪切"
 "Dark" = "深色"
 "Darken" = "变暗"
@@ -357,6 +365,7 @@ status = "draft — needs native review"
 "Description" = "描述"
 "Description (optional)" = "描述（可选）"
 "Design" = "设计"
+"Design panel" = "设计面板"
 "Desktop" = "桌面"
 "Destination" = "目标"
 "Detach alias" = "分离别名"
@@ -367,6 +376,7 @@ status = "draft — needs native review"
 "Detach variable" = "分离变量"
 "Details" = "详细"
 "Dev Mode" = "开发模式"
+"Dev Mode only inspects: switch to Design (Shift+D) to edit" = "开发模式仅用于检查：切换到设计 (Shift+D) 进行编辑"
 "Dev resources" = "开发资源"
 "Development" = "开发"
 "Device" = "设备"
@@ -383,6 +393,7 @@ status = "draft — needs native review"
 "Distribute horizontal spacing" = "水平间距分布"
 "Distribute vertical spacing" = "垂直间距分布"
 "Divider" = "分隔线"
+"Don't Save" = "不保存"
 "Don't truncate" = "不截断"
 "Done" = "完成"
 "Done editing" = "完成编辑"
@@ -413,6 +424,7 @@ status = "draft — needs native review"
 "Effect settings" = "效果设置"
 "Effect styles" = "效果样式"
 "Effects" = "效果"
+"Elbow" = "折线"
 "Ellipse" = "椭圆"
 "Ellipses" = "椭圆"
 "Else" = "否则"
@@ -461,6 +473,7 @@ status = "draft — needs native review"
 "False" = "假"
 "Fetching from the server…" = "正在从服务器获取…"
 "FigCraft couldn't open its window: {error}" = "FigCraft 无法打开窗口：{error}"
+"FigCraft doesn't support every feature of these files yet. The notes list what was left out or changed in the imported copy; the original file is unchanged." = "FigCraft 尚不支持这些文件的全部功能。说明中列出了导入副本中省略或更改的内容；原始文件保持不变。"
 "File" = "文件"
 "File name" = "文件名"
 "File published" = "文件已发布"
@@ -542,6 +555,7 @@ status = "draft — needs native review"
 "Hanging list" = "悬挂列表"
 "Hanging punctuation" = "标点悬挂"
 "Hard light" = "强光"
+"Heart" = "爱心"
 "Height" = "高度"
 "Help" = "帮助"
 "Help and resources" = "帮助和资源"
@@ -552,6 +566,7 @@ status = "draft — needs native review"
 "Hide from publishing" = "发布时隐藏"
 "Hide section contents" = "隐藏分区内容"
 "Highlight layers on hover" = "悬停时高亮图层"
+"Highlighter" = "荧光笔"
 "Highlights" = "高光"
 "Hold Alt" = "按住 Alt"
 "Hold Alt+Z" = "按住 Alt+Z"
@@ -577,11 +592,14 @@ status = "draft — needs native review"
 "If {condition}" = "如果 {condition}"
 "Ignore auto layout (absolute position)" = "忽略自动布局（绝对定位）"
 "Image" = "图片"
+"Images" = "图片"
 "Import" = "导入"
 "Import path" = "导入路径"
 "Import plugin from manifest" = "从清单导入插件"
 "Import plugin from manifest…" = "从清单导入插件…"
+"Import report" = "导入报告"
 "Import variables" = "导入变量"
+"Imported document" = "导入的文档"
 "Imported {name}" = "已导入 {name}"
 "Imported {n} new variables, updated {updated}" = { other = "已导入 {n} 个新变量，更新 {updated} 个" }
 "Import…" = "导入…"
@@ -609,11 +627,13 @@ status = "draft — needs native review"
 "Instance swap (no other component)" = "实例替换（无其他组件）"
 "Instances" = "实例"
 "Instant" = "即时"
+"Intensity" = "强度"
 "Interaction" = "交互"
 "Interactions" = "交互"
 "Interface design and prototyping. A free, open-source, clean-room design tool written from scratch in Rust, part of the ArtCraft Crafting Apps." = "界面设计与原型制作。一款以 Rust 从零编写的免费、开源、净室设计工具，属于 ArtCraft Crafting Apps 系列。"
 "Intersect" = "相交"
 "Intersects" = "相交"
+"Invalid color" = "无效颜色"
 "Invite link" = "邀请链接"
 "Invite link copied" = "已复制邀请链接"
 "It asks permission to:" = "它请求以下权限："
@@ -702,6 +722,7 @@ status = "draft — needs native review"
 "Mark as resolved" = "标为已解决"
 "Mark as unread" = "标为未读"
 "Mark as unresolved" = "标为未解决"
+"Marker" = "马克笔"
 "Mask" = "蒙版"
 "Mass · Stiffness · Damping" = "质量 · 刚度 · 阻尼"
 "Match (empty: the whole name)" = "匹配（留空：整个名称）"
@@ -758,7 +779,9 @@ status = "draft — needs native review"
 "Named instance" = "具名实例"
 "Navigate to" = "导航到"
 "Nested instance" = "嵌套实例"
+"New board" = "新建白板"
 "New design file" = "新建设计文件"
+"Next frame" = "下一个画框"
 "Next or previous control in the focused region" = "聚焦区域中的下一个或上一个控件"
 "Next ready for dev" = "下一个可供开发"
 "Next size option" = "下一个尺寸选项"
@@ -768,12 +791,15 @@ status = "draft — needs native review"
 "No branches. A branch is a copy of the file to try changes in, then review and merge." = "没有分支。分支是文件的副本，可在其中尝试更改，再审阅并合并。"
 "No category" = "无类别"
 "No changes" = "无更改"
+"No color styles" = "没有颜色样式"
 "No colour variables fit here." = "没有适用于此处的颜色变量。"
 "No colour variables yet. Create them in Local variables." = "还没有颜色变量。请在“本地变量”中创建。"
 "No comments yet" = "还没有评论"
+"No compatibility warnings reported" = "未报告兼容性警告"
 "No components yet. Select layers and press {keys}." = "还没有组件。选择图层并按 {keys}。"
 "No conflicts." = "没有冲突。"
 "No contributor data was built into this copy." = "此副本未内置贡献者数据。"
+"No device" = "无设备"
 "No fonts match" = "没有匹配的字体"
 "No join code here (the server is older than join codes, or this address can't be put in one): share the link instead." = "此处没有加入代码（服务器版本早于加入代码，或此地址无法写入代码）：请改为分享链接。"
 "No layer changes to show." = "没有可显示的图层更改。"
@@ -816,6 +842,7 @@ status = "draft — needs native review"
 "Not read yet" = "尚未读取"
 "Not shared" = "未分享"
 "Note {n}" = "备注 {n}"
+"Nothing changed since this version." = "自此版本以来没有任何更改。"
 "Nothing changed since this was marked ready for dev." = "自标记为可供开发以来没有任何更改。"
 "Nothing here yet. Set a frame's status to list it." = "这里还没有内容。设置画框的状态即可将其列出。"
 "Nothing online yet. Use Share on a file to put it online and it is listed here." = "还没有在线文件。对文件使用“分享”将其放到网上后，它会列在这里。"
@@ -849,6 +876,7 @@ status = "draft — needs native review"
 "Open branch" = "打开分支"
 "Open file" = "打开文件"
 "Open files" = "打开的文件"
+"Open presentations" = "打开的演示"
 "Open in focus view" = "在聚焦视图中打开"
 "Open in new window" = "在新窗口中打开"
 "Open invite links in FigCraft" = "在 FigCraft 中打开邀请链接"
@@ -857,6 +885,7 @@ status = "draft — needs native review"
 "Open overlay" = "打开浮层"
 "Open prototype preview" = "打开原型预览"
 "Open variables ({count})" = "打开变量（{count}）"
+"Opened as a new document" = "已作为新文档打开"
 "Opened “{name}” in a new tab" = "已在新标签页中打开“{name}”"
 "Open|comments" = "未解决"
 "Options" = "选项"
@@ -879,7 +908,11 @@ status = "draft — needs native review"
 "PDF print settings" = "PDF 打印设置"
 "Padding" = "内边距"
 "Page" = "页面"
+"Page deleted" = "页面已删除"
 "Pages" = "页面"
+"Pages added to the document" = "页面已添加到文档"
+"Pink" = "粉色"
+"Placed on the current page" = "已放置在当前页面"
 "Pages: {pages}" = "页面：{pages}"
 "Paint bucket" = "油漆桶"
 "Pan the canvas" = "平移画布"
@@ -894,6 +927,7 @@ status = "draft — needs native review"
 "Paste a team library link (a view link)" = "粘贴团队库链接（查看链接）"
 "Paste here" = "粘贴到此处"
 "Paste to replace" = "粘贴以替换"
+"Pasted design layers; {n} kinds of content were left out" = { other = "已粘贴设计图层；有 {n} 类内容未包含" }
 "Pattern" = "图案"
 "Pattern alignment" = "图案对齐"
 "Pattern scale" = "图案缩放"
@@ -919,6 +953,7 @@ status = "draft — needs native review"
 "Plugins run in FigCraft's sandbox, without files, network or clock. Install only plugins you trust." = "插件在 FigCraft 的沙盒中运行，无法使用文件、网络或时钟。请只安装你信任的插件。"
 "Plus darker" = "加深"
 "Plus lighter" = "增亮"
+"Plus one" = "加一"
 "Point" = "点"
 "Points" = "点数"
 "Polygon" = "多边形"
@@ -944,6 +979,7 @@ status = "draft — needs native review"
 "Preview" = "预览"
 "Preview this flow" = "预览此流程"
 "Preview this frame" = "预览此画框"
+"Previous frame" = "上一个画框"
 "Previous ready for dev" = "上一个可供开发"
 "Progressive" = "渐进"
 "Properties" = "属性"
@@ -964,6 +1000,7 @@ status = "draft — needs native review"
 "Push" = "推入"
 "Push changes to main component" = "将更改推送到主组件"
 "Put text on path" = "将文本放到路径上"
+"Question" = "问号"
 "R" = "R"
 "Radial" = "径向"
 "Radius" = "半径"
@@ -1008,6 +1045,7 @@ status = "draft — needs native review"
 "Removed" = "已删除"
 "Removed from the server" = "已从服务器移除"
 "Removed since it was marked" = "标记后已删除"
+"Removed since this version" = "自此版本以来已移除"
 "Rename" = "重命名"
 "Rename duplicated layers" = "重命名副本图层"
 "Rename folder" = "重命名文件夹"
@@ -1037,6 +1075,7 @@ status = "draft — needs native review"
 "Resize by the nudge amount" = "按微移量调整大小"
 "Resize frames to the device's screen (or the window without a device): their constraints and auto layout respond" = "将画框调整为设备屏幕大小（无设备时为窗口大小）：其约束和自动布局随之响应"
 "Resize to fit" = "调整大小以适应"
+"Resizing" = "调整大小"
 "Resolve" = "解决"
 "Resolve change" = "解决更改"
 "Resolved" = "已解决"
@@ -1062,6 +1101,7 @@ status = "draft — needs native review"
 "Rotation jitter" = "旋转抖动"
 "Round" = "圆形"
 "Rounded" = "圆润"
+"Rounded rectangle" = "圆角矩形"
 "Row" = "行"
 "Row gap" = "行间距"
 "Row sizes" = "行高"
@@ -1108,12 +1148,14 @@ status = "draft — needs native review"
 "Select all with same" = "选择所有相同"
 "Select layer" = "选择图层"
 "Select layers to apply the style to" = "选择要应用样式的图层"
+"Select layers with this color" = "选择使用此颜色的图层"
 "Select overlapping shapes" = "选择重叠的形状"
 "Select points to edit their position, radius and mirroring" = "选择点以编辑其位置、半径和镜像"
 "Select slot" = "选择插槽"
 "Selection" = "所选项"
 "Selection box, {w} by {h} at {x}, {y}: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "选框，{w} × {h}，位于 {x}, {y}：方向键移动，Shift+方向键或 {cmd}+方向键调整大小，Enter 选择，Esc 取消"
 "Selection box: arrows move it, Shift+arrows or {cmd}+arrows size it, Enter selects, Escape cancels" = "选框：方向键移动，Shift+方向键或 {cmd}+方向键调整大小，Enter 选择，Esc 取消"
+"Selection colors" = "所选项颜色"
 "Send backward" = "下移一层"
 "Send report" = "发送举报"
 "Send to back" = "置于底层"
@@ -1129,6 +1171,7 @@ status = "draft — needs native review"
 "Shape" = "形状"
 "Shape builder" = "形状生成器"
 "Shape tools" = "形状工具"
+"Shapes" = "形状"
 "Share" = "分享"
 "Share this file" = "分享此文件"
 "Share: live session, export" = "分享：实时会话、导出"
@@ -1186,10 +1229,13 @@ status = "draft — needs native review"
 "Space+drag" = "空格+拖动"
 "Spacing" = "间距"
 "Spam, stolen work, abuse…" = "垃圾信息、盗用作品、滥用…"
+"Speech bubble" = "对话气泡"
 "Splay" = "张开"
 "Spotlight me" = "聚焦于我"
 "Spread" = "扩展"
 "Square" = "方形"
+"Stamp" = "印章"
+"Stamps" = "印章"
 "Standard" = "标准"
 "Standard ligatures" = "标准连字"
 "Star" = "星形"
@@ -1198,17 +1244,22 @@ status = "draft — needs native review"
 "Start ascending from / stop descending at" = "升序起点 / 降序终点"
 "Start from a blank canvas" = "从空白画布开始"
 "Start on path" = "路径起点"
+"Start on the Home screen" = "启动时显示主页"
 "Start point" = "起点"
 "Start sharing" = "开始分享"
 "Starting to share…" = "正在开始分享…"
 "Status" = "状态"
 "Sticky" = "粘性"
+"Sticky note" = "便利贴"
+"Sticky note colors" = "便利贴颜色"
+"Sticky notes, shapes and connectors" = "便利贴、形状和连接线"
 "Stop" = "停止"
 "Stop following {name}" = "停止跟随 {name}"
 "Stop session" = "停止会话"
 "Stop sharing" = "停止分享"
 "Stop spotlighting" = "停止聚焦"
 "Stop {n}  {hex}" = "色标 {n}  {hex}"
+"Straight" = "直线"
 "Stretch" = "拉伸"
 "Strikethrough" = "删除线"
 "String" = "字符串"
@@ -1252,6 +1303,7 @@ status = "draft — needs native review"
 "Text" = "文本"
 "Text align" = "文本对齐"
 "Text content" = "文本内容"
+"Text size" = "文字大小"
 "Text style" = "文本样式"
 "Text styles" = "文本样式"
 "Texts" = "文本"
@@ -1282,6 +1334,9 @@ status = "draft — needs native review"
 "This server is open to the public: no key needed." = "此服务器对公众开放：无需密钥。"
 "This server needs its key: add ?key=… to the address (`figcraft-server key` prints it on the server's machine)." = "此服务器需要密钥：请在地址后加上 ?key=…（在服务器所在的机器上运行 `figcraft-server key` 可显示）。"
 "This server takes files only with its key: see Advanced." = "此服务器只接受带密钥的文件：请查看“高级”。"
+"Thumbs up" = "点赞"
+"This version can't be read." = "无法读取此版本。"
+"This version doesn't have it: all of it is new." = "此版本中没有它：全部是新的。"
 "Tidy up" = "整理"
 "Tile" = "平铺"
 "Tile type" = "平铺类型"
@@ -1298,6 +1353,7 @@ status = "draft — needs native review"
 "Top left radius" = "左上圆角"
 "Top right radius" = "右上圆角"
 "Transform" = "变换"
+"Triangle" = "三角形"
 "Triangle arrow" = "三角箭头"
 "Trigger" = "触发器"
 "True" = "真"
@@ -1320,7 +1376,7 @@ status = "draft — needs native review"
 "Unread" = "未读"
 "Unresolve" = "取消解决"
 "Unsaved changes" = "未保存的更改"
-"Unsaved changes in {names}. Close the window and lose them?" = "{names} 中有未保存的更改。要关闭窗口并丢弃这些更改吗？"
+"Unsaved changes in {names}. Save them before closing?" = "{names} 中有未保存的更改。关闭前要保存吗？"
 "Unsaved changes: save first ({save}), or close the tab with {alt}-click to discard" = "有未保存的更改：请先保存（{save}），或按住 {alt} 点击关闭标签页以丢弃"
 "Unsaved changes: save first, or close again with {key} to discard" = "有未保存的更改：请先保存，或再次按 {key} 关闭以丢弃"
 "Up" = "向上"
@@ -1339,6 +1395,7 @@ status = "draft — needs native review"
 "Use as mask" = "用作蒙版"
 "Use auto layout" = "使用自动布局"
 "Use number keys for opacity" = "用数字键设置不透明度"
+"Use the .figcraft or .fig extension." = "请使用 .figcraft 或 .fig 扩展名。"
 "Use the layer's fill" = "使用图层的填充"
 "Used in {files} · {instances}" = "用于 {files} · {instances}"
 "Username" = "用户名"
@@ -1382,10 +1439,12 @@ status = "draft — needs native review"
 "WebSocket URL copied" = "已复制 WebSocket URL"
 "Wedge" = "楔形"
 "Weight" = "粗细"
+"What changed since a saved version" = "自已保存版本以来的更改"
 "What changed since it was marked ready for dev" = "自标记为可供开发以来的更改"
 "What is wrong with this file? The server's operator gets your report." = "此文件有什么问题？你的举报会发送给服务器的运营者。"
 "What it's for" = "用途"
 "What this changed from isn't known: it changed before FigCraft kept a copy of ready-for-dev frames. Resolve the change (or mark it ready again) to compare from now on." = "无法得知更改前的状态：它在 FigCraft 开始保存可供开发画框的副本之前就已更改。请解决此更改（或重新标记为可供开发），以便今后进行比较。"
+"When marked ready" = "标记为就绪时"
 "While hovering" = "悬停时"
 "While pressing" = "按住时"
 "White" = "白"
@@ -1427,25 +1486,118 @@ status = "draft — needs native review"
 "call any command its access allows" = "调用其访问权限允许的任何命令"
 "call only: {commands}" = "仅调用：{commands}"
 "can edit the document" = "可编辑文档"
+"conditional prototype actions nested too deeply were skipped" = "已跳过嵌套过深的条件原型操作"
+"conditional prototype actions with conditions that can't be evaluated were skipped" = "已跳过条件无法求值的条件原型操作"
+"connector label background was skipped: style data is missing" = "已跳过连接线标签背景：缺少样式数据"
+"connector label was skipped: background bounds are invalid" = "已跳过连接线标签：背景边界无效"
+"connector label was skipped: background transform is invalid" = "已跳过连接线标签：背景变换无效"
+"connector label was skipped: composed text transform is invalid" = "已跳过连接线标签：组合后的文本变换无效"
+"connector label was skipped: derived background bounds are missing" = "已跳过连接线标签：缺少推算的背景边界"
+"connector label was skipped: derived text bounds are missing" = "已跳过连接线标签：缺少推算的文本边界"
+"connector label was skipped: text bounds are invalid" = "已跳过连接线标签：文本边界无效"
+"connector label was skipped: text style data is missing" = "已跳过连接线标签：缺少文本样式数据"
+"connector label was skipped: text transform is invalid" = "已跳过连接线标签：文本变换无效"
+"connector labels were skipped" = "已跳过连接线标签"
+"connector layers import as static frame/vector snapshots with labels when present; live endpoint bindings are not retained" = "连接线图层导入为静态的画框/矢量快照，有标签时一并导入；不保留端点的动态绑定"
+"connector snapshot vector data is missing; connector was left empty" = "缺少连接线快照的矢量数据；连接线保留为空"
+"connectors whose ends can't be placed are empty" = "无法放置端点的连接线为空"
 "crop marks" = "裁切标记"
+"damaged vector geometry was skipped" = "已跳过损坏的矢量几何"
+"damaged vector networks import as outlines" = "损坏的矢量网络导入为轮廓"
 "development: {path}" = "开发：{path}"
+"document children other than pages were skipped" = "已跳过非页面的文档子项"
+"duplicate grid track sizing entries use equal tracks" = "重复的网格轨道尺寸条目使用等分轨道"
 "e.g. count + 1" = "例如 count + 1"
 "e.g. count >= 3 and not done" = "例如 count >= 3 and not done"
+"elbowed and curved connectors without a saved path import as straight lines" = "没有已保存路径的折线和曲线连接线导入为直线"
+"entries without a node type were skipped" = "已跳过没有节点类型的条目"
 "figcraft:// links from a browser, chat or email open this app and join the session." = "来自浏览器、聊天或邮件的 figcraft:// 链接会打开此应用并加入会话。"
+"filled areas of a vector with their own fill use the layer's fill" = "具有自身填充的矢量填充区域使用图层的填充"
 "from {server}" = "来自 {server}"
+"gamepad triggers without exactly one known controller button were skipped" = "已跳过没有恰好一个已知手柄按钮的游戏手柄触发器"
+"grid track list exceeds 1000 entries; the tracks use the default equal sizing" = "网格轨道列表超过 1000 个条目；轨道使用默认的等分尺寸"
+"grid track sizing is unsupported or malformed; affected tracks use equal sizing" = "网格轨道尺寸不受支持或格式错误；受影响的轨道使用等分尺寸"
+"grid track sizing list exceeds 1000 entries; the tracks use the default equal sizing" = "网格轨道尺寸列表超过 1000 个条目；轨道使用默认的等分尺寸"
 "hidden" = "已隐藏"
 "iOS" = "iOS"
+"image filters are ambiguous because both filter containers are present; filter conversion was skipped" = "两个滤镜容器同时存在，图片滤镜有歧义；已跳过滤镜转换"
+"image filters use FigCraft's approximate renderer" = "图片滤镜使用 FigCraft 的近似渲染"
+"instance swap properties whose default component isn't in the file were skipped" = "已跳过默认组件不在文件中的实例替换属性"
+"instances inside their own main component were imported as frames" = "位于自身主组件内的实例已导入为画框"
+"instances of components that aren't in the file show no layers" = "文件中没有的组件的实例不显示图层"
+"instances of components that aren't in the file were imported as frames" = "文件中没有的组件的实例已导入为画框"
+"instances that would nest a component inside itself were imported as frames" = "会将组件嵌套到自身内部的实例已导入为画框"
+"instances without a main component were imported as empty frames" = "没有主组件的实例已导入为空画框"
+"invalid internal .fig text path data was ignored" = "已忽略无效的 .fig 内部路径文字数据"
+"invalid or oversized vector networks import as outlines" = "无效或过大的矢量网络导入为轮廓"
+"invalid or oversized vector path data was skipped" = "已跳过无效或过大的矢量路径数据"
+"key triggers without a supported key were skipped" = "已跳过没有受支持按键的按键触发器"
+"key up triggers import as key presses" = "松开按键触发器导入为按下按键"
+"layers without a position were placed at their parent's origin" = "没有位置的图层已放在其父级的原点"
+"layers without a type were skipped" = "已跳过没有类型的图层"
+"legacy image filter container is unsupported; filter conversion was skipped" = "不支持旧版图片滤镜容器；已跳过滤镜转换"
 "locked" = "已锁定"
+"malformed image filters container was skipped" = "已跳过格式错误的图片滤镜容器"
+"malformed image paintFilter container was skipped" = "已跳过格式错误的图片 paintFilter 容器"
+"malformed slot content assignment was skipped" = "已跳过格式错误的插槽内容分配"
 "no bleed" = "无出血"
 "nobody else here yet" = "这里还没有其他人"
+"non-default slot settings are not represented and were skipped" = "非默认的插槽设置无法表示，已跳过"
 "now" = "刚刚"
 "or" = "或"
+"point stroke joins were preserved; dashed or variable-width strokes render with the layer join" = "已保留各点的描边转角；虚线描边或可变宽度描边以图层的转角绘制"
+"preferred slot component keys cannot be resolved to file nodes and were skipped" = "插槽的首选组件键无法对应到文件中的图层，已跳过"
+"prototype actions of unknown types were skipped" = "已跳过未知类型的原型操作"
+"prototype actions without a destination in the file were skipped" = "已跳过在文件中没有目标的原型操作"
+"prototype expressions on variables that aren't in the variables JSON were skipped" = "已跳过使用变量 JSON 中没有的变量的原型表达式"
+"prototype expressions with unsupported functions were skipped" = "已跳过使用不受支持函数的原型表达式"
+"prototype interactions without supported actions were skipped" = "已跳过没有受支持操作的原型交互"
+"prototype navigations of unknown types were skipped" = "已跳过未知类型的原型导航"
+"prototype transitions of unknown types play instantly" = "未知类型的原型过渡即时播放"
+"prototype triggers of unknown types were skipped" = "已跳过未知类型的原型触发器"
 "put a widget on the canvas" = "在画布上放置小组件"
 "read and edit the document" = "读取和编辑文档"
 "read the document" = "读取文档"
 "reads the document" = "读取文档"
+"set-variable actions on variables that aren't in the variables JSON were skipped" = "已跳过针对变量 JSON 中没有的变量的设置变量操作"
+"set-variable actions with values that can't be evaluated were skipped" = "已跳过值无法求值的设置变量操作"
+"set-variable actions with values that don't fit the variable were skipped" = "已跳过值与变量不符的设置变量操作"
+"set-variable actions without a value were skipped" = "已跳过没有值的设置变量操作"
+"set-variable-mode actions on collections or modes that aren't in the variables JSON were skipped" = "已跳过针对变量 JSON 中没有的集合或模式的设置变量模式操作"
+"slot content assignment target is missing or is not slot content" = "插槽内容分配的目标缺失或不是插槽内容"
+"slot content assignment uses the empty GUID sentinel and was skipped" = "插槽内容分配使用空 GUID 作为哨兵值，已跳过"
+"some vector points refer to point settings missing from the file; they use the layer's joins and plain corners" = "部分矢量点引用了文件中缺失的点设置；这些点使用图层的转角和普通角"
+"some vector segments refer to style settings missing from the file; they use the layer's stroke" = "部分矢量段引用了文件中缺失的样式设置；这些段使用图层的描边"
+"stale or invalid grid track sizing entries were ignored" = "已忽略过时或无效的网格轨道尺寸条目"
+"stars and polygons without point counts or geometry use the default point count" = "没有点数或几何的星形和多边形使用默认点数"
+"style settings of some vector segments aren't supported; those segments use the layer's stroke" = "部分矢量段的样式设置不受支持；这些段使用图层的描边"
+"text path underline or strikethrough decoration is not rendered" = "不绘制路径文字的下划线或删除线"
+"text style overrides refer to missing table entries" = "文本样式覆盖引用了缺失的表条目"
+"the file has no pages" = "文件没有页面"
 "the plugin" = "插件"
+"the variables JSON has no `variableCollections` (expected the local variables response) and was ignored" = "变量 JSON 中没有 `variableCollections`（应为本地变量响应），已忽略"
 "this session only" = "仅限本次会话"
+"unknown component property types were skipped" = "已跳过未知的组件属性类型"
+"variable aliases to variables that aren't in the variables JSON (or of another type) were skipped" = "已跳过指向变量 JSON 中没有的（或其他类型的）变量的别名"
+"variable bindings to properties the layer doesn't have were skipped" = "已跳过绑定到图层没有的属性的变量绑定"
+"variable bindings to variables that aren't in the variables JSON (library variables) were skipped" = "已跳过绑定到变量 JSON 中没有的变量（库变量）的绑定"
+"variable bindings were skipped: the file JSON has no variable definitions (pass the local variables JSON as `variables`, or embed its `meta` next to the file JSON)" = "已跳过变量绑定：文件 JSON 中没有变量定义（将本地变量 JSON 作为 `variables` 传入，或将其 `meta` 嵌入文件 JSON 旁）"
+"variable bindings whose variable type doesn't fit the property were skipped" = "已跳过变量类型与属性不符的变量绑定"
+"variable collections without modes were skipped" = "已跳过没有模式的变量集合"
+"variable mode lookups in prototype expressions that aren't a variable and one of its modes were skipped" = "已跳过原型表达式中不是变量及其某个模式的变量模式查找"
+"variable modes of collections that aren't in the file were skipped" = "已跳过文件中没有的集合的变量模式"
+"variable modes of collections that aren't in the variables JSON were skipped" = "已跳过变量 JSON 中没有的集合的变量模式"
+"variable values that don't match their type (or composed colours) were skipped" = "已跳过与其类型不符的变量值（或组合颜色）"
+"variables of unknown types were skipped" = "已跳过未知类型的变量"
+"variables whose collection isn't in the variables JSON were skipped" = "已跳过其集合不在变量 JSON 中的变量"
+"variables without readable values were skipped" = "已跳过没有可读值的变量"
+"vector points with unknown stroke joins use the layer join" = "转角未知的矢量点使用图层的转角"
+"vectors without geometry are empty" = "没有几何的矢量为空"
+"vectors without geometry are empty (export the file JSON with geometry=paths)" = "没有几何的矢量为空（使用 geometry=paths 导出文件 JSON）"
+"very long text was cut to 1,048,576 characters" = "过长的文本已截断为 1,048,576 个字符"
+"very long vector paths were skipped" = "已跳过过长的矢量路径"
+"video actions are not supported and were skipped" = "不支持视频操作，已跳过"
+"video triggers are not supported and were skipped" = "不支持视频触发器，已跳过"
 "{instances} in {files}" = "{files} 中的 {instances}"
 "{language}: draft translation, waiting for a native speaker's review." = "{language}：翻译草稿，等待母语者审校。"
 "{length} bleed" = "出血 {length}"
@@ -1453,6 +1605,7 @@ status = "draft — needs native review"
 "{name} is forgotten on this computer; the file stays on {server}" = "已在这台电脑上忘记 {name}；文件仍保留在 {server} 上"
 "{name} is on the server." = "{name} 已在服务器上。"
 "{name} is spotlighting" = "{name} 正在聚焦"
+"{name} is too large to open in the browser (over 512 MB)." = "{name} 太大，无法在浏览器中打开（超过 512 MB）。"
 "{name}\nClick to apply to the selection" = "{name}\n点击应用于所选项"
 "{name}\nDrag onto the canvas, or click to place in the middle of the view.\nHold Alt (Option) while dropping onto an instance to swap it." = "{name}\n拖到画布上，或点击放置在视图中央。\n拖放到实例上时按住 Alt（Option）可替换该实例。"
 "{name} (from {library})" = "{name}（来自 {library}）"
@@ -1488,6 +1641,7 @@ status = "draft — needs native review"
 "{n} matches" = { other = "{n} 个匹配项" }
 "{n} minutes ago" = { other = "{n} 分钟前" }
 "{n} months ago" = { other = "{n} 个月前" }
+"{n} more notes omitted from this report" = { other = "另有 {n} 条说明未列入此报告" }
 "{n} of {total}" = "第 {n} 个，共 {total} 个"
 "{n} people joined" = { other = "{n} 人已加入" }
 "{n} preferred components" = { other = "{n} 个首选组件" }
@@ -1547,7 +1701,17 @@ status = "draft — needs native review"
 "arrange.packH" = "水平紧凑排列"
 "arrange.packV" = "垂直紧凑排列"
 "arrange.roundToPixels" = "取整到像素"
+"arrange.spacing" = "间距"
 "arrange.tidy" = "整理"
+"board.connector" = "连接线"
+"board.ink" = "马克笔笔画"
+"board.label" = "连接线标签"
+"board.nextSticky" = "下一张便利贴"
+"board.setColor" = "白板颜色"
+"board.setStyle" = "白板样式"
+"board.shape" = "带文字的形状"
+"board.stamp" = "印章"
+"board.sticky" = "便利贴"
 "bool.exclude" = "排除所选项"
 "bool.flatten" = "拼合布尔组"
 "bool.intersect" = "所选项相交"
@@ -1646,6 +1810,7 @@ status = "draft — needs native review"
 "edit.duplicate" = "创建副本"
 "edit.findReplace" = "查找和替换"
 "edit.paste" = "粘贴"
+"edit.pasteDesignLayers" = "粘贴设计图层"
 "edit.pasteOver" = "粘贴到所选项上方"
 "edit.pasteProperties" = "粘贴属性"
 "edit.pasteReplace" = "粘贴以替换"
@@ -1669,7 +1834,9 @@ status = "draft — needs native review"
 "file.exportLayers" = "导出图层"
 "file.exportSvg" = "将所选项导出为 SVG"
 "file.import" = "导入"
+"file.moveTab" = "移动标签页"
 "file.new" = "新建设计文件"
+"file.newBoard" = "新建白板"
 "file.open" = "打开"
 "file.openRecent" = "打开最近的文件"
 "file.placeImage" = "置入图片"
@@ -1806,6 +1973,7 @@ status = "draft — needs native review"
 "pref.reduceMotion" = "减少动态效果"
 "pref.renameDuplicates" = "重命名副本图层"
 "pref.showDimensions" = "在对象上显示尺寸"
+"pref.startOnHome" = "启动时显示主页"
 "pref.userName" = "评论中显示的名字"
 "proto.action.add" = "添加原型操作"
 "proto.action.move" = "调整原型操作顺序"
@@ -1849,6 +2017,10 @@ status = "draft — needs native review"
 "select.sameStroke" = "选择相同描边"
 "select.sameText" = "选择相同文本属性"
 "select.set" = "选择"
+"selection.applyColorStyle" = "将颜色样式应用于所选项"
+"selection.colors" = "所选项颜色"
+"selection.selectColor" = "选择使用此颜色的图层"
+"selection.setPaint" = "更改所选项颜色"
 "shape.arrow" = "箭头"
 "shape.ellipse" = "椭圆"
 "shape.line" = "直线"
@@ -1928,10 +2100,14 @@ status = "draft — needs native review"
 "text.weightUp" = "增大字重"
 "tool.arrow" = "箭头"
 "tool.comment" = "评论"
+"tool.connector" = "连接线"
 "tool.ellipse" = "椭圆"
+"tool.eraser" = "橡皮擦"
 "tool.frame" = "画框"
 "tool.hand" = "抓手"
+"tool.highlighter" = "荧光笔"
 "tool.line" = "直线"
+"tool.marker" = "马克笔"
 "tool.move" = "移动"
 "tool.pen" = "钢笔"
 "tool.pencil" = "铅笔"
@@ -1943,9 +2119,12 @@ status = "draft — needs native review"
 "tool.scaleAnchor" = "缩放锚点"
 "tool.section" = "分区"
 "tool.set" = "选择工具"
+"tool.shape" = "形状"
 "tool.shapeBuilder" = "形状生成器"
 "tool.slice" = "切片"
+"tool.stamp" = "印章"
 "tool.star" = "星形"
+"tool.sticky" = "便利贴"
 "tool.text" = "文本"
 "transform.move" = "移动"
 "transform.moveTo" = "移动到"
@@ -2007,11 +2186,13 @@ status = "draft — needs native review"
 "vector.edit.tool" = "矢量编辑工具"
 "vector.edit.transform" = "变换点"
 "vector.edit.widthPoint" = "宽度点"
+"vector.fillRule" = "设置填充规则"
 "vector.flatten" = "拼合"
 "vector.join" = "连接所选项"
 "vector.offset" = "偏移路径"
 "vector.outlineStroke" = "轮廓化描边"
 "vector.reverse" = "反转路径方向"
+"vector.reverseLoop" = "反转环"
 "vector.simplify" = "简化矢量"
 "vector.smoothJoin" = "平滑连接所选项"
 "version.autosave" = "自动保存版本"
diff --git a/crates/ui-egui/src/a11y.rs b/crates/ui-egui/src/a11y.rs
index 824defd41..5fc098a47 100644
--- a/crates/ui-egui/src/a11y.rs
+++ b/crates/ui-egui/src/a11y.rs
@@ -942,10 +942,11 @@ pub fn menu_item(resp: &Response, label: &str, trail: &str, checked: Option<bool
 }
 
 /// A menu item opening a submenu.
-pub fn submenu(resp: &Response, label: &str) {
+pub fn submenu(resp: &Response, label: &str, open: bool) {
     node(resp, label, |n| {
         n.set_role(Role::MenuItem);
         n.set_has_popup(accesskit::HasPopup::Menu);
+        n.set_expanded(open);
     });
 }
 
diff --git a/crates/ui-egui/src/assets_panel.rs b/crates/ui-egui/src/assets_panel.rs
index f8ea18e03..36636c3de 100644
--- a/crates/ui-egui/src/assets_panel.rs
+++ b/crates/ui-egui/src/assets_panel.rs
@@ -316,7 +316,7 @@ fn search_row(app: &mut FigApp, ui: &mut Ui, w: f32) -> String {
     );
     crate::widgets::select_all_on_focus(ui, &r, &filter);
     if r.has_focus() {
-        ui.painter().rect_stroke(field, CornerRadius::same(5), Stroke::new(1.0, t.accent), egui::StrokeKind::Inside);
+        ui.painter().rect_stroke(field, CornerRadius::same(5), Stroke::new(1.0, crate::theme::ACCENT), egui::StrokeKind::Inside);
         if ui.input(|i| i.key_pressed(egui::Key::Escape)) {
             filter.clear();
         }
diff --git a/crates/ui-egui/src/async_dialog_tests.rs b/crates/ui-egui/src/async_dialog_tests.rs
index 26808fe5d..f38ac8242 100644
--- a/crates/ui-egui/src/async_dialog_tests.rs
+++ b/crates/ui-egui/src/async_dialog_tests.rs
@@ -2,7 +2,7 @@ use std::path::PathBuf;
 
 use figcraft_engine::Session;
 
-use crate::{DialogFuture, FigApp, Services};
+use crate::{ContentsFuture, DialogFuture, FigApp, Services};
 
 struct OpenFile(PathBuf);
 
@@ -79,6 +79,74 @@ fn save_as_saves_the_file_it_was_opened_for_after_another_tab_comes_to_the_front
     let _ = std::fs::remove_dir_all(dir);
 }
 
+/// The browser: the picker hands over a file's name and contents, never a path.
+struct Contents(&'static str, Vec<u8>);
+
+impl Services for Contents {
+    fn pick_open(&mut self, _title: &str, _exts: &[&str]) -> DialogFuture {
+        panic!("a platform that picks contents is never asked for a path")
+    }
+    fn pick_open_contents(&mut self, _title: &str, _exts: &[&str]) -> Option<ContentsFuture> {
+        Some(Box::pin(std::future::ready(Some(Ok((self.0.to_string(), self.1.clone()))))))
+    }
+}
+
+/// The browser, with a picked file it won't read.
+struct Unreadable(String);
+
+impl Services for Unreadable {
+    fn pick_open_contents(&mut self, _title: &str, _exts: &[&str]) -> Option<ContentsFuture> {
+        Some(Box::pin(std::future::ready(Some(Err(self.0.clone())))))
+    }
+}
+
+#[test]
+fn a_picked_file_that_cannot_be_read_says_why_and_opens_nothing() {
+    let why = crate::browser_can_read("Huge.fig", 600.0 * 1024.0 * 1024.0).unwrap_err();
+    let mut app = FigApp::new(Session::empty(), Box::new(Unreadable(why.clone())));
+    app.open_dialog();
+    app.poll_dialog(&egui::Context::default());
+    assert!(app.session.docs.is_empty());
+    assert_eq!(app.ui.last_error.as_deref(), Some(why.as_str()));
+    assert!(why.contains("Huge.fig"), "{why}");
+}
+
+#[test]
+fn the_browser_reads_files_up_to_512_mib() {
+    let max = (512u64 << 20) as f64;
+    assert!(crate::browser_can_read("a", 0.0).is_ok());
+    assert!(crate::browser_can_read("a", max).is_ok());
+    assert!(crate::browser_can_read("a", max + 1.0).is_err());
+    assert!(crate::browser_can_read("a", f64::NAN).is_err());
+    assert!(crate::browser_can_read("a", f64::INFINITY).is_err());
+}
+
+#[test]
+fn open_dialog_opens_picked_contents_as_a_new_unsaved_document() {
+    let bytes = figcraft_format::save_bytes(&figcraft_doc::Document::new("Picked"), None).unwrap();
+    let mut app = FigApp::new(Session::empty(), Box::new(Contents("Picked.figcraft", bytes)));
+    app.ui.home = true;
+    app.open_dialog();
+    assert!(app.session.docs.is_empty(), "opening waits for the picker result");
+    app.poll_dialog(&egui::Context::default());
+    assert_eq!(app.session.docs.len(), 1);
+    assert_eq!(app.session.docs[0].path, None, "no path to save over");
+    assert_eq!(app.session.docs[0].doc.name, "Picked");
+    assert!(!app.ui.home, "and the editor shows it");
+}
+
+#[test]
+fn import_dialog_imports_picked_contents_into_the_file_in_front() {
+    let svg = br#"<svg xmlns="http://www.w3.org/2000/svg" width="40" height="20"><rect width="40" height="20" fill="red"/></svg>"#.to_vec();
+    let mut app = FigApp::new(Session::new(), Box::new(Contents("Logo.svg", svg)));
+    let rectangles = |app: &FigApp| app.session.doc().unwrap().nodes().filter(|n| matches!(n.kind, figcraft_doc::NodeKind::Rectangle)).count();
+    assert_eq!(rectangles(&app), 0);
+    app.import_dialog(false);
+    app.poll_dialog(&egui::Context::default());
+    assert_eq!(app.session.docs.len(), 1, "imported, not opened");
+    assert_eq!(rectangles(&app), 1, "the SVG's content");
+}
+
 #[test]
 fn a_dialog_whose_file_closed_meanwhile_does_nothing() {
     let (mut app, dir, path) = two_files("closed");
diff --git a/crates/ui-egui/src/bidi.rs b/crates/ui-egui/src/bidi.rs
index 915c7e115..58c5df933 100644
--- a/crates/ui-egui/src/bidi.rs
+++ b/crates/ui-egui/src/bidi.rs
@@ -274,8 +274,9 @@ fn word_at(text: &str, i: usize) -> (usize, usize) {
     (a, b)
 }
 
-/// Faces the UI adds for scripts its own fonts lack (desktop: from the system), as egui font data.
-pub fn script_fallbacks(have: &dyn Fn(char) -> bool) -> Vec<(String, egui::FontData)> {
+/// Faces the UI adds for scripts its own fonts lack (desktop: from the system), as egui font data;
+/// `taken` as for [`crate::theme::system_fallbacks`].
+pub fn script_fallbacks(have: &dyn Fn(char) -> bool, taken: &mut Vec<Arc<figcraft_text::Face>>) -> Vec<(String, egui::FontData)> {
     // Hebrew, Arabic letters, Arabic presentation forms (what joined names are drawn with).
     const SAMPLES: [char; 3] = ['\u{05D0}', '\u{0628}', '\u{FE91}'];
     const FAMILIES: [&str; 11] = [
@@ -291,17 +292,7 @@ pub fn script_fallbacks(have: &dyn Fn(char) -> bool) -> Vec<(String, egui::FontD
         "FreeSans",
         "Noto Sans",
     ];
-    let mut out: Vec<(String, egui::FontData)> = Vec::new();
-    let mut taken: Vec<Arc<figcraft_text::Face>> = Vec::new();
-    for c in SAMPLES {
-        if have(c) || taken.iter().any(|f| f.has_char(c)) {
-            continue;
-        }
-        let Some(face) = figcraft_text::face_with_char(c, &FAMILIES) else { continue };
-        out.push((format!("system-{}-{}", face.family, face.style), crate::theme::font_data(&face)));
-        taken.push(face);
-    }
-    out
+    crate::theme::system_fallbacks(SAMPLES, &FAMILIES, have, taken)
 }
 
 #[cfg(test)]
diff --git a/crates/ui-egui/src/board_bar.rs b/crates/ui-egui/src/board_bar.rs
new file mode 100644
index 000000000..c312ddb95
--- /dev/null
+++ b/crates/ui-egui/src/board_bar.rs
@@ -0,0 +1,294 @@
+//! Boards in the UI: the small bar floating over a board's selection (colour, shape, text size,
+//! connector style; boards hide the Design panel until asked for), and the swatches it and the
+//! board tools' flyouts share.
+
+use egui::{Color32, CornerRadius, Pos2, Rect, Sense, Stroke, StrokeKind, Ui, pos2, vec2};
+use figcraft_doc::{BOARD_COLORS, BoardItem, BoardShape, NodeKind, Routing, Stamp, StrokeCap};
+use figcraft_engine::board::{BoardTool, TEXT_SIZES};
+use serde_json::{Value, json};
+
+use crate::FigApp;
+use crate::a11y;
+use crate::i18n::{tr, tr_noop};
+use crate::icons::{self, Icon};
+use crate::theme::{Tokens, semibold};
+use crate::toolbar::Options;
+
+/// What a swatch shows.
+pub(crate) enum Mark {
+    Color(figcraft_color::Color),
+    Shape(BoardShape),
+    Stamp(Stamp),
+}
+
+/// One choice of a board tool's flyout: its name, the tool's params, whether it is the tool's now.
+pub(crate) struct Choice {
+    pub label: &'static str,
+    pub params: Value,
+    pub on: bool,
+    pub mark: Mark,
+}
+
+/// The choices a board tool's flyout offers.
+pub(crate) fn choices(options: Options, board: &BoardTool) -> Vec<Choice> {
+    match options {
+        Options::Colors => BOARD_COLORS
+            .iter()
+            .map(|(n, c)| Choice { label: color_label(n), params: json!({"color": n}), on: board.sticky == *c, mark: Mark::Color(*c) })
+            .collect(),
+        Options::Shapes => BoardShape::ALL
+            .iter()
+            .map(|b| Choice { label: b.label(), params: json!({"shape": b.id()}), on: board.shape == *b, mark: Mark::Shape(*b) })
+            .collect(),
+        Options::Stamps => Stamp::ALL
+            .iter()
+            .map(|b| Choice { label: b.label(), params: json!({"stamp": b.id()}), on: board.stamp == *b, mark: Mark::Stamp(*b) })
+            .collect(),
+        Options::None => Vec::new(),
+    }
+}
+
+/// A board colour's name as the UI says it.
+fn color_label(name: &str) -> &'static str {
+    match name {
+        "yellow" => tr_noop("Yellow"),
+        "orange" => tr_noop("Orange"),
+        "red" => tr_noop("Red"),
+        "pink" => tr_noop("Pink"),
+        "violet" => tr_noop("Violet"),
+        "blue" => tr_noop("Blue"),
+        "green" => tr_noop("Green"),
+        _ => tr_noop("Gray"),
+    }
+}
+
+/// Paint `mark` in `r`: a colour chip, a shape's outline in `ink`, or a stamp badge.
+pub(crate) fn paint_choice(p: &egui::Painter, r: Rect, mark: &Mark, ink: Color32) {
+    match mark {
+        Mark::Color(c) => {
+            p.rect_filled(r, CornerRadius::same(4), c32(*c));
+            p.rect_stroke(r, CornerRadius::same(4), Stroke::new(1.0, Color32::from_black_alpha(40)), StrokeKind::Inside);
+        }
+        Mark::Shape(s) => {
+            let path = s.path(14.0, 14.0);
+            let path = figcraft_geom::Affine::translate((1.0, 1.0)) * path;
+            icons::paint_outlines(p, r, 16.0, &[(&path, false)], ink, 1.2);
+        }
+        Mark::Stamp(s) => {
+            p.circle_filled(r.center(), r.width().min(r.height()) / 2.0, c32(s.color()));
+            let parts: Vec<(figcraft_geom::BezPath, bool)> =
+                s.mark().iter().filter_map(|m| figcraft_geom::BezPath::from_svg(m.d).ok().map(|b| (b, m.filled))).collect();
+            let refs: Vec<(&figcraft_geom::BezPath, bool)> = parts.iter().map(|(b, f)| (b, *f)).collect();
+            icons::paint_outlines(p, r, figcraft_doc::STAMP_SIZE, &refs, Color32::WHITE, 3.0);
+        }
+    }
+}
+
+fn c32(c: figcraft_color::Color) -> Color32 {
+    let [r, g, b, a] = c.to_rgba8();
+    Color32::from_rgba_unmultiplied(r, g, b, a)
+}
+
+/// What the selection has that the bar can change.
+#[derive(Default)]
+struct Has {
+    color: bool,
+    shape: Option<BoardShape>,
+    text: bool,
+    connector: Option<(Routing, bool)>,
+}
+
+/// What the selected board objects take from the bar (layers that aren't board objects, a section
+/// say, are left out); `None` when none takes anything.
+fn has(app: &FigApp) -> Option<Has> {
+    let ds = app.session.ds().ok()?;
+    let mut h = Has::default();
+    for n in ds.selection.iter().filter_map(|id| ds.doc.node(*id)) {
+        match &n.board {
+            Some(BoardItem::Sticky { .. } | BoardItem::Ink) => h.color = true,
+            Some(BoardItem::Shape { shape }) => {
+                h.color = true;
+                h.text = true;
+                h.shape = Some(*shape);
+            }
+            Some(BoardItem::Connector(c)) => {
+                h.color = true;
+                h.connector = Some((c.routing, n.stroke.cap_end != StrokeCap::None));
+            }
+            Some(BoardItem::Label { .. }) => h.text = true,
+            Some(BoardItem::Stamp { .. }) | None => {}
+        }
+    }
+    (h.color || h.text || h.connector.is_some()).then_some(h)
+}
+
+const CELL: f32 = 28.0;
+const SWATCH: f32 = 20.0;
+const GAP: f32 = 4.0;
+/// The room each part takes after its controls (the divider and the gap around it).
+const PART_END: f32 = 8.0;
+
+impl Has {
+    /// The bar's width for these parts.
+    fn width(&self) -> f32 {
+        let mut w = 8.0;
+        if self.color {
+            w += BOARD_COLORS.len() as f32 * (SWATCH + GAP) + PART_END;
+        }
+        if self.shape.is_some() {
+            w += CELL + 12.0 + GAP + PART_END;
+        }
+        if self.text {
+            w += TEXT_SIZES.len() as f32 * (CELL + 2.0) + PART_END;
+        }
+        if self.connector.is_some() {
+            w += 3.0 * (CELL + 2.0) + PART_END;
+        }
+        w
+    }
+}
+
+/// Where a bar `size` big goes for the selection's screen box `sel`: centred above it, below it
+/// when there is no room above, inside the canvas.
+pub(crate) fn place(sel: Rect, size: egui::Vec2, canvas: Rect) -> Pos2 {
+    let w = size.x;
+    let cx = sel.center().x.clamp(canvas.min.x + w / 2.0 + 8.0, (canvas.max.x - w / 2.0 - 8.0).max(canvas.min.x + w / 2.0 + 8.0));
+    let above = sel.min.y - 14.0 - size.y;
+    let y = if above > canvas.min.y + 8.0 { above } else { (sel.max.y + 14.0).min(canvas.max.y - size.y - 80.0) };
+    pos2(cx - w / 2.0, y)
+}
+
+/// The bar above a board's selection, while nothing is being dragged and the file can be edited.
+pub fn show(app: &mut FigApp, ctx: &egui::Context) {
+    let editable = app.session.active_read_only().is_none();
+    if app.session.tool.busy() || !editable || !app.session.doc().is_ok_and(figcraft_engine::board::is_board) {
+        return;
+    }
+    let Some(h) = has(app) else { return };
+    let Some(b) = app.session.ds().ok().and_then(|ds| ds.doc.bounds_of(&ds.selection)) else { return };
+    let sel = Rect::from_two_pos(app.to_screen(b.x0, b.y0), app.to_screen(b.x1, b.y1));
+    let size = vec2(h.width(), 40.0);
+    let at = place(sel, size, app.canvas.rect);
+    let t = Tokens::get(ctx);
+    egui::Area::new(egui::Id::new("board_bar")).fixed_pos(at).order(egui::Order::Middle).show(ctx, |ui| {
+        let (rect, _) = ui.allocate_exact_size(size, Sense::click());
+        a11y::container_bounds(ui, rect);
+        let p = ui.painter();
+        p.rect_filled(rect.expand(2.0).translate(vec2(0.0, 1.0)), CornerRadius::same(12), Color32::from_black_alpha(18));
+        p.rect_filled(rect, CornerRadius::same(10), t.panel);
+        p.rect_stroke(rect, CornerRadius::same(10), Stroke::new(1.0, t.border), StrokeKind::Inside);
+        let cy = rect.center().y;
+        let mut x = rect.min.x + 8.0;
+        if h.color {
+            x = color_part(app, ui, x, cy, &t);
+        }
+        if let Some(shape) = h.shape {
+            x = shape_part(app, ui, shape, pos2(x, cy), &t);
+        }
+        if h.text {
+            x = size_part(app, ui, x, cy, &t);
+        }
+        if let Some((routing, arrow)) = h.connector {
+            line_part(app, ui, (routing, arrow), pos2(x, cy), &t);
+        }
+    });
+}
+
+/// The board colours from `x` (`board.setColor`); where the next part starts.
+fn color_part(app: &mut FigApp, ui: &mut Ui, mut x: f32, cy: f32, t: &Tokens) -> f32 {
+    for (i, (name, c)) in BOARD_COLORS.iter().enumerate() {
+        let r = Rect::from_center_size(pos2(x + SWATCH / 2.0, cy), vec2(SWATCH, SWATCH));
+        let resp = ui.interact(r, ui.id().with(("bb_color", i)), Sense::click()).on_hover_text(tr(color_label(name)));
+        a11y::button(&resp, tr(color_label(name)));
+        if resp.hovered() {
+            ui.painter().rect_filled(r.expand(2.0), CornerRadius::same(6), t.hover);
+        }
+        paint_choice(ui.painter(), r, &Mark::Color(*c), t.icon);
+        if resp.clicked() {
+            app.run("board.setColor", json!({"color": name}));
+        }
+        x += SWATCH + GAP;
+    }
+    divider(ui, t, x, cy)
+}
+
+/// The shape menu at `at` (its left edge and middle), showing `shape`; where the next part starts.
+fn shape_part(app: &mut FigApp, ui: &mut Ui, shape: BoardShape, at: Pos2, t: &Tokens) -> f32 {
+    let r = Rect::from_min_size(pos2(at.x, at.y - CELL / 2.0), vec2(CELL + 12.0, CELL));
+    let resp = ui.interact(r, ui.id().with("bb_shape"), Sense::click()).on_hover_text(tr("Shape"));
+    a11y::menu_button(&resp, tr("Shape"), a11y::menu_open(&resp));
+    if resp.hovered() {
+        ui.painter().rect_filled(r, CornerRadius::same(5), t.hover);
+    }
+    paint_choice(ui.painter(), Rect::from_center_size(pos2(r.min.x + CELL / 2.0, at.y), vec2(18.0, 18.0)), &Mark::Shape(shape), t.icon);
+    icons::paint(ui.painter(), Rect::from_center_size(pos2(r.max.x - 7.0, at.y), vec2(12.0, 12.0)), Icon::Chevron, t.icon_secondary);
+    crate::right::menu_popup(&resp).show(|ui| {
+        for b in BoardShape::ALL {
+            let art = |p: &egui::Painter, row: Rect, ink: Color32| {
+                paint_choice(p, Rect::from_center_size(pos2(row.max.x - 16.0, row.center().y), vec2(16.0, 16.0)), &Mark::Shape(b), ink)
+            };
+            if crate::right::menu_item_with(ui, tr(b.label()), "", 24.0, art) {
+                app.run("board.setStyle", json!({"shape": b.id()}));
+                ui.close();
+            }
+        }
+    });
+    divider(ui, t, at.x + CELL + 12.0 + GAP, at.y)
+}
+
+/// The text sizes from `x` (`board.setStyle {fontSize}`); where the next part starts.
+fn size_part(app: &mut FigApp, ui: &mut Ui, mut x: f32, cy: f32, t: &Tokens) -> f32 {
+    for (label, size) in TEXT_SIZES {
+        let r = Rect::from_center_size(pos2(x + CELL / 2.0, cy), vec2(CELL, CELL));
+        let resp = ui.interact(r, ui.id().with(("bb_size", label)), Sense::click()).on_hover_text(tr("Text size"));
+        a11y::button(&resp, &format!("{} {label}", tr("Text size")));
+        if resp.hovered() {
+            ui.painter().rect_filled(r, CornerRadius::same(5), t.hover);
+        }
+        ui.painter().text(r.center(), egui::Align2::CENTER_CENTER, label, semibold(11.0), t.text);
+        if resp.clicked() {
+            app.run("board.setStyle", json!({"fontSize": size}));
+        }
+        x += CELL + 2.0;
+    }
+    divider(ui, t, x, cy)
+}
+
+/// A connector's routing (straight, elbow) and end arrow at `at`, as they are now (`line`).
+fn line_part(app: &mut FigApp, ui: &mut Ui, line: (Routing, bool), at: Pos2, t: &Tokens) {
+    let (routing, arrow) = line;
+    let cells = [
+        (Icon::Line, tr("Straight"), routing == Routing::Straight, json!({"style": "straight"})),
+        (Icon::Connector, tr("Elbow"), routing == Routing::Elbow, json!({"style": "elbow"})),
+        (Icon::Arrow, tr("Arrow at the end"), arrow, json!({"endCap": if arrow { "none" } else { "triangleArrow" }})),
+    ];
+    let mut x = at.x;
+    for (i, (icon, tip, on, params)) in cells.into_iter().enumerate() {
+        let r = Rect::from_center_size(pos2(x + CELL / 2.0, at.y), vec2(CELL, CELL));
+        if crate::toolbar::tool_cell(ui, t, r, ("bb_line", i), icon, on, tip).clicked() {
+            app.run("board.setStyle", params);
+        }
+        x += CELL + 2.0;
+    }
+}
+
+/// A thin separator after `x`; where the next part starts.
+fn divider(ui: &Ui, t: &Tokens, x: f32, cy: f32) -> f32 {
+    ui.painter().line_segment([pos2(x + 2.0, cy - 10.0), pos2(x + 2.0, cy + 10.0)], Stroke::new(1.0, t.border));
+    x + 8.0
+}
+
+/// The name of the person who placed the stamp under the pointer, beside it.
+pub fn stamp_author(app: &FigApp, painter: &egui::Painter, pointer: Option<Pos2>) {
+    let (Some(at), Ok(ds)) = (pointer, app.session.ds()) else { return };
+    let Some(n) = ds.hover.and_then(|h| ds.doc.node(h)) else { return };
+    let Some(BoardItem::Stamp { author, .. }) = &n.board else { return };
+    if author.is_empty() || !matches!(n.kind, NodeKind::Frame) {
+        return;
+    }
+    let t = Tokens::get(painter.ctx());
+    let galley = painter.layout_no_wrap(author.clone(), semibold(11.0), t.text);
+    let r = Rect::from_min_size(at + vec2(14.0, 14.0), galley.size() + vec2(12.0, 6.0));
+    painter.rect_filled(r, CornerRadius::same(4), t.menu);
+    painter.galley(r.min + vec2(6.0, 3.0), galley, t.menu_text);
+}
diff --git a/crates/ui-egui/src/board_ui_tests.rs b/crates/ui-egui/src/board_ui_tests.rs
new file mode 100644
index 000000000..4ffb3cf4e
--- /dev/null
+++ b/crates/ui-egui/src/board_ui_tests.rs
@@ -0,0 +1,212 @@
+//! Boards in the UI, drawn headless: the board toolbar (its flyouts pick a tool with a colour, a
+//! shape or a stamp; the Design panel's button), the right panel hidden until asked for, the bar
+//! over the selection (colours, shapes, text sizes, connector style, also with layers that aren't
+//! board objects selected, never on a file you can only view), the home screen's New board card,
+//! and the marks design files and boards get.
+
+use egui::{Event, Modifiers, PointerButton, Pos2, Rect, pos2};
+use figcraft_doc::{BoardItem, BoardShape, FileKind, NodeId, Routing, Stamp, StrokeCap, board_color};
+use figcraft_engine::Session;
+use figcraft_engine::tools::ToolId;
+use serde_json::{Value, json};
+
+use crate::layers_drag_tests::Ui;
+use crate::live_tests::{flat, has_text, text_center};
+
+fn click(u: &mut Ui, p: Pos2) {
+    for pressed in [true, false] {
+        u.frame(vec![Event::PointerMoved(p), Event::PointerButton { pos: p, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE }]);
+    }
+    u.frame(vec![]);
+}
+
+fn id(v: &Value) -> NodeId {
+    NodeId(v["id"].as_u64().unwrap())
+}
+
+/// The app on a new board.
+fn board() -> Ui {
+    let mut s = Session::new();
+    s.execute("file.newBoard", &json!({})).unwrap();
+    let mut u = Ui::new(s);
+    u.frame(vec![]);
+    u
+}
+
+/// The board toolbar pill on screen.
+fn pill(u: &Ui) -> Rect {
+    crate::toolbar::pill_rect(u.app.canvas.rect, crate::toolbar::bar_width(&u.app))
+}
+
+/// The left edge of board toolbar group `i` (button 32 wide, a 10-wide caret after the groups with
+/// flyouts, 4 between): move, ink, sticky, shapes, connector, text, section, stamp, comment.
+fn group_x(u: &Ui, i: usize) -> f32 {
+    const WIDTHS: [f32; 9] = [46.0, 46.0, 46.0, 46.0, 36.0, 36.0, 36.0, 46.0, 36.0];
+    pill(u).min.x + 8.0 + WIDTHS.iter().take(i).sum::<f32>()
+}
+
+/// Open group `i`'s flyout from its caret and click option `n` in it (a row of 32-wide cells, 4
+/// apart, 8 in from the flyout's edge, the flyout's bottom 8 above the pill).
+fn pick_option(u: &mut Ui, i: usize, n: usize) {
+    let caret = pos2(group_x(u, i) + 37.0, pill(u).center().y);
+    click(u, caret);
+    let at = pos2(group_x(u, i) + 8.0 + n as f32 * 36.0 + 16.0, pill(u).min.y - 8.0 - 24.0);
+    click(u, at);
+}
+
+/// Whether the bar over the selection showed in the last frame.
+fn bar_shown(ctx: &egui::Context) -> bool {
+    ctx.memory(|m| m.areas().visible_last_frame(&egui::LayerId::new(egui::Order::Middle, egui::Id::new("board_bar"))))
+}
+
+/// The bar over the selection, when it shows.
+fn bar(u: &Ui) -> Option<Rect> {
+    bar_shown(&u.ctx).then(|| u.ctx.memory(|m| m.area_rect(egui::Id::new("board_bar")))).flatten()
+}
+
+#[test]
+fn the_board_toolbar_picks_tools_with_their_colours_shapes_and_stamps() {
+    let mut u = board();
+    pick_option(&mut u, 2, 5);
+    assert_eq!(u.app.session.tool.tool, ToolId::Sticky);
+    assert_eq!(Some(u.app.session.tool.board.sticky), board_color("blue"));
+    pick_option(&mut u, 3, 3);
+    assert_eq!((u.app.session.tool.tool, u.app.session.tool.board.shape), (ToolId::BoardShape, BoardShape::Diamond));
+    pick_option(&mut u, 7, 1);
+    assert_eq!((u.app.session.tool.tool, u.app.session.tool.board.stamp), (ToolId::Stamp, Stamp::Heart));
+    // The connector's button picks it; the ink group's flyout lists the marker's siblings.
+    let connector = pos2(group_x(&u, 4) + 16.0, pill(&u).center().y);
+    click(&mut u, connector);
+    assert_eq!(u.app.session.tool.tool, ToolId::Connector);
+    let ink_caret = pos2(group_x(&u, 1) + 37.0, pill(&u).center().y);
+    click(&mut u, ink_caret);
+    assert_eq!(u.app.ui.tool_flyout, Some("ink"));
+}
+
+#[test]
+fn a_boards_design_panel_opens_when_asked_for_and_prototyping_is_not_offered() {
+    let mut u = board();
+    u.app.ui.right_tab = crate::RightTab::Prototype;
+    u.frame(vec![]);
+    assert_eq!(u.app.ui.right_tab, crate::RightTab::Design, "boards have no Prototype tab");
+    let canvas = u.app.canvas.rect;
+    assert!(canvas.max.x > 1400.0, "no right panel: the canvas reaches the window's edge ({canvas:?})");
+    // The Design panel's button at the pill's right end.
+    let p = pill(&u);
+    click(&mut u, pos2(p.max.x - 8.0 - 16.0, p.center().y));
+    assert!(u.app.ui.board_panel);
+    u.frame(vec![]);
+    assert!(u.app.canvas.rect.max.x < canvas.max.x - 200.0, "the panel takes its room");
+    // On a design file the panel shows whatever was asked for a board.
+    u.app.run("file.new", json!({}));
+    u.app.run("view.design", json!({}));
+    u.frame(vec![]);
+    assert!(u.app.ui.board_panel, "view.design on a design file doesn't toggle the board's panel");
+}
+
+#[test]
+fn the_selection_bar_recolours_reshapes_and_restyles() {
+    let mut u = board();
+    let shape = id(&u.app.session.execute("board.shape", &json!({"x": 0, "y": 0, "shape": "rectangle", "text": "Hi"})).unwrap());
+    let section = id(&u.app.session.execute("node.create", &json!({"type": "section", "x": 0, "y": 400, "width": 200, "height": 200})).unwrap());
+    // A section selected with it (no board object) leaves the bar for the shape.
+    u.app.session.execute("select.set", &json!({"ids": [shape, section]})).unwrap();
+    u.frame(vec![]);
+    u.frame(vec![]);
+    let r = bar(&u).expect("the bar shows");
+    let cy = r.center().y;
+    // Swatch 5 (blue): 8 in, 24 apart, 20 wide.
+    click(&mut u, pos2(r.min.x + 8.0 + 5.0 * 24.0 + 10.0, cy));
+    let outline = u.app.session.doc().unwrap().node(shape).unwrap().children[0];
+    assert_eq!(u.app.session.doc().unwrap().node(outline).unwrap().fills[0].solid_color(), board_color("blue"));
+    // Text size L: after the colours (208) and the shape menu (52), the third of the 30-wide cells.
+    let r = bar(&u).unwrap();
+    click(&mut u, pos2(r.min.x + 208.0 + 52.0 + 2.0 * 30.0 + 14.0, cy));
+    let text = figcraft_engine::board::text_of(u.app.session.doc().unwrap(), shape).unwrap();
+    assert_eq!(u.app.session.doc().unwrap().node(text).unwrap().kind.text().unwrap().style.font_size, 24.0);
+    // The shape menu lists the outlines.
+    let r = bar(&u).unwrap();
+    click(&mut u, pos2(r.min.x + 208.0 + 20.0, cy));
+    let shapes = flat(&u.frame_output(vec![]).shapes);
+    click(&mut u, text_center(&shapes, "Ellipse"));
+    assert_eq!(u.app.session.doc().unwrap().node(shape).unwrap().board, Some(BoardItem::Shape { shape: BoardShape::Ellipse }));
+}
+
+#[test]
+fn the_selection_bar_sets_a_connectors_style_and_offers_nothing_for_a_stamp() {
+    let mut u = board();
+    let a = u.app.session.execute("board.sticky", &json!({"x": 0, "y": 0})).unwrap()["id"].clone();
+    let b = u.app.session.execute("board.sticky", &json!({"x": 400, "y": 300})).unwrap()["id"].clone();
+    let c = id(&u.app.session.execute("board.connector", &json!({"from": a, "to": b, "style": "elbow"})).unwrap());
+    u.frame(vec![]);
+    u.frame(vec![]);
+    let r = bar(&u).expect("the bar shows for a connector");
+    let cy = r.center().y;
+    // After the colours (208): Straight, Elbow, the end's arrow, 30 apart.
+    click(&mut u, pos2(r.min.x + 208.0 + 14.0, cy));
+    let routing = |u: &Ui| match &u.app.session.doc().unwrap().node(c).unwrap().board {
+        Some(BoardItem::Connector(k)) => k.routing,
+        _ => panic!("not a connector"),
+    };
+    assert_eq!(routing(&u), Routing::Straight);
+    let r = bar(&u).unwrap();
+    click(&mut u, pos2(r.min.x + 208.0 + 60.0 + 14.0, cy));
+    assert_eq!(u.app.session.doc().unwrap().node(c).unwrap().stroke.cap_end, StrokeCap::None);
+    // Nothing is offered while a stamp alone is selected: it takes neither colour nor style.
+    let st = id(&u.app.session.execute("board.stamp", &json!({"x": 900, "y": 0, "stamp": "star"})).unwrap());
+    u.app.session.execute("select.set", &json!({"ids": [st]})).unwrap();
+    u.frame(vec![]);
+    u.frame(vec![]);
+    assert!(bar(&u).is_none());
+}
+
+#[test]
+fn a_board_you_only_view_offers_no_bar() {
+    let (mut h, _) = crate::live_tests::Harness::new();
+    h.app.session.execute("file.newBoard", &json!({})).unwrap();
+    let st = id(&h.app.session.execute("board.sticky", &json!({"x": 0, "y": 0})).unwrap());
+    h.frames(2);
+    assert!(bar_shown(&h.ctx), "the bar shows for the selected sticky");
+    crate::live_server_tests::joined(&mut h, figcraft_engine::live::Access::View);
+    h.app.session.execute("select.set", &json!({"ids": [st]})).unwrap();
+    h.frames(2);
+    assert!(h.app.session.active_read_only().is_some());
+    assert!(!bar_shown(&h.ctx), "view only: nothing to edit");
+}
+
+#[test]
+fn the_home_screen_makes_boards_and_marks_files_by_kind() {
+    let mut u = Ui::new(Session::empty());
+    let shapes = flat(&u.frame_output(vec![]).shapes);
+    click(&mut u, text_center(&shapes, "New board"));
+    assert_eq!(u.app.session.doc().unwrap().kind, FileKind::Board);
+    assert_eq!(crate::icons::file_mark(FileKind::Board), crate::icons::Icon::Board);
+    assert_eq!(crate::icons::file_mark(FileKind::Design), crate::icons::Icon::PenNib);
+}
+
+#[test]
+fn a_stamp_shows_who_placed_it_on_hover() {
+    let mut s = Session::new();
+    s.prefs.user_name = "Grace".into();
+    s.execute("file.newBoard", &json!({})).unwrap();
+    s.execute("board.stamp", &json!({"x": 100, "y": 100, "stamp": "check"})).unwrap();
+    s.execute("select.none", &json!({})).unwrap();
+    let mut u = Ui::new(s);
+    let at = u.app.to_screen(100.0, 100.0);
+    u.frame(vec![Event::PointerMoved(at)]);
+    u.frame(vec![Event::PointerMoved(at + egui::vec2(1.0, 0.0))]);
+    let shapes = flat(&u.frame_output(vec![Event::PointerMoved(at + egui::vec2(1.0, 1.0))]).shapes);
+    assert!(has_text(&shapes, "Grace"), "the placer's name beside the pointer");
+}
+
+#[test]
+fn the_next_sticky_from_the_keyboard_goes_on_typing() {
+    let mut u = board();
+    u.app.run("board.sticky", json!({"x": 0, "y": 0}));
+    // Shift+Cmd/Ctrl+Enter runs it from the menu layer, asking to type in the new one.
+    crate::menus::invoke(&mut u.app, "board.nextSticky");
+    let doc = u.app.session.doc().unwrap();
+    let te = u.app.session.ds().unwrap().text_edit.clone().expect("typing in the new sticky");
+    let owner = figcraft_engine::board::owner_of_text(doc, te.id).unwrap();
+    assert_eq!(doc.node(owner).unwrap().transform.translation().x, 224.0);
+}
diff --git a/crates/ui-egui/src/canvas.rs b/crates/ui-egui/src/canvas.rs
index 82e89798c..0b13f5a8b 100644
--- a/crates/ui-egui/src/canvas.rs
+++ b/crates/ui-egui/src/canvas.rs
@@ -12,7 +12,7 @@ use serde_json::json;
 use crate::FigApp;
 use crate::i18n::{tr, trf, trn};
 use crate::render_worker::{Done, Job, Worker};
-use crate::theme::{ACCENT, COMPONENT, Tokens, doc_c32, regular, semibold};
+use crate::theme::{COMPONENT, Tokens, doc_c32, regular, semibold};
 
 pub struct CanvasState {
     pub rect: Rect,
@@ -183,7 +183,9 @@ pub fn show(app: &mut FigApp, ui: &mut Ui, worker: &mut Worker) {
         }
     }
     let own_cursor = input(app, ui, &resp);
-    crate::drop_overlay(&ctx, ctx.content_rect(), tr("Drop to import"));
+    // A browser names no dragged file until the drop, so documents there still say "import".
+    let documents = ctx.input(|i| i.raw.hovered_files.iter().all(|f| f.path.as_deref().is_some_and(crate::is_document)));
+    crate::drop_overlay(&ctx, ctx.content_rect(), if documents { tr("Drop to open") } else { tr("Drop to import") });
     crate::guides::end_released(&ctx);
     crate::live::track_pointer(app, &ctx);
     app.sync_preedit();
@@ -233,25 +235,30 @@ pub fn show(app: &mut FigApp, ui: &mut Ui, worker: &mut Worker) {
         })
         .unwrap_or(t.canvas);
     painter.rect_filled(rect, CornerRadius::ZERO, bg);
+    crate::theme::set_canvas_page(&ctx, bg);
     if let (Some(tex), Some(v), true) = (&app.canvas.texture, &app.canvas.tex_view, shown.is_some() && app.canvas.tex_of == shown) {
         // Re-project the last render onto the current view.
         let tl = app.to_screen(v.origin.0, v.origin.1);
         let zoom = app.session.ds().map(|d| d.view.zoom).unwrap_or(1.0);
-        let w = (f64::from(v.width) / v.scale * zoom) as f32;
-        let h = (f64::from(v.height) / v.scale * zoom) as f32;
-        painter.image(tex.id(), Rect::from_min_size(tl, vec2(w, h)), Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);
+        let pixel_preview = app.session.ds().ok().and_then(|ds| ds.view.pixel_preview_scale()) == Some(v.scale);
+        let image_rect = presented_image_rect(tl, v, zoom, ppp, pixel_preview);
+        painter.image(tex.id(), image_rect, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);
     }
     app.session.tool.labels = overlays(app, &painter, &t);
+    crate::frame_labels::rename_field(app, ui);
     // The zoom tool's area.
     if let (Some(start), Some(p)) = (app.canvas.zoom_drag, ctx.input(|i| i.pointer.hover_pos())) {
         let area = Rect::from_two_pos(start, p);
         if area.width() > 4.0 || area.height() > 4.0 {
-            painter.rect_filled(area, CornerRadius::ZERO, ACCENT.gamma_multiply(0.1));
-            painter.rect_stroke(area, CornerRadius::ZERO, Stroke::new(1.0, ACCENT), StrokeKind::Inside);
+            painter.rect_filled(area, CornerRadius::ZERO, accent(&painter).gamma_multiply(0.1));
+            painter.rect_stroke(area, CornerRadius::ZERO, Stroke::new(1.0, accent(&painter)), StrokeKind::Inside);
         }
     }
     crate::dev_mode::draw(app, &painter);
     crate::handles::draw(app, &painter);
+    crate::board_bar::stamp_author(app, &painter, ctx.input(|i| i.pointer.hover_pos()).filter(|p| rect.contains(*p)));
+    crate::board_bar::show(app, &ctx);
+    crate::selection_spacing::draw(app, &painter);
     crate::comments::draw(app, &painter);
     crate::live_text::draw(app, &painter);
     crate::live::draw(app, &painter, &ctx);
@@ -271,6 +278,22 @@ pub fn show(app: &mut FigApp, ui: &mut Ui, worker: &mut Worker) {
     }
 }
 
+/// The image's screen rect; align native-density renders to device pixels to avoid linear filtering
+/// blending neighbouring texels. Stale and pixel-preview renders retain their original projection.
+pub(super) fn presented_image_rect(tl: Pos2, view: &figcraft_render::View, zoom: f64, ppp: f32, pixel_preview: bool) -> Rect {
+    let w = (f64::from(view.width) / view.scale * zoom) as f32;
+    let h = (f64::from(view.height) / view.scale * zoom) as f32;
+    let native_density = !pixel_preview
+        && ppp.is_finite()
+        && ppp > 0.0
+        && zoom.is_finite()
+        && view.scale.is_finite()
+        && view.scale > 0.0
+        && (view.scale - zoom * f64::from(ppp)).abs() <= view.scale.abs().max(1.0) * 1e-9;
+    let min = if native_density { pos2((tl.x * ppp).round() / ppp, (tl.y * ppp).round() / ppp) } else { tl };
+    Rect::from_min_size(min, vec2(w, h))
+}
+
 /// What the canvas says to screen readers: the selected layer ("Rectangle 1, Rectangle, 120 by 80,
 /// selected"), how many are selected, or the page with nothing selected.
 pub fn describe(s: &figcraft_engine::Session) -> String {
@@ -472,6 +495,8 @@ fn zoom_tool(app: &mut FigApp, ui: &Ui, resp: &egui::Response, pos: Pos2, mods:
 /// then doesn't show.
 fn input(app: &mut FigApp, ui: &mut Ui, resp: &egui::Response) -> bool {
     if crate::proto_canvas::input(app, ui, resp) {
+        // A prototype gesture is a press on the canvas too: the Pages list gives up the keyboard.
+        app.ui.pages_focus = None;
         return true;
     }
     let ctx = ui.ctx().clone();
@@ -480,27 +505,31 @@ fn input(app: &mut FigApp, ui: &mut Ui, resp: &egui::Response) -> bool {
     let editing_text = app.session.ds().map(|d| d.text_edit.is_some()).unwrap_or(false);
     let typing_elsewhere = crate::a11y::field_focused(&ctx);
     app.canvas.space_pan = space && !editing_text && !typing_elsewhere;
-    // Dropped files import onto the canvas, behind a card while they do ([`crate::pending_open`]).
+    if !app.canvas.dragging && crate::selection_spacing::input(app, &ctx, hover_pos, resp.hovered(), app.canvas.space_pan) {
+        return false;
+    }
+    // Dropped files import onto the canvas, behind a card while they do ([`crate::pending_open`]);
+    // a dropped document opens as a file of its own, as on the home screen.
     let dropped = ctx.input(|i| i.raw.dropped_files.clone());
     for f in dropped {
         let path = f.path().to_path_buf();
+        if crate::is_document(&path) {
+            crate::pending_open::open_dropped(app, &f);
+            continue;
+        }
         let pt = hover_pos.map(|h| app.to_page(h)).unwrap_or_default();
         let name = path.file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_else(|| "dropped.png".into());
-        let params = if path.exists() {
-            json!({"path": path.to_string_lossy(), "x": pt.x, "y": pt.y})
-        } else if let Some(bytes) = crate::dropped_bytes(&f) {
-            use base64::Engine as _;
-            let b64 = base64::engine::general_purpose::STANDARD.encode(&bytes);
-            json!({"data": b64, "name": name, "x": pt.x, "y": pt.y})
+        let (params, read) = if path.exists() {
+            (json!({"path": path.to_string_lossy(), "x": pt.x, "y": pt.y}), None)
         } else {
-            continue;
+            (json!({"name": name, "x": pt.x, "y": pt.y}), Some(crate::dropped_bytes(&f, &name)))
         };
         let Some(target) =
             app.session.ds().ok().map(|doc| crate::pending_open::ImportTarget { uid: doc.uid, page: doc.page, name: doc.doc.name.clone() })
         else {
             continue;
         };
-        app.ui.pending_opens.push(crate::pending_open::PendingOpen { label: name, params, command: "file.import", target: Some(target) });
+        app.ui.pending_opens.push(crate::pending_open::PendingOpen { label: name, params, command: "file.import", target: Some(target), read });
     }
     let Some(pos) = hover_pos.filter(|p| app.canvas.rect.contains(*p)) else {
         // A drag released off the canvas, or off the window, ends where the pointer was last seen.
@@ -523,6 +552,7 @@ fn input(app: &mut FigApp, ui: &mut Ui, resp: &egui::Response) -> bool {
     // A press on the canvas gives the keyboard back to it (arrows nudge again).
     if resp.hovered() && ctx.input(|i| i.pointer.any_pressed()) {
         app.ui.layers_focus = false;
+        app.ui.pages_focus = None;
         app.ui.key_box = None;
     }
     // Zoom (pinch, Cmd/Ctrl+scroll) about the pointer; plain scroll pans.
@@ -788,11 +818,11 @@ fn swap_highlight(app: &FigApp, painter: &egui::Painter, doc: &Document, id: Nod
 }
 
 /// The outline colour for a layer: purple for components, sets and instances and every layer in
-/// them, blue otherwise.
-fn outline_colour(doc: &Document, id: NodeId) -> Color32 {
+/// them, the page's overlay `green` otherwise.
+fn outline_colour(doc: &Document, id: NodeId, green: Color32) -> Color32 {
     use figcraft_engine::components::{owning_component, owning_instance};
     let set = matches!(doc.node(id).map(|n| &n.kind), Some(NodeKind::ComponentSet { .. }));
-    if set || owning_component(doc, id).is_some() || owning_instance(doc, id).is_some() { COMPONENT } else { ACCENT }
+    if set || owning_component(doc, id).is_some() || owning_instance(doc, id).is_some() { COMPONENT } else { green }
 }
 
 /// The outline path of shapes (ellipses, vectors) for hover/selection outlines.
@@ -911,7 +941,8 @@ fn overlays(app: &FigApp, painter: &egui::Painter, t: &Tokens) -> Vec<(NodeId, [
             }
         }
         // The focus view's bar names its frame.
-        let labelled = focus.is_none() && (n.kind.is_frame_like() || matches!(n.kind, NodeKind::Section { .. }));
+        // Board objects (stickies, shapes with text, stamps) are frames without a name label.
+        let labelled = focus.is_none() && (n.kind.is_frame_like() || matches!(n.kind, NodeKind::Section { .. })) && !n.is_board_atom();
         if labelled && let Some(q) = crate::frame_labels::draw(app, painter, t, &doc, *c, sel.contains(c), ds.hover == Some(*c)) {
             labels.push((*c, q.map(|p| app.to_page(p))));
         }
@@ -925,20 +956,20 @@ fn overlays(app: &FigApp, painter: &egui::Painter, t: &Tokens) -> Vec<(NodeId, [
         && app.session.prefs.highlight_on_hover
         && app.session.tool.overlay.measure_box.is_none()
     {
-        draw_outline(app, painter, &doc, h, stroke(outline_colour(&doc, h), 1.5));
+        draw_outline(app, painter, &doc, h, stroke(outline_colour(&doc, h, accent(painter)), 1.5));
     }
     // Inside a boolean group (an operand selected or in vector edit mode): every operand's outline,
     // so the shapes making the live result stay visible while one of them changes.
     let operands = figcraft_engine::booleans::outlined_operands(&doc, &sel, ds.vector_edit.as_ref().map(|ve| ve.id));
     for id in operands.iter().filter(|o| !sel.contains(o)) {
-        draw_outline(app, painter, &doc, *id, stroke(outline_colour(&doc, *id).gamma_multiply(0.6), 1.0));
+        draw_outline(app, painter, &doc, *id, stroke(outline_colour(&doc, *id, accent(painter)).gamma_multiply(0.6), 1.0));
     }
     // Mask outlines (a mask doesn't draw itself), frame outlines and slices, as the View menu shows.
     if view.mask_outlines || view.frame_outlines || view.show_slices {
         for id in doc.subtree(page) {
             let Some(n) = doc.node(id).filter(|n| n.visible) else { continue };
             if view.mask_outlines && n.is_mask {
-                draw_outline(app, painter, &doc, id, stroke(ACCENT, 1.0));
+                draw_outline(app, painter, &doc, id, stroke(accent(painter), 1.0));
             } else if view.frame_outlines && n.kind.is_frame_like() {
                 draw_outline(app, painter, &doc, id, stroke(t.text_secondary, 1.0));
             } else if view.show_slices
@@ -954,20 +985,20 @@ fn overlays(app: &FigApp, painter: &egui::Painter, t: &Tokens) -> Vec<(NodeId, [
     if let Some(d) = ov.drop_target
         && let Some(q) = node_quad(app, &doc, d)
     {
-        quad(painter, q, stroke(if figcraft_engine::components::is_slot(&doc, d) { COMPONENT } else { ACCENT }, 1.0));
+        quad(painter, q, stroke(if figcraft_engine::components::is_slot(&doc, d) { COMPONENT } else { accent(painter) }, 1.0));
     }
     slot_badges(app, painter, &doc, &sel, ov.drop_target);
     if let Some(t) = ov.swap_target {
         swap_highlight(app, painter, &doc, t);
     }
     if let Some([x0, y0, x1, y1]) = ov.insert_line {
-        painter.line_segment([app.to_screen(x0, y0), app.to_screen(x1, y1)], stroke(ACCENT, 2.0));
+        painter.line_segment([app.to_screen(x0, y0), app.to_screen(x1, y1)], stroke(accent(painter), 2.0));
     }
     if let Some([x0, y0, x1, y1]) = ov.drop_cell {
         let r = Rect::from_two_pos(app.to_screen(x0, y0), app.to_screen(x1, y1));
-        painter.rect_filled(r, CornerRadius::same(2), ACCENT.gamma_multiply(0.12));
+        painter.rect_filled(r, CornerRadius::same(2), accent(painter).gamma_multiply(0.12));
         let pts = [r.left_top(), r.right_top(), r.right_bottom(), r.left_bottom(), r.left_top()];
-        painter.add(Shape::dashed_line(&pts, stroke(ACCENT, 1.5), 4.0, 3.0));
+        painter.add(Shape::dashed_line(&pts, stroke(accent(painter), 1.5), 4.0, 3.0));
     }
     // Vector edit mode, with the transform box around several selected points.
     // The selection's size label, which measurement labels keep clear of.
@@ -990,13 +1021,13 @@ fn overlays(app: &FigApp, painter: &egui::Painter, t: &Tokens) -> Vec<(NodeId, [
             width_overlay(app, painter, &doc, &ve, zoom);
         } else if let Some(c) = app.session.vector_edit_box() {
             let label = format!("{} × {}", fmt((c[1] - c[0]).hypot()), fmt((c[3] - c[0]).hypot()));
-            size_label = transform_box(app, painter, c.map(|p| app.to_screen(p.x, p.y)), ACCENT, true, 4, label);
+            size_label = transform_box(app, painter, c.map(|p| app.to_screen(p.x, p.y)), accent(painter), true, 4, Some(label));
         }
     }
     // Selection.
     let editing = ds.text_edit.clone();
     if !sel.is_empty() && editing.is_none() && ds.vector_edit.is_none() {
-        let col = if sel.iter().any(|i| outline_colour(&doc, *i) == COMPONENT) { COMPONENT } else { ACCENT };
+        let col = if sel.iter().any(|i| outline_colour(&doc, *i, accent(painter)) == COMPONENT) { COMPONENT } else { accent(painter) };
         for id in &sel {
             draw_outline(app, painter, &doc, *id, stroke(col, 1.0));
         }
@@ -1014,8 +1045,11 @@ fn overlays(app: &FigApp, painter: &egui::Painter, t: &Tokens) -> Vec<(NodeId, [
             // A layer smaller than its handles on screen shows just its outline (they still answer
             // just outside it).
             let tiny = figcraft_engine::tools::box_sides_px(&b, zoom).1 < figcraft_engine::tools::SMALL_BOX_PX;
-            // Locked layers (selected in the layers panel) can't be resized: no handles either.
-            let handles = if sel.iter().any(|i| figcraft_engine::tools::locked_in(&doc, *i)) {
+            // Measuring to another layer (Alt held) shows just the outlines: no handles or size.
+            let measuring = app.session.tool.overlay.measure_box.is_some();
+            // Locked layers (selected in the layers panel) can't be resized, nor anything in Dev
+            // Mode: no handles either.
+            let handles = if measuring || app.session.tool.dev_mode || sel.iter().any(|i| figcraft_engine::tools::locked_in(&doc, *i)) {
                 0
             } else if is_line {
                 2
@@ -1024,9 +1058,11 @@ fn overlays(app: &FigApp, painter: &egui::Painter, t: &Tokens) -> Vec<(NodeId, [
             } else {
                 4
             };
-            size_label = transform_box(app, painter, b.map(|p| app.to_screen(p.x, p.y)), col, sel.len() > 1, handles, label);
-            arc_overlay(app, painter, col);
-            shape_overlay(app, painter, col);
+            size_label = transform_box(app, painter, b.map(|p| app.to_screen(p.x, p.y)), col, sel.len() > 1, handles, (!measuring).then_some(label));
+            if !measuring {
+                arc_overlay(app, painter, col);
+                shape_overlay(app, painter, col);
+            }
             if app.session.tool.tool == ToolId::Scale {
                 // The point that stays put: the dragged pivot, else the anchor.
                 let pivot = scale
@@ -1065,12 +1101,12 @@ fn overlays(app: &FigApp, painter: &egui::Painter, t: &Tokens) -> Vec<(NodeId, [
     {
         let layout = &text.layout;
         if let Some(q) = node_quad(app, edoc, te.id) {
-            quad(painter, q, stroke(ACCENT, 1.0));
+            quad(painter, q, stroke(accent(painter), 1.0));
         }
         let (a, b) = (te.caret.min(te.anchor), te.caret.max(te.anchor));
         if a != b && preedit.is_none() {
             for q in text.selection(app, a, b) {
-                painter.add(Shape::convex_polygon(q.to_vec(), ACCENT.gamma_multiply(0.3), Stroke::NONE));
+                painter.add(Shape::convex_polygon(q.to_vec(), accent(painter).gamma_multiply(0.3), Stroke::NONE));
             }
         }
         if let Some(p) = preedit {
@@ -1101,21 +1137,23 @@ fn overlays(app: &FigApp, painter: &egui::Painter, t: &Tokens) -> Vec<(NodeId, [
     // Marquee.
     if let Some([x0, y0, x1, y1]) = ov.marquee.or(app.ui.key_box) {
         let r = Rect::from_two_pos(app.to_screen(x0, y0), app.to_screen(x1, y1));
-        painter.rect_filled(r, CornerRadius::ZERO, ACCENT.gamma_multiply(0.1));
-        painter.rect_stroke(r, CornerRadius::ZERO, stroke(ACCENT, 1.0), StrokeKind::Inside);
+        painter.rect_filled(r, CornerRadius::ZERO, accent(painter).gamma_multiply(0.1));
+        painter.rect_stroke(r, CornerRadius::ZERO, stroke(accent(painter), 1.0), StrokeKind::Inside);
     }
     // Pen path.
     if !ov.pen.is_empty() {
         let pts: Vec<Pos2> = ov.pen.iter().map(|[x, y]| app.to_screen(*x, *y)).collect();
         if app.session.tool.tool == ToolId::Pencil {
-            painter.add(Shape::line(pts, stroke(t.text, 2.0)));
+            // The stroke it will make, in its colour and weight (at least a point when zoomed out).
+            let (color, weight) = figcraft_engine::tools::PENCIL_STROKE;
+            painter.add(Shape::line(pts, stroke(doc_c32(painter.ctx(), color), ((weight * zoom) as f32).max(1.0))));
         } else {
             for [x0, y0, x1, y1] in &ov.pen_handles {
                 bezier_handle(painter, app.to_screen(*x0, *y0), app.to_screen(*x1, *y1), 3.5, Color32::WHITE);
             }
             for p in &pts {
                 painter.circle_filled(*p, 3.5, Color32::WHITE);
-                painter.circle_stroke(*p, 3.5, stroke(ACCENT, 1.0));
+                painter.circle_stroke(*p, 3.5, stroke(accent(painter), 1.0));
             }
             if let Some([x0, y0, x1, y1]) = ov.rubber {
                 let (a, b) = (app.to_screen(x0, y0), app.to_screen(x1, y1));
@@ -1127,11 +1165,11 @@ fn overlays(app: &FigApp, painter: &egui::Painter, t: &Tokens) -> Vec<(NodeId, [
                             [a, h, b, b],
                             false,
                             Color32::TRANSPARENT,
-                            stroke(ACCENT, 1.0),
+                            stroke(accent(painter), 1.0),
                         ));
                     }
                     None => {
-                        painter.line_segment([a, b], stroke(ACCENT, 1.0));
+                        painter.line_segment([a, b], stroke(accent(painter), 1.0));
                     }
                 }
             }
@@ -1142,7 +1180,7 @@ fn overlays(app: &FigApp, painter: &egui::Painter, t: &Tokens) -> Vec<(NodeId, [
         let c = app.to_screen(x, y);
         let rs = (r * app.session.ds().map(|d| d.view.zoom).unwrap_or(1.0)) as f32;
         painter.circle_stroke(c, rs, stroke(Color32::WHITE, 3.0));
-        painter.circle_stroke(c, rs, stroke(ACCENT, 1.5));
+        painter.circle_stroke(c, rs, stroke(accent(painter), 1.5));
     }
     // Lasso (vector edit mode).
     if ov.lasso.len() > 1 {
@@ -1150,7 +1188,7 @@ fn overlays(app: &FigApp, painter: &egui::Painter, t: &Tokens) -> Vec<(NodeId, [
         if let Some(first) = pts.first().copied() {
             pts.push(first);
         }
-        painter.add(Shape::dashed_line(&pts, stroke(ACCENT, 1.0), 4.0, 3.0));
+        painter.add(Shape::dashed_line(&pts, stroke(accent(painter), 1.0), 4.0, 3.0));
     }
     // Guides (under the rulers).
     crate::guides::draw(app, painter);
@@ -1162,8 +1200,16 @@ fn overlays(app: &FigApp, painter: &egui::Painter, t: &Tokens) -> Vec<(NodeId, [
 }
 
 /// A transform box (screen corners tl, tr, br, bl): its outline when `outline`, the first `handles`
-/// corner handles and, when dimensions are shown, the size `label` under it (its box returned).
-fn transform_box(app: &FigApp, painter: &egui::Painter, q: [Pos2; 4], col: Color32, outline: bool, handles: usize, label: String) -> Option<Rect> {
+/// corner handles and, when dimensions are shown, the size `label` (if any) under it (its box returned).
+fn transform_box(
+    app: &FigApp,
+    painter: &egui::Painter,
+    q: [Pos2; 4],
+    col: Color32,
+    outline: bool,
+    handles: usize,
+    label: Option<String>,
+) -> Option<Rect> {
     if outline {
         quad(painter, q, stroke(col, 1.0));
     }
@@ -1172,7 +1218,7 @@ fn transform_box(app: &FigApp, painter: &egui::Painter, q: [Pos2; 4], col: Color
         painter.rect_filled(r, CornerRadius::same(1), Color32::WHITE);
         painter.rect_stroke(r, CornerRadius::same(1), stroke(col, 1.0), StrokeKind::Inside);
     }
-    if app.session.prefs.show_dimensions {
+    if let Some(label) = label.filter(|_| app.session.prefs.show_dimensions) {
         let bottom = q.iter().map(|p| p.y).fold(f32::MIN, f32::max);
         let cx = q.iter().map(|p| p.x).sum::<f32>() / 4.0;
         return Some(pill(painter, pos2(cx, bottom + 9.0), Align2::CENTER_TOP, label, col));
@@ -1184,7 +1230,7 @@ fn transform_box(app: &FigApp, painter: &egui::Painter, q: [Pos2; 4], col: Color
 fn pill(painter: &egui::Painter, at: Pos2, align: Align2, text: String, col: Color32) -> Rect {
     let galley = painter.layout_no_wrap(text, semibold(11.0), Color32::WHITE);
     let r = align.anchor_size(at, galley.size() + vec2(8.0, 4.0));
-    painter.rect_filled(r, CornerRadius::same(3), col);
+    painter.rect_filled(r, CornerRadius::same(3), crate::theme::under_white(col));
     painter.galley(r.min + vec2(4.0, 2.0), galley, Color32::WHITE);
     r
 }
@@ -1241,7 +1287,7 @@ fn width_overlay(app: &FigApp, painter: &egui::Painter, doc: &Document, ve: &fig
     let sp = |p: &[f64; 2]| app.to_screen(p[0], p[1]);
     let draw = |h: &figcraft_engine::vectoredit::WidthHandle, ghost: bool| {
         let (c, a, b) = (sp(&h.at), sp(&h.sides[0]), sp(&h.sides[1]));
-        let col = if ghost { ACCENT.gamma_multiply(0.5) } else { ACCENT };
+        let col = if ghost { accent(painter).gamma_multiply(0.5) } else { accent(painter) };
         painter.line_segment([a, b], stroke(Color32::from_white_alpha(160), 3.0));
         painter.line_segment([a, b], stroke(col, 1.0));
         for (e, side) in [(a, WidthSide::Right), (b, WidthSide::Left)] {
@@ -1253,7 +1299,7 @@ fn width_overlay(app: &FigApp, painter: &egui::Painter, doc: &Document, ve: &fig
         let on = !ghost && ve.width_point == Some(h.index);
         let hovered = !ghost && hover == Some(WHit::Point { index: h.index });
         let r = if hovered { 5.0 } else { 4.0 };
-        painter.circle_filled(c, r, if on { ACCENT } else { Color32::WHITE });
+        painter.circle_filled(c, r, if on { accent(painter) } else { Color32::WHITE });
         painter.circle_stroke(c, r, stroke(col, 1.0));
     };
     for h in width_handles(doc, ve, zoom) {
@@ -1269,9 +1315,9 @@ fn width_overlay(app: &FigApp, painter: &egui::Painter, doc: &Document, ve: &fig
 /// A bezier handle from its anchor `v` to its end `e` (screen points): the line, and a dot of
 /// radius `r` filled with `fill` (vector edit mode and the Pen draw them alike).
 fn bezier_handle(painter: &egui::Painter, v: Pos2, e: Pos2, r: f32, fill: Color32) {
-    painter.line_segment([v, e], stroke(ACCENT, 1.0));
+    painter.line_segment([v, e], stroke(accent(painter), 1.0));
     painter.circle_filled(e, r, fill);
-    painter.circle_stroke(e, r, stroke(ACCENT, 1.0));
+    painter.circle_stroke(e, r, stroke(accent(painter), 1.0));
 }
 
 /// Vector edit mode: a layer's segments, handles and points (`points`) with its `hover`ed part, and
@@ -1290,7 +1336,7 @@ fn vector_overlay(
     // Paint bucket target: hatched like a fill to come.
     if active && !ov.face.is_empty() {
         let polys: Vec<Vec<Pos2>> = ov.face.iter().map(|poly| poly.iter().map(sp).collect()).collect();
-        hatched(painter, &polys, ACCENT);
+        hatched(painter, &polys, accent(painter));
     }
     if active {
         region_hatch(app, painter);
@@ -1308,7 +1354,7 @@ fn vector_overlay(
         } else {
             1.5
         };
-        painter.add(egui::epaint::CubicBezierShape::from_points_stroke([a, b, c, d], false, Color32::TRANSPARENT, stroke(ACCENT, w)));
+        painter.add(egui::epaint::CubicBezierShape::from_points_stroke([a, b, c, d], false, Color32::TRANSPARENT, stroke(accent(painter), w)));
     }
     if !points {
         return;
@@ -1316,7 +1362,7 @@ fn vector_overlay(
     for h in &o.handles {
         let hovered = hover == Some(VHit::Handle { seg: h.seg, start: h.start });
         let on = o.selected_handles.contains(&(h.seg, h.start));
-        bezier_handle(painter, sp(&h.vertex), sp(&h.handle), if hovered { 4.5 } else { 3.5 }, if on { ACCENT } else { Color32::WHITE });
+        bezier_handle(painter, sp(&h.vertex), sp(&h.handle), if hovered { 4.5 } else { 3.5 }, if on { accent(painter) } else { Color32::WHITE });
     }
     for (i, v) in o.vertices.iter().enumerate() {
         let p = sp(v);
@@ -1324,14 +1370,14 @@ fn vector_overlay(
         let size = if hovered { 9.0 } else { 7.0 };
         let r = Rect::from_center_size(p, vec2(size, size));
         let on = o.selected_vertices.contains(&i);
-        painter.rect_filled(r, CornerRadius::same(5), if on { ACCENT } else { Color32::WHITE });
-        painter.rect_stroke(r, CornerRadius::same(5), stroke(ACCENT, 1.0), StrokeKind::Inside);
+        painter.rect_filled(r, CornerRadius::same(5), if on { accent(painter) } else { Color32::WHITE });
+        painter.rect_stroke(r, CornerRadius::same(5), stroke(accent(painter), 1.0), StrokeKind::Inside);
         if o.anchor == Some(i) {
-            painter.circle_stroke(p, 7.5, stroke(ACCENT, 1.0));
+            painter.circle_stroke(p, 7.5, stroke(accent(painter), 1.0));
         }
     }
     if let Some([x0, y0, x1, y1]) = ov.rubber.filter(|_| active) {
-        painter.add(Shape::dashed_line(&[app.to_screen(x0, y0), app.to_screen(x1, y1)], stroke(ACCENT, 1.0), 4.0, 3.0));
+        painter.add(Shape::dashed_line(&[app.to_screen(x0, y0), app.to_screen(x1, y1)], stroke(accent(painter), 1.0), 4.0, 3.0));
     }
 }
 
@@ -1348,7 +1394,7 @@ fn region_hatch(app: &FigApp, painter: &egui::Painter) {
     let r = painter.clip_rect();
     let clip = figcraft_geom::Rect::new(f64::from(r.min.x), f64::from(r.min.y), f64::from(r.max.x), f64::from(r.max.y));
     for [a, b] in app.session.vector_region_hatch(view, Some(clip)) {
-        painter.line_segment([pos2(a.x as f32, a.y as f32), pos2(b.x as f32, b.y as f32)], stroke(ACCENT, REGION_HATCH_WIDTH));
+        painter.line_segment([pos2(a.x as f32, a.y as f32), pos2(b.x as f32, b.y as f32)], stroke(accent(painter), REGION_HATCH_WIDTH));
     }
 }
 
@@ -1363,10 +1409,10 @@ fn builder_overlay(app: &FigApp, painter: &egui::Painter, t: &Tokens, arr: &figc
     for r in &arr.regions {
         for poly in screen(r) {
             painter.add(Shape::closed_line(poly.clone(), stroke(Color32::from_white_alpha(150), 2.5)));
-            painter.add(Shape::closed_line(poly, stroke(ACCENT, 1.0)));
+            painter.add(Shape::closed_line(poly, stroke(accent(painter), 1.0)));
         }
     }
-    let col = if ov.builder_remove { t.danger } else { ACCENT };
+    let col = if ov.builder_remove { t.danger } else { accent(painter) };
     for r in ov.builder_regions.iter().filter_map(|i| arr.regions.get(*i)) {
         hatched(painter, &screen(r), col);
     }
@@ -1476,8 +1522,16 @@ fn rulers(app: &FigApp, painter: &egui::Painter, t: &Tokens, doc: &Document, sel
     // Highlight the selection's span.
     if let Some(b) = doc.bounds_of(sel) {
         let (a, bb) = (app.to_screen(b.x0, b.y0), app.to_screen(b.x1, b.y1));
-        painter.rect_filled(Rect::from_min_max(pos2(a.x, r.min.y), pos2(bb.x, r.min.y + size)), CornerRadius::ZERO, ACCENT.gamma_multiply(0.15));
-        painter.rect_filled(Rect::from_min_max(pos2(r.min.x, a.y), pos2(r.min.x + size, bb.y)), CornerRadius::ZERO, ACCENT.gamma_multiply(0.15));
+        painter.rect_filled(
+            Rect::from_min_max(pos2(a.x, r.min.y), pos2(bb.x, r.min.y + size)),
+            CornerRadius::ZERO,
+            accent(painter).gamma_multiply(0.15),
+        );
+        painter.rect_filled(
+            Rect::from_min_max(pos2(r.min.x, a.y), pos2(r.min.x + size, bb.y)),
+            CornerRadius::ZERO,
+            accent(painter).gamma_multiply(0.15),
+        );
     }
     let mut x = (p0.x / step).floor() * step;
     while x <= p1.x {
@@ -1505,3 +1559,8 @@ pub fn fmt(v: f64) -> String {
 #[cfg(test)]
 #[path = "zoom_preview_tests.rs"]
 mod zoom_preview_tests;
+
+/// The overlay green for the page this painter draws on ([`crate::theme::canvas_accent`]).
+fn accent(p: &egui::Painter) -> Color32 {
+    crate::theme::canvas_accent(p.ctx())
+}
diff --git a/crates/ui-egui/src/canvas_fixes_tests.rs b/crates/ui-egui/src/canvas_fixes_tests.rs
index 3b593daef..4cd32d565 100644
--- a/crates/ui-egui/src/canvas_fixes_tests.rs
+++ b/crates/ui-egui/src/canvas_fixes_tests.rs
@@ -128,3 +128,36 @@ fn the_pen_draws_the_handles_of_the_point_being_dragged_and_a_curved_band() {
     let band = shapes.iter().any(|s| matches!(s, Shape::CubicBezier(c) if c.points[0].distance(a) < 0.5 && c.points[1].distance(at(&u, 140.0, 100.0)) < 0.5 && c.stroke.color == accent));
     assert!(band, "a curve leaving along the out handle");
 }
+
+/// While drawing, the Pencil shows the stroke it will make, in its colour and weight (#256): in a
+/// dark theme the theme's text colour was white, so over a white shape nothing showed until the
+/// stroke was let go.
+#[test]
+fn the_pencil_previews_its_stroke_in_its_colour_and_weight() {
+    let mut u = Ui::new(Session::new());
+    u.app.run("tool.set", json!({"tool": "pencil"}));
+    let (color, weight) = figcraft_engine::tools::PENCIL_STROKE;
+    let preview = |shapes: &[Shape]| {
+        shapes.iter().find_map(|s| match s {
+            Shape::Path(p) if !p.closed && p.points.len() >= 3 && p.stroke.color == egui::epaint::ColorMode::Solid(crate::theme::c32(color)) => {
+                Some(p.stroke.width)
+            }
+            _ => None,
+        })
+    };
+    let at = |u: &Ui, x: f64, y: f64| u.app.to_screen(x, y);
+    let start = at(&u, 10.0, 10.0);
+    u.button(start, true);
+    for i in 1..=6 {
+        let p = at(&u, 10.0 + 12.0 * f64::from(i), 10.0 + 6.0 * f64::from(i % 2));
+        u.frame(vec![egui::Event::PointerMoved(p)]);
+    }
+    let zoom = u.app.session.ds().unwrap().view.zoom;
+    let w = preview(&flat(&u.frame_output(vec![]).shapes)).expect("a preview while drawing");
+    assert!((w - (weight * zoom) as f32).abs() < 0.01, "{w} for {weight} at {zoom}");
+    // Zoomed far out it stays visible.
+    u.app.session.ds_mut().unwrap().view.zoom = 0.05;
+    let p = at(&u, 120.0, 40.0);
+    let w = preview(&flat(&u.frame_output(vec![egui::Event::PointerMoved(p)]).shapes)).expect("still previewing");
+    assert!((w - 1.0).abs() < 0.01, "at least a point: {w}");
+}
diff --git a/crates/ui-egui/src/canvas_image_rect_tests.rs b/crates/ui-egui/src/canvas_image_rect_tests.rs
new file mode 100644
index 000000000..d047f0570
--- /dev/null
+++ b/crates/ui-egui/src/canvas_image_rect_tests.rs
@@ -0,0 +1,35 @@
+use super::canvas::presented_image_rect;
+use egui::{Pos2, Rect, pos2, vec2};
+use figcraft_render::View;
+
+#[test]
+fn native_density_rect_aligns_origin_and_preserves_pixel_extent() {
+    for ppp in [1.0_f32, 1.25, 1.5, 2.0] {
+        for zoom in [0.37_f64, 0.67, 1.0, 1.3, 2.0] {
+            let view = View { origin: (-31.25, 18.75), scale: zoom * f64::from(ppp), width: 375, height: 240 };
+            let tl = pos2(149.5, 91.25);
+            let rect = presented_image_rect(tl, &view, zoom, ppp, false);
+            assert!(((rect.min.x * ppp) - (rect.min.x * ppp).round()).abs() < 1e-4, "left edge: ppp={ppp}, zoom={zoom}, rect={rect:?}");
+            assert!(((rect.min.y * ppp) - (rect.min.y * ppp).round()).abs() < 1e-4, "top edge: ppp={ppp}, zoom={zoom}, rect={rect:?}");
+            assert!((rect.min.x - tl.x).abs() * ppp <= 0.5001, "x shift exceeds half a device pixel: ppp={ppp}, rect={rect:?}");
+            assert!((rect.min.y - tl.y).abs() * ppp <= 0.5001, "y shift exceeds half a device pixel: ppp={ppp}, rect={rect:?}");
+            assert!((rect.width() * ppp - view.width as f32).abs() < 1e-3, "width changed: ppp={ppp}, rect={rect:?}");
+            assert!((rect.height() * ppp - view.height as f32).abs() < 1e-3, "height changed: ppp={ppp}, rect={rect:?}");
+        }
+    }
+}
+
+#[test]
+fn stale_pixel_preview_and_invalid_density_keep_unsnapped_origin() {
+    let tl = Pos2::new(149.5, 91.25);
+    let view = View { origin: (0.0, 0.0), scale: 1.95, width: 300, height: 180 };
+    for (zoom, ppp, pixel_preview) in [(1.2, 1.5, false), (1.3, 1.5, true)] {
+        let rect = presented_image_rect(tl, &view, zoom, ppp, pixel_preview);
+        let original =
+            Rect::from_min_size(tl, vec2((f64::from(view.width) / view.scale * zoom) as f32, (f64::from(view.height) / view.scale * zoom) as f32));
+        assert_eq!(rect, original);
+    }
+    for ppp in [0.0, -1.0, f32::NAN, f32::INFINITY] {
+        assert_eq!(presented_image_rect(tl, &view, 1.3, ppp, false).min, tl);
+    }
+}
diff --git a/crates/ui-egui/src/cjk.rs b/crates/ui-egui/src/cjk.rs
index c7fb1f986..35323efe7 100644
--- a/crates/ui-egui/src/cjk.rs
+++ b/crates/ui-egui/src/cjk.rs
@@ -1,8 +1,9 @@
-//! Chinese, Japanese and Korean text in the UI. egui's own fonts and Inter have no CJK glyphs, so
-//! the UI adds a face per script it needs: the UI language's, the scripts in the open file's names
+//! Chinese, Japanese, Korean and Bengali text in the UI. egui's own fonts and Inter have no glyphs
+//! for them, so the UI adds a face per script it needs: the UI language's, the scripts in the open file's names
 //! and comments, the language picker's and typed text. Desktop finds them among the installed
 //! fonts (the system font scan), only once one is needed, so English users load none; the web
-//! build has only the CJK faces built in from craft-fonts (`FIGCRAFT_EMBED_CJK`), else none.
+//! build has only the CJK faces built in from craft-fonts (`FIGCRAFT_EMBED_CJK`), else none (no
+//! Bengali face is built in, so the web leaves Bengali out).
 
 use std::sync::Arc;
 
@@ -12,6 +13,13 @@ pub const KANA: u8 = 1;
 pub const HANGUL: u8 = 2;
 /// Han characters (and CJK punctuation and full-width forms).
 pub const HAN: u8 = 4;
+/// Bengali script.
+pub const BENGALI: u8 = 8;
+/// Every script bit: nothing more to look for once all have a face.
+pub const ALL: u8 = KANA | HANGUL | HAN | BENGALI;
+
+/// Bengali faces: cross-platform, Windows, macOS, then Linux names.
+const BENGALI_FONTS: &[&str] = &["Noto Sans Bengali", "Nirmala UI", "Bangla Sangam MN", "Kalpurush", "SolaimanLipi"];
 
 /// Japanese faces, the built-in one first: Windows, macOS, then Linux names.
 const JAPANESE: &[&str] = &[
@@ -37,6 +45,8 @@ const CHINESE: &[&str] = &[
     "Microsoft YaHei UI",
     "Microsoft YaHei",
     "PingFang SC",
+    "Hiragino Sans GB",
+    "Heiti SC",
     "Noto Sans SC",
     "Source Han Sans SC",
     "WenQuanYi Micro Hei",
@@ -44,36 +54,47 @@ const CHINESE: &[&str] = &[
     "Droid Sans Fallback",
 ];
 
-/// The CJK scripts in `s`.
+/// The CJK and Bengali scripts in `s`.
 pub fn scripts(s: &str) -> u8 {
     s.chars().fold(0, |m, c| {
         m | match u32::from(c) {
             0x3040..=0x30FF | 0x31F0..=0x31FF | 0xFF66..=0xFF9F => KANA,
             0x1100..=0x11FF | 0x3130..=0x318F | 0xA960..=0xA97F | 0xAC00..=0xD7FF | 0xFFA0..=0xFFDC => HANGUL,
             0x3000..=0x303F | 0x3400..=0x4DBF | 0x4E00..=0x9FFF | 0xF900..=0xFAFF | 0xFF01..=0xFF65 | 0x20000..=0x3FFFF => HAN,
+            0x0980..=0x09FF => BENGALI,
             _ => 0,
         }
     })
 }
 
-/// The CJK scripts a UI language (a catalog code) is written in.
+/// The scripts a UI language (a catalog code) is written in.
 pub fn language(code: &str) -> u8 {
     match code.split('-').next() {
         Some("ja") => KANA | HAN,
         Some("ko") => HANGUL,
         Some("zh") => HAN,
+        Some("bn") => BENGALI,
         _ => 0,
     }
 }
 
 /// Whether the UI can draw language `code`: always on desktop (a system face is found when it's
-/// needed; tofu at worst), on the web only with built-in faces for its scripts. The language
-/// picker and the system language skip a language it can't.
+/// needed; tofu at worst), on the web only with built-in faces for its scripts (Georgian: craft-fonts'
+/// Noto Sans Georgian). The language picker and the system language skip a language it can't.
 pub fn can_show(code: &str) -> bool {
+    shows(code, cfg!(target_arch = "wasm32"))
+}
+
+/// [`can_show`] in a desktop or (`web`) a web build.
+fn shows(code: &str, web: bool) -> bool {
+    if !web {
+        return true;
+    }
+    if code.split('-').next() == Some("ka") {
+        return figcraft_text::face_with_char('ა', &["Noto Sans Georgian"]).is_some();
+    }
     let need = language(code);
-    need == 0
-        || !cfg!(target_arch = "wasm32")
-        || samples(need, 0).iter().all(|(c, _)| figcraft_text::face_with_char(*c, &["BIZ UDPGothic", "Noto Sans CJK SC"]).is_some())
+    need == 0 || samples(need, 0).iter().all(|(c, _)| figcraft_text::face_with_char(*c, &["BIZ UDPGothic", "Noto Sans CJK SC"]).is_some())
 }
 
 /// A character standing for each script in `need`, with the families to look for it in, the UI
@@ -87,10 +108,16 @@ fn samples(need: u8, ui: u8) -> Vec<(char, Vec<&'static str>)> {
         (false, HANGUL) => ('漢', [KOREAN, JAPANESE, CHINESE].concat()),
         (false, _) => ('漢', [JAPANESE, KOREAN, CHINESE].concat()),
     };
-    let mut v = vec![(KANA, ('あ', JAPANESE.to_vec())), (HAN, han), (HANGUL, ('한', KOREAN.to_vec()))];
+    let mut v = vec![(KANA, ('あ', JAPANESE.to_vec())), (HAN, han), (HANGUL, ('한', KOREAN.to_vec())), (BENGALI, ('অ', BENGALI_FONTS.to_vec()))];
     match ui {
         HANGUL => v.reverse(),
         HAN => v.swap(0, 1),
+        BENGALI => {
+            if let Some(pos) = v.iter().position(|(bit, _)| *bit == BENGALI) {
+                let item = v.remove(pos);
+                v.insert(0, item);
+            }
+        }
         _ => {}
     }
     v.into_iter().filter(|(bit, _)| need & bit != 0).map(|(_, s)| s).collect()
@@ -122,20 +149,32 @@ mod tests {
         assert_eq!(scripts("ボタン"), KANA);
         assert_eq!(scripts("버튼"), HANGUL);
         assert_eq!(scripts("按钮"), HAN);
+        assert_eq!(scripts("বাংলা"), BENGALI);
         assert_eq!(scripts("日本語のレイヤー（1）"), KANA | HAN);
         assert_eq!(language("ja"), KANA | HAN);
         assert_eq!(language("ko"), HANGUL);
         assert_eq!(language("zh-Hant"), HAN);
         assert_eq!(language("zh-Hans"), HAN);
+        assert_eq!(language("bn"), BENGALI);
         assert_eq!(language("fr"), 0);
         assert!(["en", "es", "es-419", "fr", "de", "pt-BR", "tr", "id"].iter().all(|c| can_show(c)));
     }
 
+    #[test]
+    fn the_web_offers_georgian_only_with_its_face() {
+        assert!(shows("ka", false), "desktop always lists Georgian");
+        let face = figcraft_text::face_with_char('ა', &["Noto Sans Georgian"]).is_some();
+        assert_eq!(shows("ka", true), face);
+        assert_eq!(shows("ka-GE", true), face);
+        assert!(shows("en", true) && shows("tr", true));
+    }
+
     #[test]
     fn the_ui_language_script_comes_first() {
         let order = |need, ui| samples(need, ui).into_iter().map(|(c, _)| c).collect::<String>();
         let first_face = |need, ui| samples(need, ui).first().and_then(|(_, f)| f.first()).copied();
         assert_eq!(order(KANA | HAN | HANGUL, 0), "あ漢한");
+        assert_eq!(order(KANA | HAN | HANGUL | BENGALI, language("bn")), "অあ漢한");
         assert_eq!(order(KANA | HAN | HANGUL, KANA | HAN), "あ漢한");
         assert_eq!(order(KANA | HAN | HANGUL, HANGUL), "한漢あ");
         assert_eq!(order(HANGUL, 0), "한");
@@ -148,6 +187,6 @@ mod tests {
         assert_eq!(order(KANA | HAN, language("zh-Hans")), "们あ");
         assert!(["Microsoft YaHei UI", "PingFang SC", "Noto Sans CJK SC"].iter().all(|f| samples(HAN, HAN)[0].1[..4].contains(f)));
         assert!(faces(0, "en", &|_| false).is_empty());
-        assert!(faces(KANA | HANGUL | HAN, "ja", &|_| true).is_empty(), "nothing is looked up for scripts the UI draws");
+        assert!(faces(KANA | HANGUL | HAN | BENGALI, "ja", &|_| true).is_empty(), "nothing is looked up for scripts the UI draws");
     }
 }
diff --git a/crates/ui-egui/src/colorpicker.rs b/crates/ui-egui/src/colorpicker.rs
index bb18a0b2e..9d37477ab 100644
--- a/crates/ui-egui/src/colorpicker.rs
+++ b/crates/ui-egui/src/colorpicker.rs
@@ -18,6 +18,11 @@ use crate::widgets;
 #[derive(Clone, Debug, PartialEq)]
 pub enum PickerTarget {
     PageBackground,
+    SelectionColor {
+        targets: Vec<figcraft_engine::selection_colors::PaintTarget>,
+        selection: Vec<NodeId>,
+        document: u64,
+    },
     Paint {
         fills: bool,
         index: usize,
@@ -72,6 +77,13 @@ pub fn range_fills(doc: &figcraft_doc::Document, id: NodeId, start: usize) -> Op
 fn current_paint(app: &FigApp, target: &PickerTarget) -> Option<Paint> {
     let doc = app.session.doc().ok()?;
     match target {
+        PickerTarget::SelectionColor { targets, selection, document } => {
+            let ds = app.session.ds().ok()?;
+            if ds.uid != *document || ds.selection != *selection {
+                return None;
+            }
+            targets.first()?.paint(doc)
+        }
         PickerTarget::PageBackground => match &doc.node(app.session.page().ok()?)?.kind {
             NodeKind::Page { background, .. } => Some(Paint::solid(*background)),
             _ => None,
@@ -108,8 +120,7 @@ fn current_paint(app: &FigApp, target: &PickerTarget) -> Option<Paint> {
 /// Write `paint` to the target. `live` edits are part of an ongoing drag.
 fn write(app: &mut FigApp, target: &PickerTarget, paint: &Paint, live: bool) {
     if let PickerTarget::PluginField { plugin, control, .. } = target {
-        let c = paint.solid_color().unwrap_or(Color::BLACK);
-        let hex = c.with_alpha(c.a * paint.opacity).to_css_hex();
+        let hex = paint.solid_color().unwrap_or(Color::BLACK).to_css_hex();
         let (plugin, control) = (plugin.clone(), control.clone());
         if !live {
             crate::plugins_ui::set_field(app, &plugin, &control, &hex);
@@ -121,6 +132,7 @@ fn write(app: &mut FigApp, target: &PickerTarget, paint: &Paint, live: bool) {
         let _ = app.session.begin_interaction("Color");
     }
     let r = match target {
+        PickerTarget::SelectionColor { targets, .. } => app.session.execute("selection.setPaint", &json!({"targets": targets, "paint": paint})),
         PickerTarget::PageBackground => {
             let c = paint.solid_color().unwrap_or(Color::DEFAULT_PAGE);
             app.session.execute("page.setBackground", &json!({"color": c.to_css_hex()}))
@@ -140,7 +152,7 @@ fn write(app: &mut FigApp, target: &PickerTarget, paint: &Paint, live: bool) {
         }
         PickerTarget::Variable { id, mode } => {
             let c = paint.solid_color().unwrap_or(Color::BLACK);
-            app.session.execute("variable.set", &json!({"variable": id, "mode": mode, "value": c.with_alpha(c.a * paint.opacity).to_css_hex()}))
+            app.session.execute("variable.set", &json!({"variable": id, "mode": mode, "value": c.to_css_hex()}))
         }
         PickerTarget::PluginField { .. } => return,
         PickerTarget::Style { id, index } => {
@@ -423,8 +435,21 @@ fn alpha_slider(ui: &mut Ui, rect: Rect, color: Color) -> Option<(f32, bool)> {
     slider_knob(ui, rect, color.a, Id::new("cp_alpha"))
 }
 
+/// The colour picker window's area id. A fixed id (not `Window::new`'s, which egui keys by
+/// `Id::new(Some(title))`) so the style picker can tell a click inside the picker from one outside.
+pub fn window_id() -> Id {
+    Id::new("color_picker")
+}
+
 pub fn show(app: &mut FigApp, ctx: &egui::Context) {
-    let Some(target) = app.ui.picker.clone() else { return };
+    let Some(target) = app.ui.picker.clone() else {
+        // A colour sampled for a picker that has closed has no paint to go to.
+        app.session.tool.picked = None;
+        if app.session.tool.pick_only {
+            app.run("tool.move", json!({}));
+        }
+        return;
+    };
     // A layer's picker belongs to the selection it was opened for: once that changes, close it
     // rather than keep editing layers that are no longer selected.
     let stale = match &target {
@@ -434,6 +459,9 @@ pub fn show(app: &mut FigApp, ctx: &egui::Context) {
     };
     let current = if stale { None } else { current_paint(app, &target) };
     let Some(mut paint) = current else {
+        if matches!(target, PickerTarget::SelectionColor { .. }) {
+            finish(app);
+        }
         app.ui.picker = None;
         return;
     };
@@ -448,6 +476,9 @@ pub fn show(app: &mut FigApp, ctx: &egui::Context) {
     let mut open = true;
     let mut close_now = false;
     egui::Window::new("color_picker")
+        // A fixed area id so the style picker can tell a click in here from a click outside
+        // (`Window::new` alone would key the area by `Id::new(Some(title))`).
+        .id(window_id())
         .title_bar(false)
         .fixed_pos(pos)
         .fixed_size(vec2(240.0, 0.0))
@@ -455,6 +486,10 @@ pub fn show(app: &mut FigApp, ctx: &egui::Context) {
         .open(&mut open)
         .show(ctx, |ui| {
             ui.spacing_mut().item_spacing = vec2(8.0, 8.0);
+            // The eyedropper's colour goes to this picker's paint (a stroke, an effect, a gradient stop...).
+            if let Some(c) = app.session.tool.picked.take() {
+                set_color(app, &target, &mut paint, c, stop_id(), ui);
+            }
             // Header.
             let (hr, _) = ui.allocate_exact_size(vec2(240.0, 40.0), Sense::hover());
             ui.painter().text(pos2(hr.min.x + 16.0, hr.center().y), Align2::LEFT_CENTER, tr("Custom"), semibold(11.0), t.text);
@@ -500,7 +535,7 @@ pub fn show(app: &mut FigApp, ctx: &egui::Context) {
                                 image_pending = true;
                                 let target = target.clone();
                                 app.pick_open(tr("Choose image"), &["png", "jpg", "jpeg", "webp", "gif", "tif", "tiff"], move |app, p| {
-                                    let Ok(bytes) = std::fs::read(&p) else { return };
+                                    let Ok(bytes) = figcraft_engine::file_access::read(&p) else { return };
                                     let Some(hash) = app.session.doc_mut().ok().and_then(|d| figcraft_format_add(d, bytes)) else { return };
                                     if let Some(mut paint) = current_paint(app, &target) {
                                         paint.kind = Paint::image(hash, ImageScaleMode::Fill).kind;
@@ -757,8 +792,7 @@ pub fn show(app: &mut FigApp, ctx: &egui::Context) {
                 )
                 .clicked()
                 {
-                    app.ui.picker = None;
-                    app.run("edit.pickColor", json!({}));
+                    app.run("edit.pickColor", json!({"apply": false}));
                     return;
                 }
                 let (c2, d2) = hue_slider(ui, hr, &mut hsb);
@@ -872,6 +906,7 @@ fn pattern_sources(app: &FigApp, target: &PickerTarget) -> Vec<(NodeId, String)>
     let Ok(doc) = app.session.doc() else { return Vec::new() };
     let painted = match target {
         PickerTarget::Paint { ids, .. } => ids.clone(),
+        PickerTarget::SelectionColor { targets, .. } => targets.iter().map(|t| t.id).collect(),
         PickerTarget::TextRange { id, .. } => vec![*id],
         _ => Vec::new(),
     };
@@ -997,7 +1032,7 @@ fn saved_preset_row(ui: &mut Ui, name: &str) -> Option<PresetAction> {
     let del_resp = ui.interact(del, ui.id().with(("cp_preset_del", name)), Sense::click()).tip(tr("Delete preset"));
     let hot = resp.hovered() || del_resp.hovered();
     if hot {
-        ui.painter().rect_filled(r, CornerRadius::same(5), crate::theme::ACCENT);
+        ui.painter().rect_filled(r, CornerRadius::same(5), t.menu_hover);
     }
     let col = if hot { Color32::WHITE } else { t.text };
     ui.painter().text(pos2(r.min.x + 8.0, r.center().y), Align2::LEFT_CENTER, name, regular(11.5), col);
@@ -1129,6 +1164,70 @@ impl WithStops for Gradient {
     }
 }
 
+#[cfg(test)]
+mod selection_color_tests {
+    use super::*;
+    use crate::NoServices;
+    use figcraft_engine::{Session, selection_colors::collect};
+
+    fn setup() -> (FigApp, NodeId, NodeId) {
+        let mut s = Session::new();
+        let a = NodeId(s.execute("shape.rectangle", &json!({"width":40,"height":40,"props":{"fill":"#ff0000"}})).unwrap()["id"].as_u64().unwrap());
+        let b = NodeId(s.execute("shape.rectangle", &json!({"width":40,"height":40,"props":{"fill":"#0000ff"}})).unwrap()["id"].as_u64().unwrap());
+        s.execute("select.set", &json!({"ids":[a,b]})).unwrap();
+        let mut app = FigApp::new(s, Box::new(NoServices));
+        let targets = collect(app.session.doc().unwrap(), &[a, b])[0].targets.clone();
+        crate::selection_colors::open_picker(&mut app, targets);
+        (app, a, b)
+    }
+
+    #[test]
+    fn picker_live_changes_keep_frozen_targets_and_commit_once() {
+        let (mut app, a, b) = setup();
+        let target = app.ui.picker.clone().unwrap();
+        let before = app.session.undo_depth();
+        for color in ["#0000ff", "#00ff00"] {
+            write(&mut app, &target, &Paint::solid(Color::from_hex(color).unwrap()), true);
+        }
+        assert!(app.session.recent_colors.is_empty(), "previews must not be recorded");
+        finish(&mut app);
+        assert_eq!(app.session.recent_colors, vec![Color::from_hex("#00ff00").unwrap()]);
+        assert_eq!(app.session.undo_depth().0, before.0 + 1);
+        assert_eq!(current_paint(&app, &target).unwrap().solid_color().unwrap().to_hex(), "00FF00");
+        assert_eq!(app.session.doc().unwrap().node(b).unwrap().fills[0].solid_color().unwrap().to_hex(), "0000FF");
+        app.session.undo().unwrap();
+        assert_eq!(app.session.doc().unwrap().node(a).unwrap().fills[0].solid_color().unwrap().to_hex(), "FF0000");
+    }
+
+    #[test]
+    fn writing_a_variable_keeps_its_alpha() {
+        // The picker holds a colour variable's alpha as the paint opacity; writing it back applies it once.
+        let (mut app, _, _) = setup();
+        app.session.execute("variable.createCollection", &json!({"name":"T"})).unwrap();
+        let v = app.session.execute("variable.create", &json!({"collection":"T","name":"tint","type":"color","value":"#0D6EFD80"})).unwrap();
+        let var = app.session.doc().unwrap().variables.get(v["id"].as_str().unwrap()).unwrap().clone();
+        let target = PickerTarget::Variable { id: var.id.clone(), mode: var.values.keys().next().unwrap().clone() };
+        for _ in 0..2 {
+            let paint = current_paint(&app, &target).unwrap();
+            write(&mut app, &target, &paint, false);
+        }
+        let c = current_paint(&app, &target).unwrap().solid_color().unwrap();
+        assert_eq!(c.to_css_hex().to_uppercase(), "#0D6EFD80");
+    }
+
+    #[test]
+    fn picker_does_not_follow_selection_or_document_switches() {
+        let (mut app, _, _) = setup();
+        let target = app.ui.picker.clone().unwrap();
+        app.session.execute("select.none", &json!({})).unwrap();
+        assert!(current_paint(&app, &target).is_none());
+        let (mut app, _, _) = setup();
+        let target = app.ui.picker.clone().unwrap();
+        app.session.execute("file.new", &json!({})).unwrap();
+        assert!(current_paint(&app, &target).is_none());
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/ui-egui/src/colorpicker_eyedropper_tests.rs b/crates/ui-egui/src/colorpicker_eyedropper_tests.rs
new file mode 100644
index 000000000..51856b48b
--- /dev/null
+++ b/crates/ui-egui/src/colorpicker_eyedropper_tests.rs
@@ -0,0 +1,90 @@
+//! The eyedropper of a colour picker, driven through egui headless: the colour it samples goes to
+//! the paint the picker edits (a stroke, an effect), not to the layer's fill (vectorcraft#3342).
+
+use egui::accesskit::Role;
+use egui::{Event, Pos2, pos2};
+use figcraft_doc::NodeId;
+use figcraft_engine::{Session, ToolId};
+use serde_json::json;
+
+use crate::colorpicker::PickerTarget;
+use crate::layers_drag_tests::Ui;
+
+fn rect(s: &mut Session, x: f64, props: serde_json::Value) -> NodeId {
+    let v = s.execute("shape.rectangle", &json!({"x": x, "y": 0, "width": 60, "height": 60, "props": props})).unwrap();
+    NodeId(v["id"].as_u64().unwrap())
+}
+
+/// The middle of the picker's eyedropper button.
+fn eyedropper_button(u: &mut Ui) -> Pos2 {
+    u.ctx.enable_accesskit();
+    u.frame(vec![]);
+    let out = u.frame_output(vec![]);
+    let nodes = out.platform_output.accesskit_update.expect("an AccessKit update").nodes;
+    let n = nodes.iter().map(|(_, n)| n).find(|n| n.role() == Role::Button && n.label() == Some("Pick color (I)")).expect("the eyedropper button");
+    let b = n.bounds().expect("bounds");
+    pos2(((b.x0 + b.x1) / 2.0) as f32, ((b.y0 + b.y1) / 2.0) as f32)
+}
+
+fn click(u: &mut Ui, p: Pos2) {
+    u.button(p, true);
+    u.button(p, false);
+    u.frame(vec![Event::PointerMoved(p)]);
+    u.frame(vec![]);
+}
+
+#[test]
+fn the_pickers_eyedropper_applies_the_colour_to_the_paint_it_edits() {
+    for effect in [false, true] {
+        // A red layer to sample, and a green one with a blue stroke (and a shadow) to edit.
+        let mut s = Session::new();
+        s.execute("page.setBackground", &json!({"color": "#FFFFFF"})).unwrap();
+        let red = rect(&mut s, 0.0, json!({"fill": "#FF0000"}));
+        let b = rect(&mut s, 200.0, json!({"fill": "#00FF00", "stroke": "#0000FF", "strokeWeight": 2}));
+        s.execute("select.set", &json!({"ids": [b]})).unwrap();
+        let target = if effect {
+            s.execute("effect.add", &json!({"ids": [b], "type": "dropShadow"})).unwrap();
+            PickerTarget::Effect { ids: vec![b], index: 0, secondary: false }
+        } else {
+            PickerTarget::Paint { fills: false, index: 0, ids: vec![b] }
+        };
+        let mut u = Ui::new(s);
+        u.app.ui.picker = Some(target.clone());
+        let at = eyedropper_button(&mut u);
+        click(&mut u, at);
+        assert_eq!(u.app.session.tool.tool, ToolId::Eyedropper, "the button picks up the eyedropper");
+        let undo = u.app.session.undo_depth().0;
+        let on_red = u.app.to_screen(30.0, 30.0);
+        click(&mut u, on_red);
+        let doc = u.app.session.doc().unwrap();
+        let n = doc.node(b).unwrap();
+        let hex = |p: Option<figcraft_color::Color>| p.map(|c| c.to_hex()).unwrap_or_default();
+        let picked = if effect { hex(n.effects[0].color(false)) } else { hex(n.strokes[0].solid_color()) };
+        assert_eq!(picked, "FF0000", "the picker's paint takes the colour (effect: {effect})");
+        assert_eq!(hex(n.fills[0].solid_color()), "00FF00", "the fill is left alone (effect: {effect})");
+        assert!(doc.node(red).is_some());
+        assert_eq!(u.app.session.tool.tool, ToolId::Move, "picking ends the eyedropper");
+        assert_eq!(u.app.ui.picker, Some(target), "the picker stays open on its paint");
+        assert_eq!(u.app.session.undo_depth().0, undo + 1, "one undo step");
+    }
+}
+
+#[test]
+fn closing_the_picker_drops_its_eyedropper() {
+    // The colour sampled after the picker closed has no paint to go to: it must not wait for the
+    // next picker, and the eyedropper gives way to the Move tool.
+    let mut s = Session::new();
+    let b = rect(&mut s, 200.0, json!({"fill": "#00FF00", "stroke": "#0000FF"}));
+    s.execute("select.set", &json!({"ids": [b]})).unwrap();
+    let mut u = Ui::new(s);
+    u.app.ui.picker = Some(PickerTarget::Paint { fills: false, index: 0, ids: vec![b] });
+    let at = eyedropper_button(&mut u);
+    click(&mut u, at);
+    assert_eq!(u.app.session.tool.tool, ToolId::Eyedropper);
+    u.app.ui.picker = None;
+    u.app.session.tool.picked = figcraft_color::Color::from_hex("#FF0000");
+    u.frame(vec![]);
+    u.frame(vec![]);
+    assert_eq!(u.app.session.tool.tool, ToolId::Move);
+    assert_eq!(u.app.session.tool.picked, None, "a colour sampled for a closed picker is dropped");
+}
diff --git a/crates/ui-egui/src/colorpicker_selection_tests.rs b/crates/ui-egui/src/colorpicker_selection_tests.rs
index 57aae197a..fff5536a5 100644
--- a/crates/ui-egui/src/colorpicker_selection_tests.rs
+++ b/crates/ui-egui/src/colorpicker_selection_tests.rs
@@ -52,3 +52,54 @@ fn picker_closes_when_another_layer_is_selected() {
     u.frame(vec![]);
     assert!(u.app.ui.picker.is_none(), "selecting another layer closes the picker: {:?}", u.app.ui.picker);
 }
+
+// Regression test for #237: the "On this page" swatches wrapped onto rows that started at the picker's
+// left edge (only the first row was indented) and ran past its right edge.
+#[test]
+fn wrapped_page_colour_swatches_stay_inset_inside_the_picker() {
+    use egui::Shape;
+    let mut s = Session::new();
+    let mut first = None;
+    for i in 0..40 {
+        let v = s
+            .execute(
+                "shape.rectangle",
+                &json!({"x": i * 30, "y": 0, "width": 20, "height": 20, "props": {"fill": format!("#{:02X}{:02X}80", i * 6, 255 - i * 6)}}),
+            )
+            .unwrap();
+        first.get_or_insert(NodeId(v["id"].as_u64().unwrap()));
+    }
+    let a = first.unwrap();
+    s.execute("select.set", &json!({"ids": [a]})).unwrap();
+    let mut u = Ui::new(s);
+    u.app.ui.picker = Some(PickerTarget::Paint { fills: true, index: 0, ids: vec![a] });
+    for _ in 0..3 {
+        u.frame(vec![]);
+    }
+    let out = u.frame_output(vec![]);
+    // The picker is the only floating window open.
+    let picker = u
+        .ctx
+        .memory(|m| m.areas().visible_layer_ids().into_iter().filter(|l| l.order == egui::Order::Middle).find_map(|l| m.area_rect(l.id)))
+        .expect("the picker is open");
+    // A swatch is a 14 pt square with a 1 pt outline.
+    let swatches: Vec<egui::Rect> = out
+        .shapes
+        .iter()
+        .filter_map(|c| match &c.shape {
+            Shape::Rect(r) if r.stroke.width == 1.0 && (r.rect.width() - 14.0).abs() < 0.01 && (r.rect.height() - 14.0).abs() < 0.01 => Some(r.rect),
+            _ => None,
+        })
+        .filter(|r| picker.contains_rect(*r))
+        .collect();
+    let mut rows: Vec<f32> = swatches.iter().map(|r| r.min.y).collect();
+    rows.sort_by(f32::total_cmp);
+    rows.dedup_by(|a, b| (*a - *b).abs() < 1.0);
+    assert!(rows.len() >= 2, "expected the page colours to wrap onto several rows, got {} swatches in {} row(s)", swatches.len(), rows.len());
+    for r in &swatches {
+        assert!(
+            r.min.x >= picker.min.x + 16.0 - 0.5 && r.max.x <= picker.max.x - 16.0 + 0.5,
+            "swatch {r:?} is not inset 16 pt from both sides of the picker {picker:?}"
+        );
+    }
+}
diff --git a/crates/ui-egui/src/comments.rs b/crates/ui-egui/src/comments.rs
index 5918dfc03..d33c81ee0 100644
--- a/crates/ui-egui/src/comments.rs
+++ b/crates/ui-egui/src/comments.rs
@@ -189,10 +189,10 @@ pub fn cluster(points: &[Pos2], r: f32) -> Vec<Vec<usize>> {
 }
 
 /// A message's text with its @mentions of `people` picked out, wrapped at `width`.
-pub fn rich_text(text: &str, people: &[&str], color: Color32, width: f32) -> LayoutJob {
+pub fn rich_text(text: &str, people: &[&str], color: Color32, mention_color: Color32, width: f32) -> LayoutJob {
     let mut job = LayoutJob::default();
     let plain = TextFormat { font_id: regular(12.0), color, ..Default::default() };
-    let mention = TextFormat { font_id: semibold(12.0), color: ACCENT, ..Default::default() };
+    let mention = TextFormat { font_id: semibold(12.0), color: mention_color, ..Default::default() };
     let mut at = 0;
     for r in mention_ranges(text, people) {
         job.append(text.get(at..r.start).unwrap_or(""), 0.0, plain.clone());
@@ -400,7 +400,7 @@ pub fn draw(app: &FigApp, painter: &egui::Painter) {
     if let Some((x, y, _)) = &app.ui.comments.draft {
         let r = pin_rect(app.to_screen(*x, *y));
         painter.rect_filled(r, BUBBLE, ACCENT);
-        painter.circle_filled(r.center(), 3.0, Color32::WHITE);
+        painter.circle_filled(r.center(), 3.0, crate::theme::ACCENT_ON);
     }
 }
 
@@ -729,7 +729,7 @@ fn message(
                     ui.add_space(indent);
                     let mut names: Vec<&str> = cx.people.iter().map(String::as_str).collect();
                     names.push(cx.me);
-                    ui.add(egui::Label::new(rich_text(&m.text, &names, t.text, ui.available_width())).wrap());
+                    ui.add(egui::Label::new(rich_text(&m.text, &names, t.text, t.accent_text, ui.available_width())).wrap());
                 });
             }
         }
@@ -1062,7 +1062,8 @@ pub fn panel(app: &mut FigApp, ui: &mut Ui) {
             ui.add_space(16.0);
             ui.label(egui::RichText::new(tr(app.ui.comments.filter.label())).font(regular(11.0)).color(t.text_secondary));
             ui.add_space(4.0);
-            if ui.add(egui::Label::new(egui::RichText::new(tr("Show open")).font(regular(11.0)).color(ACCENT)).sense(Sense::click())).clicked() {
+            if ui.add(egui::Label::new(egui::RichText::new(tr("Show open")).font(regular(11.0)).color(t.accent_text)).sense(Sense::click())).clicked()
+            {
                 app.ui.comments.filter = Filter::Open;
             }
         });
diff --git a/crates/ui-egui/src/comments_tests.rs b/crates/ui-egui/src/comments_tests.rs
index bf30d5e55..eea2278e9 100644
--- a/crates/ui-egui/src/comments_tests.rs
+++ b/crates/ui-egui/src/comments_tests.rs
@@ -7,7 +7,7 @@ use egui::{Event, Key, Modifiers, Pos2, pos2, vec2};
 use figcraft_engine::Session;
 use serde_json::{Value, json};
 
-use crate::comments::{cluster, insert_mention, mention_matches, mention_query};
+use crate::comments::{cluster, insert_mention, mention_matches, mention_query, start_draft};
 use crate::present_tests::{Ui, id};
 
 fn add(s: &mut Session, x: f64, y: f64, text: &str, author: &str) -> u64 {
@@ -41,6 +41,35 @@ fn comments(u: &Ui) -> Value {
     u.app.inspect()["comments"].clone()
 }
 
+#[test]
+fn switching_from_comment_to_move_closes_the_unposted_composer() {
+    let mut u = Ui::new(Session::new());
+    u.app.run("tool.set", json!({"tool": "comment"}));
+    start_draft(&mut u.app, 100.0, 80.0);
+    assert!(comments(&u)["draft"].is_array());
+
+    u.app.run("tool.set", json!({"tool": "move"}));
+    u.frame(vec![]);
+    assert!(comments(&u)["draft"].is_null());
+}
+
+#[test]
+fn control_channel_tool_switch_closes_the_unposted_composer() {
+    let mut u = Ui::new(Session::new());
+    u.app.run("tool.set", json!({"tool": "comment"}));
+    start_draft(&mut u.app, 100.0, 80.0);
+    assert!(comments(&u)["draft"].is_array());
+
+    let invalid = json!({"command": "tool.set", "params": {"tool": "not-a-tool"}});
+    assert!(crate::control::handle(&mut u.app, &egui::Context::default(), "engine.execute", &invalid).is_err());
+    assert!(comments(&u)["draft"].is_array());
+
+    crate::control::handle(&mut u.app, &egui::Context::default(), "engine.execute", &json!({"command": "tool.set", "params": {"tool": "move"}}))
+        .unwrap();
+    u.frame(vec![]);
+    assert!(comments(&u)["draft"].is_null());
+}
+
 #[test]
 fn mention_helpers() {
     // The `@query` before the cursor.
@@ -213,7 +242,7 @@ fn the_presenter_shows_the_frames_comments() {
     key(&mut u, Key::C, Modifiers::SHIFT);
     assert_eq!(u.app.inspect()["presenter"]["comments"], true);
     // The frame is presented at 100% (Fit never scales up), centred under the bar.
-    let screen = egui::Rect::from_min_size(pos2(0.0, 40.0), vec2(1440.0, 860.0));
+    let screen = egui::Rect::from_min_size(pos2(0.0, 80.0), vec2(1440.0, 820.0));
     let frame_min = screen.center() - vec2(200.0, 150.0);
     let pin = frame_min + vec2(100.0, 100.0) + vec2(14.0, -14.0);
     click(&mut u, pin);
diff --git a/crates/ui-egui/src/component_panel.rs b/crates/ui-egui/src/component_panel.rs
index 646d6ecdb..6caab6d58 100644
--- a/crates/ui-egui/src/component_panel.rs
+++ b/crates/ui-egui/src/component_panel.rs
@@ -2,8 +2,9 @@
 //!
 //! - An instance: its main component (with a swap menu), variant dropdowns, property values,
 //!   the selected layer's overrides, and Reset / Detach / Go to main / Push changes.
-//! - A component or component set: its properties (add, rename, default, delete) and, for a set,
-//!   the variant property matrix.
+//! - A component or component set: its properties (add, rename, default, delete), Add variant
+//!   (a lone main component becomes a set) and, for a set, the variant property matrix.
+//! - Several main components: Combine as variants.
 //! - A layer inside a component: bind its visibility / text / instance to a property, or make a
 //!   frame a slot.
 //! - A slot inside an instance (and an instance's slot properties): fill it with components
@@ -11,6 +12,7 @@
 
 use egui::{Id, Sense, Ui, vec2};
 use figcraft_doc::*;
+use figcraft_engine::cmd::component::{can_add_variant, can_combine_variants};
 use figcraft_engine::components::{
     PROP_BINDING, default_variant, inside_instance, owning_component, owning_instance, slot_def, slot_edited, slots_of, variant_conflicts,
     variant_options, variant_props, variant_set,
@@ -20,13 +22,17 @@ use serde_json::{Value, json};
 use crate::FigApp;
 use crate::i18n::{tr, tr_noop, trn};
 use crate::icons::{self, Icon};
-use crate::right::{menu_item, menu_popup, row};
+use crate::list_drag::ListDrag;
+use crate::right::{menu_item, menu_popup, row, row_rect};
 use crate::theme::{COMPONENT, Tokens, semibold};
 use crate::widgets;
 
 /// Entry point (called from the Design panel header for every selection).
 pub fn instance_section(app: &mut FigApp, ui: &mut Ui, doc: &Document, sel: &[NodeId]) {
-    let [id] = sel else { return };
+    let [id] = sel else {
+        combine_ui(app, ui, doc, sel);
+        return;
+    };
     let Some(n) = doc.node(*id) else { return };
     match &n.kind {
         NodeKind::Instance { .. } => instance_ui(app, ui, doc, n),
@@ -56,6 +62,19 @@ pub fn instance_section(app: &mut FigApp, ui: &mut Ui, doc: &Document, sel: &[No
     }
 }
 
+/// Two or more main components selected: a button combines them into a component set.
+fn combine_ui(app: &mut FigApp, ui: &mut Ui, doc: &Document, sel: &[NodeId]) {
+    if !can_combine_variants(doc, sel) {
+        return;
+    }
+    row(ui, 32.0, |ui| {
+        let label = crate::i18n::command("component.combineVariants", "Combine as variants");
+        if widgets::dropdown(ui, &label, 160.0, Some(Icon::ComponentSet)).clicked() {
+            app.run("component.combineVariants", json!({"ids": sel}));
+        }
+    });
+}
+
 /// A component's description: a multi-line field, saved when it loses focus.
 fn description_ui(app: &mut FigApp, ui: &mut Ui, id: NodeId, description: &str) {
     widgets::separator(ui);
@@ -69,7 +88,7 @@ fn description_ui(app: &mut FigApp, ui: &mut Ui, id: NodeId, description: &str)
 /// Local components (and component sets, not their variants), for swap menus: (id, label), page
 /// by page. Listed once per document revision (a file with thousands of layers isn't walked every
 /// frame).
-fn local_components(app: &FigApp, ui: &Ui, doc: &Document) -> std::sync::Arc<Vec<(NodeId, String)>> {
+pub(crate) fn local_components(app: &FigApp, ui: &Ui, doc: &Document) -> std::sync::Arc<Vec<(NodeId, String)>> {
     type Cached = ((u64, u64), std::sync::Arc<Vec<(NodeId, String)>>);
     let key = app.session.ds().map(|d| (d.uid, d.revision)).unwrap_or_default();
     let id = Id::new("component_panel_local_components");
@@ -241,9 +260,11 @@ fn properties_ui(app: &mut FigApp, ui: &mut Ui, doc: &Document, owner: NodeId) {
     } else {
         Default::default()
     };
-    // Variant properties: name, values (the matrix), add value, delete.
-    for (k, vals) in &variants {
-        row(ui, 32.0, |ui| {
+    // Variant properties: name, values (the matrix), add value, delete. Dragged by their left
+    // margin to reorder them (only among themselves: the shared ones keep the engine's order).
+    let mut drag = ListDrag::in_order(ui, ("variant_props", owner));
+    for (i, (k, vals)) in variants.iter().enumerate() {
+        let header = row_rect(ui, 32.0, |ui| {
             let (ir, _) = ui.allocate_exact_size(vec2(14.0, 14.0), Sense::hover());
             icons::paint(ui.painter(), ir, Icon::ComponentSet, COMPONENT);
             if let Some(nn) = widgets::text_field(ui, Id::new(("vprop_name", owner, k.as_str())), k, 110.0, tr("Name")) {
@@ -284,6 +305,12 @@ fn properties_ui(app: &mut FigApp, ui: &mut Ui, doc: &Document, owner: NodeId) {
             });
             vi += 3;
         }
+        drag.row(ui, i, header, header.with_max_y(ui.cursor().min.y.max(header.max.y)), || k.clone());
+    }
+    if let Some((from, to)) = drag.finish(ui)
+        && let Some((k, _)) = variants.get(from)
+    {
+        app.run("component.editProperty", json!({"id": owner, "name": k, "index": to}));
     }
     // Shared properties.
     for (k, d) in &defs {
@@ -356,7 +383,8 @@ fn properties_ui(app: &mut FigApp, ui: &mut Ui, doc: &Document, owner: NodeId) {
             });
         }
     }
-    if is_set {
+    // A lone main component too: Add variant makes it a set of itself and the new variant.
+    if can_add_variant(doc, owner) {
         row(ui, 32.0, |ui| {
             if widgets::dropdown(ui, tr("Add variant"), 120.0, Some(Icon::Plus)).clicked() {
                 app.run("component.addVariant", json!({"id": owner}));
@@ -493,7 +521,9 @@ fn group_label(g: &str) -> String {
         "grids" => tr("Layout grids"),
         "exports" => tr("Export settings"),
         "interactions" => tr("Interactions"),
+        "modes" => tr("Variable modes"),
         "size" => tr("Size"),
+        "resizing" => tr("Resizing"),
         "position" => tr("Position"),
         "component" => tr("Swapped instance"),
         "props" => tr("Instance properties"),
@@ -679,35 +709,9 @@ fn instance_props(app: &mut FigApp, ui: &mut Ui, doc: &Document, n: &Node, comps
                     });
                 }
                 PropDef::InstanceSwap { preferred, .. } => {
-                    let cur = figcraft_engine::params::id_of(&v);
-                    let label = cur.and_then(|c| doc.node(c)).map(|c| c.name.clone()).unwrap_or_else(|| tr("None").into());
-                    let resp = widgets::dropdown(ui, &label, w, Some(Icon::Instance));
-                    menu_popup(&resp).width(200.0).show(|ui| {
-                        let t = Tokens::get(ui.ctx());
-                        let heading = |ui: &mut Ui, text: &str| ui.label(egui::RichText::new(text).font(semibold(11.0)).color(t.text_secondary));
-                        let mut pick = |ui: &mut Ui, c: NodeId, name: &str| {
-                            let current = cur == Some(c);
-                            if menu_item(ui, &format!("{}{name}", if current { "✓ " } else { "" }), "") {
-                                if !current {
-                                    app.run("instance.setProperties", json!({"ids": [id], "properties": {k.clone(): c.0}}));
-                                }
-                                ui.close();
-                            }
-                        };
-                        let preferred: Vec<(NodeId, String)> = preferred.iter().filter_map(|c| doc.node(*c).map(|n| (*c, n.name.clone()))).collect();
-                        if !preferred.is_empty() {
-                            heading(ui, tr("Preferred"));
-                            for (c, name) in &preferred {
-                                pick(ui, *c, name);
-                            }
-                            heading(ui, tr("All components"));
-                        }
-                        egui::ScrollArea::vertical().max_height(320.0).show(ui, |ui| {
-                            for (c, name) in comps {
-                                pick(ui, *c, name);
-                            }
-                        });
-                    });
+                    if let Some(c) = swap_dropdown(ui, doc, figcraft_engine::params::id_of(&v), &preferred, comps, w, "").1 {
+                        app.run("instance.setProperties", json!({"ids": [id], "properties": {k.clone(): c.0}}));
+                    }
                 }
                 PropDef::Variant { .. } => {}
                 PropDef::Slot { preferred } => {
@@ -720,6 +724,54 @@ fn instance_props(app: &mut FigApp, ui: &mut Ui, doc: &Document, n: &Node, comps
     }
 }
 
+/// The dropdown of an instance-swap property showing component `cur`: its menu lists the
+/// property's preferred components first (when it has any), then every component in the file. The
+/// dropdown, and the component picked (picking the current one picks nothing). `name` labels it for
+/// assistive technology.
+pub(crate) fn swap_dropdown(
+    ui: &mut Ui,
+    doc: &Document,
+    cur: Option<NodeId>,
+    preferred: &[NodeId],
+    comps: &[(NodeId, String)],
+    w: f32,
+    name: &str,
+) -> (egui::Response, Option<NodeId>) {
+    let label = cur.and_then(|c| doc.node(c)).map(|c| c.name.clone()).unwrap_or_else(|| tr("None").into());
+    let resp = widgets::dropdown(ui, &label, w, Some(Icon::Instance));
+    if !name.is_empty() {
+        crate::a11y::combo(&resp, name, &label, crate::a11y::menu_open(&resp));
+    }
+    let mut picked = None;
+    menu_popup(&resp).width(200.0).show(|ui| {
+        let t = Tokens::get(ui.ctx());
+        let heading = |ui: &mut Ui, text: &str| ui.label(egui::RichText::new(text).font(semibold(11.0)).color(t.text_secondary));
+        let mut pick = |ui: &mut Ui, c: NodeId, name: &str| {
+            let current = cur == Some(c);
+            if menu_item(ui, &format!("{}{name}", if current { "✓ " } else { "" }), "") {
+                if !current {
+                    picked = Some(c);
+                }
+                ui.close();
+            }
+        };
+        let preferred: Vec<(NodeId, String)> = preferred.iter().filter_map(|c| doc.node(*c).map(|n| (*c, n.name.clone()))).collect();
+        if !preferred.is_empty() {
+            heading(ui, tr("Preferred"));
+            for (c, name) in &preferred {
+                pick(ui, *c, name);
+            }
+            heading(ui, tr("All components"));
+        }
+        egui::ScrollArea::vertical().max_height(320.0).show(ui, |ui| {
+            for (c, name) in comps {
+                pick(ui, *c, name);
+            }
+        });
+    });
+    (resp, picked)
+}
+
 fn prop_label(ui: &mut Ui, name: &str, icon: Icon) {
     let t = Tokens::get(ui.ctx());
     let (r, _) = ui.allocate_exact_size(vec2(84.0, 20.0), Sense::hover());
diff --git a/crates/ui-egui/src/component_props_reorder_tests.rs b/crates/ui-egui/src/component_props_reorder_tests.rs
new file mode 100644
index 000000000..729185ce7
--- /dev/null
+++ b/crates/ui-egui/src/component_props_reorder_tests.rs
@@ -0,0 +1,125 @@
+//! Dragging variant properties in a component set's Properties section, driven through egui
+//! headless: a property dragged by its left margin moves in one undo step (its values go with it,
+//! instances follow), its fields don't start a drag, and Escape cancels.
+
+use egui::{Event, Pos2, vec2};
+use figcraft_doc::NodeId;
+use figcraft_engine::Session;
+use serde_json::json;
+
+use crate::layers_drag_tests::Ui;
+use crate::list_drag::grip_id;
+
+fn id(v: serde_json::Value) -> NodeId {
+    NodeId(v["id"].as_u64().unwrap())
+}
+
+/// A selected set whose variants list Size then State (two values each), a shared boolean "Icon",
+/// and an instance of the set. Returns (ui, set, instance).
+fn setup() -> (Ui, NodeId, NodeId) {
+    let mut s = Session::new();
+    let mut variants = Vec::new();
+    for (k, name) in ["Size=Small, State=Default", "Size=Large, State=Default", "Size=Small, State=Hover"].iter().enumerate() {
+        let f = id(s.execute("frame.create", &json!({"x": 0, "y": k * 60, "width": 80, "height": 40, "name": name})).unwrap());
+        variants.push(id(s.execute("component.create", &json!({"ids": [f]})).unwrap()));
+    }
+    let set = id(s.execute("component.combineVariants", &json!({"ids": variants})).unwrap());
+    s.execute("component.addProperty", &json!({"id": set, "name": "Icon", "type": "boolean", "default": true})).unwrap();
+    let inst = id(s.execute("instance.create", &json!({"component": set, "x": 400, "y": 0})).unwrap());
+    s.execute("select.set", &json!({"ids": [set]})).unwrap();
+    (Ui::new(s), set, inst)
+}
+
+/// Property names of `id` (a set or an instance), in the order they're listed.
+fn names(u: &mut Ui, id: NodeId) -> Vec<String> {
+    let props = u.app.session.execute("component.properties", &json!({"id": id})).unwrap();
+    props["properties"].as_array().unwrap().iter().map(|p| p["name"].as_str().unwrap().to_string()).collect()
+}
+
+fn undo_len(u: &Ui) -> usize {
+    u.app.session.ds().unwrap().history.undo.len()
+}
+
+/// The middle of the grip of variant property `index` (as laid out last frame).
+fn grip(u: &Ui, set: NodeId, index: usize) -> Option<Pos2> {
+    u.ctx.read_response(grip_id(("variant_props", set), index)).map(|r| r.rect.center())
+}
+
+/// Press at `from`, move to `to` in small steps, and leave the button down.
+fn drag(u: &mut Ui, from: Pos2, to: Pos2) {
+    u.button(from, true);
+    for k in 1..=10 {
+        u.frame(vec![Event::PointerMoved(from + (to - from) * (k as f32 / 10.0))]);
+    }
+}
+
+#[test]
+fn dragging_a_variant_property_reorders_it_in_one_step() {
+    let (mut u, set, inst) = setup();
+    assert_eq!(names(&mut u, set), ["Size", "State", "Icon"]);
+    let (size, state) = (grip(&u, set, 0).expect("variant properties have a grip"), grip(&u, set, 1).unwrap());
+    assert!(size.y < state.y, "listed in order");
+    let undo = undo_len(&u);
+    // State above Size.
+    let to = size - vec2(0.0, 12.0);
+    drag(&mut u, state, to);
+    assert_eq!(names(&mut u, set), ["Size", "State", "Icon"], "nothing moves before the drop");
+    u.button(to, false);
+    assert_eq!(names(&mut u, set), ["State", "Size", "Icon"]);
+    assert_eq!(names(&mut u, inst), ["State", "Size", "Icon"], "the instance lists the new order");
+    let doc = u.app.session.doc().unwrap();
+    let first = doc.node(set).unwrap().children[0];
+    assert!(doc.node(first).unwrap().name.starts_with("State="), "{}", doc.node(first).unwrap().name);
+    assert_eq!(undo_len(&u), undo + 1);
+    assert!(u.app.ui.last_error.is_none(), "{:?}", u.app.ui.last_error);
+    // Dropped where it is: nothing changes.
+    u.frame(vec![]);
+    u.frame(vec![]);
+    let g = grip(&u, set, 0).unwrap();
+    drag(&mut u, g, g + vec2(0.0, 6.0));
+    u.button(g + vec2(0.0, 6.0), false);
+    assert_eq!(undo_len(&u), undo + 1);
+    assert!(u.app.session.undo().unwrap());
+    assert_eq!(names(&mut u, set), ["Size", "State", "Icon"]);
+}
+
+#[test]
+fn a_property_dropped_under_the_last_ones_values_lands_last() {
+    let (mut u, set, _) = setup();
+    let size = grip(&u, set, 0).unwrap();
+    // State's header is 32 high and its value row 30 under it: 58 down is on the value row, below
+    // the header's half-row slack, so only an area that takes in the values counts it.
+    let state = u.ctx.read_response(grip_id(("variant_props", set), 1)).unwrap().rect;
+    let to = Pos2::new(size.x, state.min.y + 58.0);
+    drag(&mut u, size, to);
+    u.button(to, false);
+    assert_eq!(names(&mut u, set), ["State", "Size", "Icon"]);
+}
+
+#[test]
+fn pressing_the_name_field_does_not_start_a_drag() {
+    // A guard: on main there's no grip at all; it fails if the whole row becomes a drag handle.
+    let (mut u, set, _) = setup();
+    let (size, state) = (grip(&u, set, 0).unwrap(), grip(&u, set, 1).unwrap());
+    let undo = undo_len(&u);
+    let field = size + vec2(60.0, 0.0);
+    drag(&mut u, field, Pos2::new(field.x, state.y + 40.0));
+    u.button(Pos2::new(field.x, state.y + 40.0), false);
+    assert_eq!(names(&mut u, set), ["Size", "State", "Icon"]);
+    assert_eq!(undo_len(&u), undo);
+}
+
+#[test]
+fn escape_cancels_a_property_drag_and_keeps_the_selection() {
+    // A guard: the cancel comes from the shared list drag.
+    let (mut u, set, _) = setup();
+    let (size, state) = (grip(&u, set, 0).unwrap(), grip(&u, set, 1).unwrap());
+    let undo = undo_len(&u);
+    let to = size - vec2(0.0, 12.0);
+    drag(&mut u, state, to);
+    u.frame(vec![Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() }]);
+    u.button(to, false);
+    assert_eq!(names(&mut u, set), ["Size", "State", "Icon"]);
+    assert_eq!(undo_len(&u), undo);
+    assert_eq!(u.app.session.ds().unwrap().selection, [set], "the Escape only cancels the drag");
+}
diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rs
index 7a196cf27..edd9fff78 100644
--- a/crates/ui-egui/src/control.rs
+++ b/crates/ui-egui/src/control.rs
@@ -15,9 +15,11 @@
 //!   for the frames that follow (all false: released); `gamepad` presses a controller button in the
 //!   prototype playing (presenter or preview pane)
 //! - `ui.menu.invoke {id}` — a menu item exactly like clicking it (may open a dialog)
-//! - `ui.set {rightTab?, leftTab?, theme?, home?, homeSection?, homeRecentsView?, homeRecentsSort?, homeRecentsOrder?, palette?, focusRegion?, preview?, presentScroll?, …}`
-//! - `ui.screenshot {path}` — PNG of the window (needs a visible window)
-//! - `ui.render {path, scale?, ids?}` — PNG of the document (no UI chrome; works without a window)
+//! - `ui.set {rightTab?, leftTab?, theme?, home?, homeSection?, homeSearch?, homeRecentsView?, homeRecentsSort?, homeRecentsOrder?, palette?, focusRegion?, preview?, presentScroll?, …}`
+//! - `ui.screenshot {path?}` — PNG of the window (needs a visible window), written to `path` or
+//!   returned as base64 `data`
+//! - `ui.render {path?, scale?, ids?}` — PNG of the document (no UI chrome; works without a
+//!   window), written to `path` or returned as base64 `data`
 //! - `window.new {path?, index?}` → `{window}` / `window.list {}` / `window.focus {id}` — several
 //!   windows (desktop)
 //! - `app.quit {}`
@@ -55,7 +57,8 @@ impl ControlRequest {
 /// Pending screenshot replies.
 pub struct PendingShot {
     pub id: Value,
-    pub path: String,
+    /// Where to write the PNG; `None`: return it as data.
+    pub path: Option<String>,
     pub reply: std::sync::mpsc::Sender<ControlReply>,
     /// When it was asked for (UI clock, seconds).
     pub since: f64,
@@ -88,7 +91,7 @@ pub fn drain(app: &mut FigApp, ctx: &Context) {
             if p.viewport != *vp {
                 return true;
             }
-            let res = save_color_image(img, &p.path).map(|_| json!({"path": p.path, "width": img.size[0], "height": img.size[1]}));
+            let res = shot_reply(img, p.path.as_deref());
             let _ = p.reply.send(ControlReply { id: p.id.clone(), result: res });
             false
         });
@@ -110,7 +113,7 @@ pub fn drain(app: &mut FigApp, ctx: &Context) {
             continue;
         }
         if r.method == "ui.screenshot" {
-            let path = r.params.get("path").and_then(Value::as_str).unwrap_or("figcraft-screenshot.png").to_string();
+            let path = r.params.get("path").and_then(Value::as_str).map(str::to_string);
             let viewport = ctx.viewport_id();
             list.lock().unwrap_or_else(std::sync::PoisonError::into_inner).push(PendingShot { id: r.id, path, reply: r.reply, since: now, viewport });
             ctx.send_viewport_cmd(egui::ViewportCommand::Screenshot(egui::UserData::default()));
@@ -136,8 +139,10 @@ pub fn drain(app: &mut FigApp, ctx: &Context) {
     }
 }
 
-/// Methods that need no frame drawn (#269): a hidden window answers them too.
-const NO_FRAME: &[&str] = &["engine.execute", "engine.commands", "document.inspect", "node.get", "window.list", "ui.render"];
+/// Methods only a drawn frame can answer: a capture of the window, raw window input and a new
+/// window (the main window's frame opens it). Everything else acts on the app's state, which a
+/// hidden window answers without a frame (#269, #720).
+const NEEDS_FRAME: &[&str] = &["ui.screenshot", "ui.input", "window.new"];
 
 /// Whether window `id` draws no frames now: minimised, or covered by other windows (on macOS also
 /// on another Space).
@@ -147,10 +152,11 @@ fn hidden(ctx: &Context, id: u64) -> bool {
 
 /// A hidden window (minimised, or covered by other windows) draws no frames, but the desktop app's
 /// `logic` still runs, for the main window even while every window is hidden: it answers the
-/// requests for any hidden window that need no frame, in that window's file, so an attached agent
-/// can edit, inspect and save. The rest (screenshots, input, the interface's own state) wait for the
-/// window to show; another window on screen is asked to draw, which the main window's frame would
-/// do but doesn't while it is hidden. A request for a window that doesn't exist is an error at once.
+/// requests for any hidden window, in that window's file, so an attached agent can edit, inspect,
+/// type and save while the app is out of sight. What needs a frame ([`NEEDS_FRAME`]) is an error at
+/// once instead of waiting for the window to show. A request for a window on screen waits for its
+/// frame; another window on screen is asked to draw, which the main window's frame would do but
+/// doesn't while it is hidden. A request for a window that doesn't exist is an error at once.
 pub fn drain_hidden(app: &mut FigApp, ctx: &Context) {
     for r in std::mem::take(&mut app.control_queue) {
         if r.is_cancelled() {
@@ -161,15 +167,21 @@ pub fn drain_hidden(app: &mut FigApp, ctx: &Context) {
             let _ = r.reply.send(ControlReply { id: r.id, result: Err(format!("no window {target}")) });
             continue;
         }
-        if !hidden(ctx, target) || !NO_FRAME.contains(&r.method.as_str()) {
+        if !hidden(ctx, target) {
             // Another window on screen draws only when asked: while the main window is hidden no
             // frame of it does that (`drain`), so ask here.
-            if target != app.windows.current && !hidden(ctx, target) {
+            if target != app.windows.current {
                 ctx.request_repaint_of(crate::windows::viewport(target));
             }
             app.control_queue.push(r);
             continue;
         }
+        if NEEDS_FRAME.contains(&r.method.as_str()) {
+            let error =
+                format!("window {target} is minimised or hidden: `{}` needs it on screen (`ui.render` draws the document without it)", r.method);
+            let _ = r.reply.send(ControlReply { id: r.id, result: Err(error) });
+            continue;
+        }
         // Outside a frame, so outside the frame's guard: within the window's swap, a panic still
         // ends in recovery copies and leaves every window its own state.
         let res = crate::windows::as_window(app, target, |app| {
@@ -181,14 +193,28 @@ pub fn drain_hidden(app: &mut FigApp, ctx: &Context) {
     }
 }
 
-fn save_color_image(img: &egui::ColorImage, path: &str) -> Result<(), String> {
+/// A screenshot's reply: the PNG written to `path` (through the automation roots, when the app
+/// has them), or returned as base64 `data`.
+fn shot_reply(img: &egui::ColorImage, path: Option<&str>) -> Result<Value, String> {
     let [w, h] = img.size;
     let mut rgba = Vec::with_capacity(w * h * 4);
     for p in &img.pixels {
         rgba.extend_from_slice(&p.to_srgba_unmultiplied());
     }
     let buf = image::RgbaImage::from_raw(w as u32, h as u32, rgba).ok_or("bad screenshot buffer")?;
-    buf.save(path).map_err(|e| e.to_string())
+    let mut png = std::io::Cursor::new(Vec::new());
+    buf.write_to(&mut png, image::ImageFormat::Png).map_err(|e| e.to_string())?;
+    let png = png.into_inner();
+    match path {
+        Some(path) => {
+            figcraft_engine::file_access::write(path, &png).map_err(|e| e.to_string())?;
+            Ok(json!({"path": path, "width": w, "height": h}))
+        }
+        None => {
+            use base64::Engine as _;
+            Ok(json!({"format": "png", "width": w, "height": h, "data": base64::engine::general_purpose::STANDARD.encode(&png)}))
+        }
+    }
 }
 
 /// A controller button given as its standard-layout index, its key trigger name ("Gamepad A") or
@@ -213,6 +239,7 @@ pub fn handle(app: &mut FigApp, ctx: &Context, method: &str, p: &Value) -> Resul
             let cmd = p.get("command").and_then(Value::as_str).ok_or("`command` required")?;
             let params = p.get("params").cloned().unwrap_or(json!({}));
             let r = app.session.execute(cmd, &params).map_err(|e| e.to_string());
+            app.clear_comment_draft_after_tool_set(cmd, r.is_ok());
             // Programmatic calls never open dialogs.
             app.session.ui_requests.retain(|u| !u.kind.starts_with("dialog."));
             app.handle_ui_requests();
@@ -309,7 +336,8 @@ pub fn handle(app: &mut FigApp, ctx: &Context, method: &str, p: &Value) -> Resul
                 .ok_or("`events` required: [{move|down|up: [x, y]} | {key, shift?, alt?, cmd?} | {text} | {leave: true}]")?;
             let pos = |v: &Value| -> Option<egui::Pos2> {
                 let a = v.as_array()?;
-                Some(egui::pos2(a.first()?.as_f64()? as f32, a.get(1)?.as_f64()? as f32))
+                let p = egui::pos2(a.first()?.as_f64()? as f32, a.get(1)?.as_f64()? as f32);
+                p.is_finite().then_some(p)
             };
             let mut events = Vec::new();
             let mut pads = Vec::new();
@@ -403,6 +431,9 @@ pub fn handle(app: &mut FigApp, ctx: &Context, method: &str, p: &Value) -> Resul
             if let Some(section) = p.get("homeSection").and_then(Value::as_str).and_then(crate::home::Section::parse) {
                 app.ui.home_view.section = section;
             }
+            if let Some(query) = p.get("homeSearch").and_then(Value::as_str) {
+                app.ui.home_view.file_query = query.chars().take(256).collect();
+            }
             if let Some(view) = p.get("homeRecentsView").and_then(Value::as_str).and_then(crate::home_recents::View::parse) {
                 view.store(&mut app.session.prefs);
             }
@@ -414,7 +445,7 @@ pub fn handle(app: &mut FigApp, ctx: &Context, method: &str, p: &Value) -> Resul
                 crate::home_recents::Sort { descending: order == "desc", ..sort }.store(&mut app.session.prefs);
             }
             if let Some(h) = p.get("palette").and_then(Value::as_bool) {
-                app.ui.palette = if h { Some(String::new()) } else { None };
+                crate::menus::set_palette(&mut app.ui, h);
             }
             // true / false, or a top-level menu to open it at ("Plugins").
             match p.get("mainMenu") {
@@ -603,12 +634,16 @@ pub fn handle(app: &mut FigApp, ctx: &Context, method: &str, p: &Value) -> Resul
             if let Some(v) = p.get("exportPreview").and_then(Value::as_bool) {
                 app.ui.export_thumb = v;
             }
-            // Dev Mode's compare view: a ready-for-dev frame or section opens it, null closes it;
+            // Dev Mode's compare view: a frame or section opens it, null closes it; `devCompareVersion`
+            // the saved version it compares with (null: when it was marked ready for dev),
             // `devCompareMode` is sideBySide or overlay, `devCompareSplit` the overlay slider (0–1).
             if let Some(v) = p.get("devCompare") {
-                app.ui.dev.compare = figcraft_engine::params::id_of(v).map(crate::dev_compare::CompareView::new);
+                app.ui.dev.compare = figcraft_engine::params::id_of(v).map(|id| crate::dev_compare::CompareView::new(id, None));
             }
             if let Some(c) = app.ui.dev.compare.as_mut() {
+                if let Some(v) = p.get("devCompareVersion") {
+                    c.version = v.as_str().map(str::to_string);
+                }
                 match p.get("devCompareMode").and_then(Value::as_str) {
                     Some("overlay") => c.mode = crate::dev_compare::Mode::Overlay,
                     Some("sideBySide") => c.mode = crate::dev_compare::Mode::SideBySide,
@@ -644,11 +679,13 @@ pub fn handle(app: &mut FigApp, ctx: &Context, method: &str, p: &Value) -> Resul
             Ok(app.inspect())
         }
         "ui.render" => {
-            let path = p.get("path").and_then(Value::as_str).ok_or("`path` required")?;
             let scale = p.get("scale").and_then(Value::as_f64).unwrap_or(1.0);
             let ids: Vec<figcraft_doc::NodeId> =
                 p.get("ids").and_then(Value::as_array).map(|a| a.iter().filter_map(figcraft_engine::params::id_of).collect()).unwrap_or_default();
-            let mut params = json!({"format": "png", "scale": scale, "path": path});
+            let mut params = json!({"format": "png", "scale": scale});
+            if let Some(path) = p.get("path").and_then(Value::as_str) {
+                params["path"] = json!(path);
+            }
             if !ids.is_empty() {
                 params["ids"] = json!(ids);
             }
@@ -723,3 +760,7 @@ fn pointer(app: &mut FigApp, p: &Value) -> Result<Value, String> {
     app.handle_ui_requests();
     Ok(json!({"selection": app.session.selection(), "tool": app.session.tool.tool.id()}))
 }
+
+#[cfg(test)]
+#[path = "control_roots_tests.rs"]
+mod roots_tests;
diff --git a/crates/ui-egui/src/control_roots_tests.rs b/crates/ui-egui/src/control_roots_tests.rs
new file mode 100644
index 000000000..763f00e61
--- /dev/null
+++ b/crates/ui-egui/src/control_roots_tests.rs
@@ -0,0 +1,102 @@
+//! An app started with automation roots: its frames and control requests read and write only
+//! inside them, and captures come back as data without a path.
+
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use figcraft_engine::Session;
+use figcraft_engine::file_access::Roots;
+use serde_json::{Value, json};
+
+use crate::{FigApp, NoServices};
+
+struct Dirs(PathBuf);
+
+impl Drop for Dirs {
+    fn drop(&mut self) {
+        let _ = std::fs::remove_dir_all(&self.0);
+    }
+}
+
+fn confined_app(name: &str) -> (FigApp, Dirs) {
+    let d = std::env::temp_dir().join(format!("figcraft-ui-roots-{name}-{}", std::process::id()));
+    for sub in ["out", "outside"] {
+        std::fs::create_dir_all(d.join(sub)).unwrap();
+    }
+    let mut s = Session::new();
+    s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 20, "height": 10})).unwrap();
+    let mut app = FigApp::new(s, Box::new(NoServices));
+    app.automation_roots = Some(Arc::new(Roots::new(&[], &[d.join("out").to_string_lossy().into_owned()]).unwrap()));
+    (app, Dirs(d))
+}
+
+/// Control method `method` handled as the desktop app does: inside the frame guard.
+fn handle(app: &mut FigApp, method: &str, p: Value) -> Result<Value, String> {
+    let ctx = egui::Context::default();
+    let mut res = Err("not run".to_string());
+    crate::windows::guard(app, &ctx, |app| res = super::handle(app, &ctx, method, &p));
+    res
+}
+
+#[test]
+fn a_confined_app_writes_only_inside_its_write_root() {
+    let (mut app, d) = confined_app("write");
+    let p = |rel: &str| d.0.join(rel).to_string_lossy().into_owned();
+    let e = handle(&mut app, "ui.render", json!({"path": p("outside/r.png")})).unwrap_err();
+    assert!(e.contains("automation path rejected"), "{e}");
+    let e =
+        handle(&mut app, "engine.execute", json!({"command": "file.export", "params": {"format": "svg", "path": p("outside/r.svg")}})).unwrap_err();
+    assert!(e.contains("automation path rejected"), "{e}");
+    assert!(handle(&mut app, "ui.render", json!({"path": p("out/r.png")})).is_ok());
+    // Without a path the PNG comes back as data.
+    let r = handle(&mut app, "ui.render", json!({})).unwrap();
+    assert!(r["data"].as_str().is_some_and(|d| !d.is_empty()), "{r}");
+    assert_eq!(std::fs::read_dir(d.0.join("outside")).unwrap().count(), 0);
+    assert!(d.0.join("out/r.png").is_file());
+    // Outside the guard (the app's own work) nothing is confined.
+    assert!(app.session.execute("file.export", &json!({"format": "svg", "path": p("outside/own.svg")})).is_ok());
+}
+
+#[test]
+fn a_confined_app_saves_only_inside_its_write_root() {
+    // #836: saving over the control channel, both as a new file and to the current one.
+    let (mut app, d) = confined_app("save");
+    let p = |rel: &str| d.0.join(rel).to_string_lossy().into_owned();
+    for cmd in ["file.saveAs", "file.save"] {
+        let e = handle(&mut app, "engine.execute", json!({"command": cmd, "params": {"path": p("outside/a.figcraft")}})).unwrap_err();
+        assert!(e.contains("automation path rejected"), "{cmd}: {e}");
+        let e = handle(&mut app, "engine.execute", json!({"command": cmd, "params": {"path": p("out/../outside/b.figcraft")}})).unwrap_err();
+        assert!(e.contains("automation path rejected"), "{cmd}: {e}");
+    }
+    assert_eq!(std::fs::read_dir(d.0.join("outside")).unwrap().count(), 0, "nothing written outside the root");
+    handle(&mut app, "engine.execute", json!({"command": "file.saveAs", "params": {"path": p("out/in.figcraft")}})).unwrap();
+    assert!(d.0.join("out/in.figcraft").is_file());
+    // Saving again goes to the same file, inside the root.
+    handle(&mut app, "engine.execute", json!({"command": "file.save", "params": {}})).unwrap();
+}
+
+#[test]
+fn window_captures_are_written_through_the_roots_or_returned() {
+    let (app, d) = confined_app("capture");
+    let img = egui::ColorImage::filled([3, 2], egui::Color32::RED);
+    let roots = app.automation_roots.clone();
+    let out = d.0.join("out/shot.png").to_string_lossy().into_owned();
+    let outside = d.0.join("outside/shot.png").to_string_lossy().into_owned();
+    figcraft_engine::file_access::confined(roots.as_ref(), || {
+        assert!(super::shot_reply(&img, Some(&outside)).unwrap_err().contains("automation path rejected"));
+        assert_eq!(super::shot_reply(&img, Some(&out)).unwrap()["width"], 3);
+        let data = super::shot_reply(&img, None).unwrap();
+        assert_eq!((data["format"].as_str(), data["height"].as_u64()), (Some("png"), Some(2)));
+    });
+    assert!(d.0.join("out/shot.png").is_file() && !d.0.join("outside/shot.png").exists());
+}
+
+#[test]
+fn ui_input_rejects_non_finite_coordinates() {
+    let (mut app, _d) = confined_app("input");
+    for ev in [json!({"move": [1e300, 5]}), json!({"down": [5, 1e300]}), json!({"scroll": [1e300, 0]})] {
+        let r = handle(&mut app, "ui.input", json!({"events": [ev]}));
+        assert!(r.is_err(), "{ev}: {r:?}");
+    }
+    assert!(app.control_input.iter().all(|e| !matches!(e, egui::Event::PointerMoved(p) if !p.is_finite())));
+}
diff --git a/crates/ui-egui/src/corner_individual_tests.rs b/crates/ui-egui/src/corner_individual_tests.rs
new file mode 100644
index 000000000..5a36f0738
--- /dev/null
+++ b/crates/ui-egui/src/corner_individual_tests.rs
@@ -0,0 +1,75 @@
+//! Individual corners in the Design panel, driven headless: the four corner fields sit where
+//! their corners are (top left, top right / bottom left, bottom right) and each sets its own.
+
+use egui::accesskit::Role;
+use egui::{Event, Id, Key, Modifiers, Pos2, Rect, pos2};
+use figcraft_doc::NodeId;
+use figcraft_engine::Session;
+use serde_json::json;
+
+use crate::layers_drag_tests::Ui;
+
+/// A rectangle rounded only on its left corners (top left and bottom left 30), selected.
+fn scene() -> (Ui, NodeId) {
+    let mut s = Session::new();
+    let r = NodeId(s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 200, "height": 120})).unwrap()["id"].as_u64().unwrap());
+    s.execute("node.set", &json!({"ids": [r], "props": {"topLeftRadius": 30, "bottomLeftRadius": 30}})).unwrap();
+    s.execute("select.set", &json!({"ids": [r]})).unwrap();
+    (Ui::new(s), r)
+}
+
+/// The rectangle's radii as `[top left, top right, bottom right, bottom left]`.
+fn radii(u: &Ui, r: NodeId) -> [f64; 4] {
+    u.app.session.doc().unwrap().node(r).unwrap().corners.radii
+}
+
+/// A full press-and-release at `p`, then settling one frame.
+fn click(u: &mut Ui, p: Pos2) {
+    u.button(p, true);
+    u.button(p, false);
+    u.frame(vec![]);
+}
+
+/// A press-and-release of Enter, committing the focused number field.
+fn enter(u: &mut Ui) {
+    u.frame(vec![
+        Event::Key { key: Key::Enter, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE },
+        Event::Key { key: Key::Enter, physical_key: None, pressed: false, repeat: false, modifiers: Modifiers::NONE },
+    ]);
+}
+
+/// The middle of the toggle button named `label`, found in the AccessKit tree.
+fn named_button(u: &mut Ui, label: &str) -> Pos2 {
+    u.ctx.enable_accesskit();
+    u.frame(vec![]);
+    let out = u.frame_output(vec![]);
+    let nodes = out.platform_output.accesskit_update.expect("an AccessKit update").nodes;
+    let n = nodes.iter().map(|(_, n)| n).find(|n| n.role() == Role::Button && n.label() == Some(label)).expect(label);
+    let b = n.bounds().expect("bounds");
+    pos2(((b.x0 + b.x1) / 2.0) as f32, ((b.y0 + b.y1) / 2.0) as f32)
+}
+
+/// Corner field `k` (an index into the radii).
+fn field(u: &Ui, k: usize) -> Rect {
+    u.ctx.read_response(Id::new(("corner", k)).with("field")).expect("corner field shows").rect
+}
+
+/// The fields sit at their corners, and typing in the bottom right one sets only that corner in a
+/// single undo step (#1002: the bottom row showed bottom right on the left).
+#[test]
+fn corner_fields_sit_at_their_corners_and_set_their_own() {
+    let (mut u, r) = scene();
+    let t = named_button(&mut u, "Individual corners");
+    click(&mut u, t);
+    let (tl, tr, br, bl) = (field(&u, 0).center(), field(&u, 1).center(), field(&u, 2).center(), field(&u, 3).center());
+    assert!(tl.x < tr.x && (tl.y - tr.y).abs() < 1.0, "top row: top left, then top right");
+    assert!(bl.x < br.x && (bl.y - br.y).abs() < 1.0, "bottom row: bottom left, then bottom right");
+    assert!(bl.y > tl.y && (bl.x - tl.x).abs() < 1.0, "bottom left sits under top left");
+    let history = u.app.session.undo_depth().0;
+    click(&mut u, br);
+    u.frame(vec![Event::Text("12".into())]);
+    enter(&mut u);
+    u.frame(vec![]);
+    assert_eq!(radii(&u, r), [30.0, 0.0, 12.0, 30.0]);
+    assert_eq!(u.app.session.undo_depth().0, history + 1);
+}
diff --git a/crates/ui-egui/src/credits_tests.rs b/crates/ui-egui/src/credits_tests.rs
index 993aa44c2..eebce8419 100644
--- a/crates/ui-egui/src/credits_tests.rs
+++ b/crates/ui-egui/src/credits_tests.rs
@@ -1,5 +1,5 @@
 //! The credits tabs as drawn, through egui headless with FigCraft's fonts and theme: every column
-//! fits the About window, switching the Contributors view keeps its size, clicking a header sorts
+//! keeps its measured width and scrolls when needed, switching the Contributors view keeps its size, clicking a header sorts
 //! by it, and empty tables (no contributors.json) draw a note instead.
 
 use egui::{Event, Pos2, RawInput, Rect, vec2};
@@ -100,17 +100,73 @@ impl Ui {
     }
 }
 
+/// Keep measured columns and the name minimum, using horizontal scrolling when the font
+/// needs more than the About window's width. No font is required to have Inter's metrics.
+fn assert_table_columns_fit_or_scroll(u: &mut Ui, widths: &[Option<f32>]) {
+    let mut columns = Vec::new();
+    let mut minimum = 0.0;
+    let mut scroll = 0.0;
+    let mut drawn = Rect::NOTHING;
+    for _ in 0..3 {
+        columns.clear();
+        drawn = u.frame(vec![], |ui| {
+            scroll = ui.spacing().scroll.allocated_width();
+            minimum = widths.iter().flatten().sum::<f32>() + scroll + NAME_MIN_W;
+            credits_table(
+                ui,
+                "credits_width_test",
+                widths,
+                NAME_MIN_W,
+                LIST_HEIGHT,
+                |mut header| {
+                    for i in 0..widths.len() {
+                        header.col(|ui| {
+                            columns.push((ui.max_rect(), ui.clip_rect()));
+                            if i + 1 == widths.len() {
+                                ui.scroll_to_rect_animation(ui.max_rect(), Some(egui::Align::Max), egui::style::ScrollAnimation::none());
+                            }
+                        });
+                    }
+                },
+                |_| {},
+            );
+        });
+    }
+    assert!(drawn.width() <= ABOUT_WIDTH + 0.5, "table viewport grew to {} pt", drawn.width());
+    assert_eq!(columns.len(), widths.len());
+    for ((rect, _), width) in columns.iter().zip(widths) {
+        if let Some(width) = width {
+            assert!((rect.width() - width).abs() < 0.5, "measured column {width} became {} pt", rect.width());
+        } else {
+            assert!(rect.width() >= NAME_MIN_W - 0.5, "name column shrank to {} pt", rect.width());
+        }
+    }
+    let content_width = columns.iter().map(|(rect, _)| rect.width()).sum::<f32>() + scroll;
+    assert!((content_width - ABOUT_WIDTH.max(minimum)).abs() < 0.5, "content needs {minimum} pt, got {content_width}");
+    let (last, clip) = columns.last().unwrap();
+    assert!((last.intersect(*clip).width() - last.width()).abs() < 0.5, "last column cannot be scrolled fully into view: {last:?} in {clip:?}");
+    if minimum <= ABOUT_WIDTH {
+        let (first, clip) = columns.first().unwrap();
+        assert!((first.intersect(*clip).width() - first.width()).abs() < 0.5, "a fitting table scrolled its first column out of view");
+    }
+}
+
 #[test]
-fn every_column_fits_the_about_window() {
-    let mut u = Ui::new();
-    let list = people(8);
-    let refs: Vec<&Contributor> = list.iter().collect();
-    let (fixed, scroll) = u.measure(|ui| (contributor_widths(ui, &refs).iter().flatten().sum::<f32>(), ui.spacing().scroll.allocated_width()));
-    assert!(fixed + scroll + NAME_MIN_W <= ABOUT_WIDTH, "contributor columns need {} pt of {ABOUT_WIDTH}", fixed + scroll + NAME_MIN_W);
-    let models: Vec<Model> = (0..8).map(|i| model(leak(format!("Claude Model {i}")), [228, 45, 6, 2, 2, 1, 1, 1][i])).collect();
-    let rows: Vec<[String; 6]> = models.iter().map(|m| model_cells(m, 482)).collect();
-    let fixed = u.measure(|ui| model_widths(ui, &rows).iter().flatten().sum::<f32>());
-    assert!(fixed + scroll + NAME_MIN_W <= ABOUT_WIDTH, "model columns need {} pt of {ABOUT_WIDTH}", fixed + scroll + NAME_MIN_W);
+fn columns_keep_their_measured_widths_with_different_font_sizes() {
+    for scale in [0.75, 1.0, 1.5] {
+        let mut u = Ui::new();
+        u.ctx.global_style_mut(|style| {
+            style.text_styles.get_mut(&egui::TextStyle::Body).unwrap().size *= scale;
+        });
+        let list = people(8);
+        let refs: Vec<&Contributor> = list.iter().collect();
+        let widths = u.measure(|ui| contributor_widths(ui, &refs));
+        assert_table_columns_fit_or_scroll(&mut u, &widths);
+        let models: Vec<Model> = (0..8).map(|i| model(leak(format!("Claude Model {i}")), [228, 45, 6, 2, 2, 1, 1, 1][i])).collect();
+        let rows: Vec<[String; 6]> = models.iter().map(|m| model_cells(m, 482)).collect();
+        let widths = u.measure(|ui| model_widths(ui, &rows));
+        assert_table_columns_fit_or_scroll(&mut u, &widths);
+    }
 }
 
 #[test]
diff --git a/crates/ui-egui/src/design_paste_tests.rs b/crates/ui-egui/src/design_paste_tests.rs
new file mode 100644
index 000000000..35743a81c
--- /dev/null
+++ b/crates/ui-egui/src/design_paste_tests.rs
@@ -0,0 +1,97 @@
+use figcraft_engine::Session;
+use figcraft_engine::cmd::edit::{CLIP_CLOSE, CLIP_OPEN};
+use serde_json::json;
+
+use crate::{FigApp, Services};
+
+struct Clip {
+    html: String,
+    text: Option<String>,
+}
+
+impl Services for Clip {
+    fn clipboard_get_html(&mut self) -> Option<String> {
+        Some(self.html.clone())
+    }
+    fn clipboard_get_text(&mut self) -> Option<String> {
+        self.text.clone()
+    }
+}
+
+/// The HTML another design app puts on the clipboard for copied layers (a `.fig` canvas inside).
+fn copied_html() -> String {
+    let mut s = Session::new();
+    s.execute("node.create", &json!({"type": "rectangle", "x": 0, "y": 0, "width": 40, "height": 20, "name": "Copied layer"})).unwrap();
+    let r = s.execute("file.export", &json!({"format": "fig"})).unwrap();
+    format!(r#"<span data-buffer="<!--{CLIP_OPEN}{}{CLIP_CLOSE}-->"></span>"#, r["data"].as_str().unwrap())
+}
+
+fn selected_names(app: &FigApp) -> Vec<String> {
+    let doc = app.session.doc().unwrap();
+    app.session.selection().iter().map(|i| doc.node(*i).unwrap().name.clone()).collect()
+}
+
+fn pasted_text(app: &FigApp) -> String {
+    let doc = app.session.doc().unwrap();
+    let id = app.session.selection()[0];
+    doc.node(id).unwrap().kind.text().unwrap().characters.clone()
+}
+
+#[test]
+fn paste_takes_layers_copied_in_another_design_app() {
+    let html = copied_html();
+    let mut app = FigApp::new(Session::new(), Box::new(Clip { html, text: Some(String::new()) }));
+    crate::menus::paste(&mut app, None, None);
+    assert_eq!(selected_names(&app), ["Copied layer"]);
+}
+
+#[test]
+fn paste_here_puts_copied_design_layers_at_the_point() {
+    let html = copied_html();
+    let mut app = FigApp::new(Session::new(), Box::new(Clip { html, text: Some(String::new()) }));
+    crate::menus::paste(&mut app, None, Some((300.0, 200.0)));
+    let id = app.session.selection()[0];
+    let b = app.session.doc().unwrap().world_bounds(id).unwrap();
+    assert_eq!((b.x0, b.y0), (300.0, 200.0));
+}
+
+#[test]
+fn html_from_other_apps_pastes_as_before() {
+    let clip = Clip { html: "<b>Hello</b>".into(), text: Some("Hello".into()) };
+    let mut app = FigApp::new(Session::new(), Box::new(clip));
+    crate::menus::paste(&mut app, None, None);
+    assert_eq!(pasted_text(&app), "Hello");
+}
+
+#[test]
+fn html_that_only_mentions_the_marker_pastes_its_text() {
+    let text = format!("Markers {CLIP_OPEN} and {CLIP_CLOSE} explained");
+    let clip = Clip { html: format!("<p>{text}</p>"), text: Some(text.clone()) };
+    let mut app = FigApp::new(Session::new(), Box::new(clip));
+    crate::menus::paste(&mut app, None, None);
+    assert_eq!(pasted_text(&app), text);
+    assert!(app.ui.last_error.is_none(), "{:?}", app.ui.last_error);
+}
+
+/// A clipboard whose contents the test replaces between pastes.
+struct SharedClip(std::rc::Rc<std::cell::RefCell<Clip>>);
+
+impl Services for SharedClip {
+    fn clipboard_get_html(&mut self) -> Option<String> {
+        Some(self.0.borrow().html.clone())
+    }
+    fn clipboard_get_text(&mut self) -> Option<String> {
+        self.0.borrow().text.clone()
+    }
+}
+
+#[test]
+fn text_copied_after_a_design_paste_pastes_as_text() {
+    let clip = std::rc::Rc::new(std::cell::RefCell::new(Clip { html: copied_html(), text: None }));
+    let mut app = FigApp::new(Session::new(), Box::new(SharedClip(clip.clone())));
+    crate::menus::paste(&mut app, None, None);
+    assert_eq!(selected_names(&app), ["Copied layer"]);
+    *clip.borrow_mut() = Clip { html: String::new(), text: Some("Fresh text".into()) };
+    crate::menus::paste(&mut app, None, None);
+    assert_eq!(pasted_text(&app), "Fresh text");
+}
diff --git a/crates/ui-egui/src/dev_compare.rs b/crates/ui-egui/src/dev_compare.rs
index 2e21eb54a..0fd57aa7b 100644
--- a/crates/ui-egui/src/dev_compare.rs
+++ b/crates/ui-egui/src/dev_compare.rs
@@ -1,12 +1,13 @@
-//! Dev Mode's compare view: a ready-for-dev frame or section as it was when it was marked next to
-//! how it is now (side by side, or one over the other with a slider), the changed layers outlined,
-//! and the list of what changed (`dev.compare`). Rendered once per document version. The branch
-//! review ([`crate::branch_ui`]) shows two versions with the same pieces.
+//! Dev Mode's compare view: a frame or section as it was when it was marked ready for dev, or in
+//! a saved version picked at the bottom, next to how it is now (side by side, or one over the
+//! other with a slider), the changed layers outlined, and the list of what changed
+//! (`dev.compare`). Rendered once per document version. The branch review ([`crate::branch_ui`])
+//! shows two versions with the same pieces.
 
 use std::sync::Arc;
 
 use egui::{Align2, Color32, CornerRadius, Id, Rect, Sense, Stroke, StrokeKind, Ui, pos2, vec2};
-use figcraft_doc::{Document, NodeId};
+use figcraft_doc::{DevStatus, Document, NodeId};
 use figcraft_engine::devcompare::{self, ChangeKind, Comparison, LayerChange};
 use serde_json::json;
 
@@ -38,25 +39,41 @@ pub struct CompareView {
     pub mode: Mode,
     /// Where the overlay slider is (0 = all new, 1 = all old).
     pub split: f32,
+    /// The saved version compared with (its id); `None`: the snapshot from when it was marked
+    /// ready for dev.
+    pub version: Option<String>,
     /// The change row under the pointer (its layer is highlighted).
     hovered: Option<NodeId>,
     cache: Option<Cached>,
 }
 
 impl CompareView {
-    pub fn new(id: NodeId) -> Self {
-        Self { id, mode: Mode::default(), split: 0.5, hovered: None, cache: None }
+    pub fn new(id: NodeId, version: Option<String>) -> Self {
+        Self { id, mode: Mode::default(), split: 0.5, version, hovered: None, cache: None }
+    }
+
+    /// The view `dev.compare {show}` (or `ui.set`) asks for: `data` holds the layer's `id` and the
+    /// `version` to compare with.
+    pub fn requested(data: &serde_json::Value) -> Option<Self> {
+        let id = data.get("id").and_then(figcraft_engine::params::id_of)?;
+        Some(Self::new(id, data.get("version").and_then(serde_json::Value::as_str).map(str::to_string)))
     }
 }
 
-/// What the view shows, built for one version of the document.
+/// What the view shows, built for one version of the document and one "before".
 struct Cached {
     doc: Arc<Document>,
+    version: Option<String>,
+    /// The version's document (read once per version picked).
+    version_doc: Option<Arc<Document>>,
     cmp: Comparison,
     before: Option<Shot>,
     after: Option<Shot>,
 }
 
+/// A saved version as the picker lists it: (id, name, when).
+type VersionRow = (String, String, u64);
+
 /// One version rendered: its texture, the page area it shows and where each listed layer is.
 pub(crate) struct Shot {
     tex: egui::TextureHandle,
@@ -129,15 +146,33 @@ pub fn show(app: &mut FigApp, ctx: &egui::Context) {
     let Some(mut view) = app.ui.dev.compare.take() else { return };
     let Ok(ds) = app.session.ds() else { return };
     let doc = ds.doc.clone();
-    if doc.node(view.id).is_none() {
+    let Some(node) = doc.node(view.id) else { return };
+    let ready = node.dev_status == DevStatus::ReadyForDev;
+    // Newest first; a version deleted meanwhile falls back to the ready-for-dev snapshot (or the
+    // newest version, for a layer that isn't ready for dev).
+    let versions: Vec<VersionRow> = ds.versions.iter().rev().map(|v| (v.id.clone(), v.name.clone(), v.time)).collect();
+    if view.version.as_ref().is_some_and(|v| !versions.iter().any(|(id, ..)| id == v)) || (!ready && view.version.is_none()) {
+        view.version = if ready { None } else { versions.first().map(|(id, ..)| id.clone()) };
+    }
+    if view.version.is_none() && !ready {
         return;
     }
-    if view.cache.as_ref().is_none_or(|c| !Arc::ptr_eq(&c.doc, &doc)) {
-        let cmp = devcompare::compare(&doc, view.id);
-        let before = devcompare::before_doc(&doc, view.id).and_then(|b| Shot::of_changes(ctx, &b, view.id, &cmp.changes, true));
+    if view.cache.as_ref().is_none_or(|c| !Arc::ptr_eq(&c.doc, &doc) || c.version != view.version) {
+        let kept = view.cache.take().filter(|c| c.version == view.version).and_then(|c| c.version_doc);
+        let version_doc = match &view.version {
+            Some(v) => kept.or_else(|| ds.versions.iter().find(|x| x.id == *v).and_then(|x| x.document().ok())),
+            None => None,
+        };
+        let (cmp, before) = match &version_doc {
+            Some(b) => (devcompare::compare_with(b, &doc, view.id), Some(b.clone())),
+            None if view.version.is_some() => (devcompare::empty(&doc, view.id), None),
+            None => (devcompare::compare(&doc, view.id), devcompare::before_doc(&doc, view.id).map(Arc::new)),
+        };
+        let before = before.and_then(|b| Shot::of_changes(ctx, &b, view.id, &cmp.changes, true));
         let after = Shot::of_changes(ctx, &doc, view.id, &cmp.changes, false);
-        view.cache = Some(Cached { doc: doc.clone(), cmp, before, after });
+        view.cache = Some(Cached { doc: doc.clone(), version: view.version.clone(), version_doc, cmp, before, after });
     }
+    let version_name = view.version.as_ref().and_then(|v| versions.iter().find(|(id, ..)| id == v)).map(|(_, name, _)| name.clone());
     let t = Tokens::get(ctx);
     let screen = ctx.content_rect();
     let size = vec2(1120.0_f32.min(screen.width() - 64.0).max(560.0), 700.0_f32.min(screen.height() - 96.0).max(320.0));
@@ -162,27 +197,16 @@ pub fn show(app: &mut FigApp, ctx: &egui::Context) {
             ui.horizontal_top(|ui| {
                 let images_w = size.x - LIST_W - 1.0;
                 let (r, _) = ui.allocate_exact_size(vec2(images_w, body_h), Sense::hover());
-                if !cache.cmp.snapshot {
-                    let msg = if cache.cmp.changed {
-                        tr(
-                            "What this changed from isn't known: it changed before FigCraft kept a copy of ready-for-dev frames. Resolve the change (or mark it ready again) to compare from now on.",
-                        )
-                    } else {
-                        tr("Nothing changed since this was marked ready for dev.")
-                    };
-                    message(ui, &t, r, msg);
-                } else if let (Some(before), Some(after)) = (&cache.before, &cache.after) {
-                    images(ui, &t, r, [(before, tr("Before")), (after, tr("Now"))], view.mode, &mut view.split, view.hovered);
-                }
+                compared(ui, r, cache, version_name.as_deref(), view.mode, &mut view.split, view.hovered);
                 let (line, _) = ui.allocate_exact_size(vec2(1.0, body_h), Sense::hover());
                 ui.painter().rect_filled(line, CornerRadius::ZERO, t.border);
                 ui.allocate_ui_with_layout(vec2(LIST_W, body_h), top_down, |ui| {
-                    if let Some(a) = list(ui, &t, &cache.cmp, &mut view.hovered) {
+                    if let Some(a) = list(ui, &t, &cache.cmp, view.version.is_some(), &mut view.hovered) {
                         action = Some(a);
                     }
                 });
             });
-            if let Some(a) = footer(ui, &t, &cache.cmp) {
+            if let Some(a) = footer(ui, &t, &cache.cmp, ready, &versions, view.version.as_deref()) {
                 action = Some(a);
             }
         });
@@ -197,6 +221,7 @@ pub fn show(app: &mut FigApp, ctx: &egui::Context) {
             }
         }
         Some(Action::Close) => open = false,
+        Some(Action::Against(v)) => view.version = v,
         None => {}
     }
     if open {
@@ -204,10 +229,37 @@ pub fn show(app: &mut FigApp, ctx: &egui::Context) {
     }
 }
 
+/// The images area: before and after, or a note saying why there is nothing to show.
+/// `version_name`: the saved version compared with (`None`: the ready-for-dev snapshot).
+fn compared(ui: &mut Ui, r: Rect, cache: &Cached, version_name: Option<&str>, mode: Mode, split: &mut f32, hovered: Option<NodeId>) {
+    let t = &Tokens::get(ui.ctx());
+    let against = version_name.is_some();
+    if !cache.cmp.snapshot {
+        let msg = if against {
+            tr("This version can't be read.")
+        } else if cache.cmp.changed {
+            tr(
+                "What this changed from isn't known: it changed before FigCraft kept a copy of ready-for-dev frames. Resolve the change (or mark it ready again) to compare from now on.",
+            )
+        } else {
+            tr("Nothing changed since this was marked ready for dev.")
+        };
+        message(ui, t, r, msg);
+    } else if !cache.cmp.changed && against {
+        message(ui, t, r, tr("Nothing changed since this version."));
+    } else if let (Some(before), Some(after)) = (&cache.before, &cache.after) {
+        images(ui, t, r, [(before, version_name.unwrap_or(tr("Before"))), (after, tr("Now"))], mode, split, hovered);
+    } else if against {
+        message(ui, t, r, tr("This version doesn't have it: all of it is new."));
+    }
+}
+
 enum Action {
     Select(NodeId),
     Resolve,
     Close,
+    /// Compare with this saved version (`None`: the snapshot from when it was marked ready).
+    Against(Option<String>),
 }
 
 /// The title row: `title` and `name`, the side by side / overlay switch and the close button.
@@ -325,7 +377,7 @@ fn pane(p: &egui::Painter, t: &Tokens, place: Place, shot: &Shot, hovered: Optio
 }
 
 /// The changed layers with their property changes; a click on a layer selects it.
-fn list(ui: &mut Ui, t: &Tokens, cmp: &Comparison, hovered: &mut Option<NodeId>) -> Option<Action> {
+fn list(ui: &mut Ui, t: &Tokens, cmp: &Comparison, from_version: bool, hovered: &mut Option<NodeId>) -> Option<Action> {
     let mut out = None;
     let summary = if !cmp.snapshot {
         tr("Changes unknown").to_string()
@@ -345,7 +397,11 @@ fn list(ui: &mut Ui, t: &Tokens, cmp: &Comparison, hovered: &mut Option<NodeId>)
     egui::ScrollArea::vertical().id_salt("compare_list").auto_shrink([false, false]).show(ui, |ui| {
         ui.spacing_mut().item_spacing = vec2(0.0, 0.0);
         for c in &cmp.changes {
-            let tip = if c.change == ChangeKind::Removed { tr("Removed since it was marked") } else { tr("Select layer") };
+            let tip = match (c.change, from_version) {
+                (ChangeKind::Removed, false) => tr("Removed since it was marked"),
+                (ChangeKind::Removed, true) => tr("Removed since this version"),
+                _ => tr("Select layer"),
+            };
             let resp = change_row(ui, t, c.change, &c.name, c.depth, c.layers, false, tip);
             if resp.hovered() {
                 now_hovered = Some(c.id);
@@ -419,17 +475,42 @@ pub(crate) fn property_lines<'a>(ui: &mut Ui, t: &Tokens, depth: usize, lines: i
     }
 }
 
-fn footer(ui: &mut Ui, t: &Tokens, cmp: &Comparison) -> Option<Action> {
+/// Resolve and Close, and left of them what it compares with: the snapshot from when it was
+/// marked ready for dev (`ready`) or one of the saved `versions` (`version`, the one picked).
+fn footer(ui: &mut Ui, t: &Tokens, cmp: &Comparison, ready: bool, versions: &[VersionRow], version: Option<&str>) -> Option<Action> {
     let (r, _) = ui.allocate_exact_size(vec2(ui.available_width(), BAR_H + 1.0), Sense::hover());
     ui.painter().rect_filled(Rect::from_min_size(r.min, vec2(r.width(), 1.0)), CornerRadius::ZERO, t.border);
     let mut out = None;
     let inner = Rect::from_min_max(pos2(r.min.x + 16.0, r.min.y + 1.0), pos2(r.max.x - 16.0, r.max.y));
+    ui.scope_builder(egui::UiBuilder::new().max_rect(inner).layout(egui::Layout::left_to_right(egui::Align::Center)), |ui| {
+        ui.spacing_mut().item_spacing.x = 8.0;
+        if !versions.is_empty() {
+            widgets::label(ui, tr("Compare with"), t.text_secondary);
+            let picked = version.and_then(|v| versions.iter().find(|(id, ..)| id == v));
+            let label = picked.map_or_else(|| tr("When marked ready").to_string(), |(_, name, _)| name.clone());
+            let resp = widgets::dropdown(ui, &label, 220.0, Some(Icon::Clock));
+            crate::right::menu_popup(&resp).show(|ui| {
+                if ready && crate::right::menu_check(ui, version.is_none(), tr("When marked ready"), "") {
+                    out = Some(Action::Against(None));
+                    ui.close();
+                }
+                for (id, name, time) in versions {
+                    if crate::right::menu_check(ui, version == Some(id.as_str()), name, &crate::comments::ago_long(*time)) {
+                        out = Some(Action::Against(Some(id.clone())));
+                        ui.close();
+                    }
+                }
+            });
+        }
+    });
     ui.scope_builder(egui::UiBuilder::new().max_rect(inner).layout(egui::Layout::right_to_left(egui::Align::Center)), |ui| {
         ui.spacing_mut().item_spacing.x = 8.0;
-        let resolve = widgets::button(ui, tr("Resolve change"), true, cmp.changed)
-            .on_hover_text(tr("Back to Ready for dev: the next change compares with how it is now"));
-        if resolve.clicked() {
-            out = Some(Action::Resolve);
+        if version.is_none() {
+            let resolve = widgets::button(ui, tr("Resolve change"), true, cmp.changed)
+                .on_hover_text(tr("Back to Ready for dev: the next change compares with how it is now"));
+            if resolve.clicked() {
+                out = Some(Action::Resolve);
+            }
         }
         if widgets::button(ui, tr("Close"), false, true).clicked() {
             out = Some(Action::Close);
diff --git a/crates/ui-egui/src/dev_mode.rs b/crates/ui-egui/src/dev_mode.rs
index 0fedccd7f..dcece9b2c 100644
--- a/crates/ui-egui/src/dev_mode.rs
+++ b/crates/ui-egui/src/dev_mode.rs
@@ -29,8 +29,12 @@ const CALLOUT_W: f32 = 220.0;
 const CALLOUT_GAP: f32 = 24.0;
 
 /// The status filters of the ready-for-dev list.
-const FILTERS: [(Option<DevStatus>, &str); 3] =
-    [(Some(DevStatus::ReadyForDev), tr_noop("Ready for dev")), (Some(DevStatus::Completed), tr_noop("Completed")), (None, tr_noop("Any status"))];
+const FILTERS: [(Option<DevStatus>, bool, &str); 4] = [
+    (Some(DevStatus::ReadyForDev), false, tr_noop("Ready for dev")),
+    (Some(DevStatus::ReadyForDev), true, tr_noop("Changed")),
+    (Some(DevStatus::Completed), false, tr_noop("Completed")),
+    (None, false, tr_noop("Any status")),
+];
 
 /// Which annotations the canvas shows.
 #[derive(Clone, Debug, Default, PartialEq, Eq)]
@@ -281,13 +285,14 @@ pub fn code(app: &mut FigApp, ui: &Ui, id: NodeId, lang: CodeLang) -> String {
 }
 
 /// The component playground, for a selected instance, component or component set: a preview of the
-/// component and a control for each variant, boolean and text property. The values tried here
-/// change the preview and the code only (returned when any is set: the Code section shows it),
-/// never the document.
+/// component and a control for each variant, boolean, text and instance-swap property. The values
+/// tried here change the preview and the code only (returned when any is set: the Code section
+/// shows it), never the document.
 pub fn playground_section(app: &mut FigApp, ui: &mut Ui, doc: &Document, id: NodeId, lang: CodeLang) -> Option<String> {
     figcraft_engine::playground::component_of(doc, id)?;
     let t = Tokens::get(ui.ctx());
     let Ok((uid, revision)) = app.session.ds().map(|d| (d.uid, d.revision)) else { return None };
+    let comps = crate::component_panel::local_components(app, ui, doc);
     let play = &mut app.ui.dev.playground;
     if play.target != Some(id) {
         *play = Playground { target: Some(id), ..Playground::default() };
@@ -357,7 +362,16 @@ pub fn playground_section(app: &mut FigApp, ui: &mut Ui, doc: &Document, id: Nod
                     set = Some((name.to_string(), json!(new.chars().take(10_000).collect::<String>())));
                 }
             }),
-            // Instance swaps and slots show as the component has them.
+            "instanceSwap" => row(ui, 32.0, |ui| {
+                widgets::label(ui, name, t.text_secondary);
+                let preferred: Vec<NodeId> = p["preferred"].as_array().into_iter().flatten().filter_map(figcraft_engine::params::id_of).collect();
+                let w = ui.available_width().max(60.0);
+                if let Some(c) = crate::component_panel::swap_dropdown(ui, doc, figcraft_engine::params::id_of(value), &preferred, &comps, w, name).1
+                {
+                    set = Some((name.to_string(), json!(c.0)));
+                }
+            }),
+            // Slots show as the component has them.
             _ => {}
         }
     }
@@ -500,18 +514,18 @@ pub fn status(app: &mut FigApp, ui: &mut Ui, doc: &Document, sel: &[NodeId]) {
     row(ui, 32.0, |ui| crate::section_panel::status_dropdown(app, ui, doc, sel, w));
     if let [id] = sel {
         let changed = doc.node(*id).is_some_and(|n| n.dev_status == DevStatus::ReadyForDev && n.dev_changed);
-        let focused = app.session.ds().ok().and_then(figcraft_engine::DocState::focused) == Some(*id);
+        let ds = app.session.ds().ok();
+        let focused = ds.and_then(figcraft_engine::DocState::focused) == Some(*id);
+        // Unchanged since it was marked (or not ready for dev): compared with the newest saved version.
+        let newest = ds.and_then(|d| d.versions.last()).map(|v| v.id.clone()).filter(|_| !changed);
         row(ui, 32.0, |ui| {
             ui.spacing_mut().item_spacing.x = 8.0;
             if !focused && widgets::button(ui, tr("Focus view"), false, true).on_hover_text(tr("Show only this on the canvas")).clicked() {
                 app.run("dev.focus", json!({"id": id}));
             }
-            if changed
-                && widgets::button(ui, tr("Compare changes"), true, true)
-                    .on_hover_text(tr("What changed since it was marked ready for dev"))
-                    .clicked()
-            {
-                app.run("dev.compare", json!({"id": id, "show": true}));
+            let tip = if changed { tr("What changed since it was marked ready for dev") } else { tr("What changed since a saved version") };
+            if (changed || newest.is_some()) && widgets::button(ui, tr("Compare changes"), changed, true).on_hover_text(tip).clicked() {
+                app.run("dev.compare", json!({"id": id, "version": newest, "show": true}));
             }
         });
     }
@@ -628,15 +642,16 @@ pub fn dev_resources_section(app: &mut FigApp, ui: &mut Ui, doc: &Document, id:
         }
         icons::paint(ui.painter(), Rect::from_center_size(pos2(r.min.x + PAD + 7.0, r.center().y), vec2(14.0, 14.0)), Icon::Link, t.icon_secondary);
         let x = r.min.x + PAD + 22.0;
-        ui.painter().text(pos2(x, r.center().y - 7.0), Align2::LEFT_CENTER, widgets::elide(ui, name, text_w), semibold(11.0), ACCENT);
+        ui.painter().text(pos2(x, r.center().y - 7.0), Align2::LEFT_CENTER, widgets::elide(ui, name, text_w), semibold(11.0), t.accent_text);
         let below = match item.from.and_then(|f| doc.node(f)) {
             Some(m) => trf("From {name}", &[("name", &m.name)]),
             None => url.clone(),
         };
         ui.painter().text(pos2(x, r.center().y + 7.0), Align2::LEFT_CENTER, widgets::elide(ui, &below, text_w), regular(10.0), t.text_secondary);
         crate::a11y::link(&resp, name);
-        // Opened only on a click, never fetched.
-        if resp.on_hover_text(url.as_str()).clicked() {
+        // Opened only on a click, never fetched, and a dev resource's URL comes from the
+        // document, so only a web link opens.
+        if resp.on_hover_text(url.as_str()).clicked() && figcraft_engine::doc_urls::openable(url) {
             ui.ctx().open_url(egui::OpenUrl::new_tab(url));
         }
         if let Some(i) = item.index {
@@ -818,7 +833,9 @@ pub fn ready_list(app: &mut FigApp, ui: &mut Ui) {
     let filter = app.ui.dev.filter.min(FILTERS.len() - 1);
     let key = (ds.uid, ds.revision, filter);
     if app.ui.dev.ready_key != Some(key) {
-        app.ui.dev.ready = devinspect::dev_items(&ds.doc, FILTERS.get(filter).and_then(|f| f.0), None);
+        let (status, changed_only) = FILTERS.get(filter).map_or((None, false), |f| (f.0, f.1));
+        app.ui.dev.ready = devinspect::dev_items(&ds.doc, status, None);
+        app.ui.dev.ready.retain(|i| i.changed || !changed_only);
         app.ui.dev.ready_key = Some(key);
     }
     let doc = ds.doc.clone();
@@ -826,9 +843,9 @@ pub fn ready_list(app: &mut FigApp, ui: &mut Ui) {
     widgets::section_header(ui, tr("Ready for dev"), &[], app.ui.dev.ready.is_empty());
     let w = ui.available_width() - PAD * 2.0;
     row(ui, 32.0, |ui| {
-        let resp = widgets::dropdown(ui, FILTERS.get(filter).map_or("", |f| tr(f.1)), w, Some(Icon::Code));
+        let resp = widgets::dropdown(ui, FILTERS.get(filter).map_or("", |f| tr(f.2)), w, Some(Icon::Code));
         menu_popup(&resp).show(|ui| {
-            for (i, (_, label)) in FILTERS.iter().enumerate() {
+            for (i, (_, _, label)) in FILTERS.iter().enumerate() {
                 if menu_check(ui, i == filter, tr(label), "") {
                     app.ui.dev.filter = i;
                     ui.close();
@@ -847,15 +864,21 @@ pub fn ready_list(app: &mut FigApp, ui: &mut Ui) {
         if resp.hovered() {
             ui.painter().rect_filled(r.shrink2(vec2(8.0, 0.0)), CornerRadius::same(5), t.hover);
         }
-        let dot = if item.status == DevStatus::ReadyForDev { t.success } else { t.text_tertiary };
+        // The status colours the canvas badges use; a changed one also says so after its name.
+        let n = doc.node(item.id);
+        let dot = n.and_then(crate::canvas::status_label).map_or(t.text_tertiary, |(_, c)| c);
         ui.painter().circle_filled(pos2(r.min.x + PAD + 4.0, r.center().y), 4.0, dot);
         let page = doc.node(item.page).map(|p| p.name.clone()).unwrap_or_default();
         let page_w = ui.painter().layout_no_wrap(page.clone(), regular(10.0), t.text_secondary).size().x.min(90.0);
         let page_r = Rect::from_min_max(pos2(r.max.x - PAD - page_w, r.min.y), pos2(r.max.x - PAD, r.max.y));
         ui.painter().with_clip_rect(page_r).text(page_r.right_center(), Align2::RIGHT_CENTER, page, regular(10.0), t.text_secondary);
         let name_r = Rect::from_min_max(pos2(r.min.x + PAD + 14.0, r.min.y), pos2(page_r.min.x - 8.0, r.max.y));
-        let name = widgets::elide(ui, &item.name, name_r.width());
-        ui.painter().text(name_r.left_center(), Align2::LEFT_CENTER, name, regular(11.0), t.text);
+        // Room for the "Changed" badge (about 60 points) after the name.
+        let name = widgets::elide(ui, &item.name, name_r.width() - if item.changed { 64.0 } else { 0.0 });
+        let name_end = ui.painter().text(name_r.left_center(), Align2::LEFT_CENTER, name, regular(11.0), t.text).max.x;
+        if let Some(n) = n.filter(|_| item.changed) {
+            crate::canvas::status_badge(&ui.painter().with_clip_rect(name_r), n, pos2(name_end + 6.0, r.center().y));
+        }
         // Hovered: a button to open it in the focus view, over the page name.
         let focus_r = Rect::from_center_size(pos2(r.max.x - PAD - 10.0, r.center().y), vec2(22.0, 22.0));
         let over_focus = ui.rect_contains_pointer(focus_r);
diff --git a/crates/ui-egui/src/dev_mode_tests.rs b/crates/ui-egui/src/dev_mode_tests.rs
index 941f1b2c5..3e2ea9ba2 100644
--- a/crates/ui-egui/src/dev_mode_tests.rs
+++ b/crates/ui-egui/src/dev_mode_tests.rs
@@ -1,8 +1,10 @@
 //! Dev Mode in the UI, driven headless (the harness is `present_tests`'): the compare view opens
 //! from `dev.compare {show}`, switches to the overlay and closes with Escape before the focus view
-//! does; the focus view's Escape; the annotation filter.
+//! does; the focus view's Escape; the annotation filter; the playground's instance-swap menu.
 
-use egui::{Key, pos2};
+use egui::accesskit::{Node, Role};
+use egui::{Event, Key, MouseWheelUnit, Pos2, TouchPhase, pos2, vec2};
+use figcraft_doc::NodeId;
 use figcraft_engine::Session;
 use serde_json::json;
 
@@ -80,3 +82,76 @@ fn annotation_filter_and_categories_panel() {
     assert_eq!(CategoryFilter::parse(&doc, "none"), Some(CategoryFilter::Uncategorized));
     assert_eq!(CategoryFilter::parse(&doc, "nope"), None);
 }
+
+/// A "Button" component whose nested "Heart" instance is its instance-swap property "Icon", a
+/// second icon "Star", and an instance of the button selected in the Inspect tab. Returns (ui,
+/// instance, heart, star).
+fn swap_setup() -> (crate::layers_drag_tests::Ui, NodeId, NodeId, NodeId) {
+    let mut s = Session::new();
+    let icon = |s: &mut Session, name: &str, x: i32| {
+        let f = id(&s.execute("frame.create", &json!({"x": x, "y": 0, "width": 24, "height": 24, "name": name})).unwrap());
+        id(&s.execute("component.create", &json!({"ids": [f]})).unwrap())
+    };
+    let (heart, star) = (icon(&mut s, "Heart", 0), icon(&mut s, "Star", 40));
+    let f = id(&s.execute("frame.create", &json!({"x": 0, "y": 100, "width": 120, "height": 40, "name": "Button"})).unwrap());
+    let nested = id(&s.execute("instance.create", &json!({"component": heart, "x": 8, "y": 108, "parent": f})).unwrap());
+    let button = id(&s.execute("component.create", &json!({"ids": [f]})).unwrap());
+    s.execute("component.addProperty", &json!({"id": button, "name": "Icon", "type": "instanceSwap", "default": heart, "layer": nested})).unwrap();
+    let inst = id(&s.execute("instance.create", &json!({"component": button, "x": 0, "y": 300})).unwrap());
+    s.execute("select.set", &json!({"ids": [inst]})).unwrap();
+    let mut u = crate::layers_drag_tests::Ui::new(s);
+    u.app.ui.right_tab = crate::RightTab::Inspect;
+    u.ctx.enable_accesskit();
+    (u, inst, heart, star)
+}
+
+fn tree(u: &mut crate::layers_drag_tests::Ui) -> Vec<Node> {
+    u.frame_output(vec![]).platform_output.accesskit_update.unwrap().nodes.into_iter().map(|(_, n)| n).collect()
+}
+
+fn centre(n: &Node) -> Pos2 {
+    let b = n.bounds().unwrap();
+    pos2(((b.x0 + b.x1) / 2.0) as f32, ((b.y0 + b.y1) / 2.0) as f32)
+}
+
+fn click(u: &mut crate::layers_drag_tests::Ui, at: Pos2) {
+    u.button(at, true);
+    u.button(at, false);
+}
+
+/// The playground's dropdown for property `name`, scrolled into view.
+fn playground_combo(u: &mut crate::layers_drag_tests::Ui, name: &str) -> Option<Node> {
+    for _ in 0..20 {
+        let combo = tree(u).into_iter().find(|n| n.role() == Role::ComboBox && n.label() == Some(name))?;
+        if centre(&combo).y < 860.0 {
+            return Some(combo);
+        }
+        let wheel =
+            Event::MouseWheel { unit: MouseWheelUnit::Point, delta: vec2(0.0, -100.0), phase: TouchPhase::Move, modifiers: Default::default() };
+        u.frame(vec![Event::PointerMoved(pos2(1300.0, 500.0)), wheel]);
+        for _ in 0..30 {
+            u.frame(vec![]);
+        }
+    }
+    None
+}
+
+#[test]
+fn the_playground_swaps_an_instance_in_the_preview_only() {
+    let (mut u, inst, heart, star) = swap_setup();
+    let (doc, undo) = (u.app.session.ds().unwrap().doc.clone(), u.app.session.undo_depth());
+    let combo = playground_combo(&mut u, "Icon").expect("the playground has a dropdown for the instance-swap property");
+    assert_eq!(combo.value(), Some("Heart"));
+    // Open it and pick Star: the item that wasn't there before the menu opened.
+    let before: Vec<Pos2> = tree(&mut u).iter().filter(|n| n.label() == Some("Star")).map(centre).collect();
+    click(&mut u, centre(&combo));
+    let item = tree(&mut u).into_iter().find(|n| n.label() == Some("Star") && !before.contains(&centre(n))).expect("Star in the menu");
+    click(&mut u, centre(&item));
+    let combo = playground_combo(&mut u, "Icon").unwrap();
+    assert_eq!(combo.value(), Some("Star"), "the playground shows the swapped icon");
+    // The file isn't touched: the instance still has the heart, nothing to undo.
+    assert!(std::sync::Arc::ptr_eq(&doc, &u.app.session.ds().unwrap().doc));
+    assert_eq!(u.app.session.undo_depth(), undo);
+    let props = u.app.session.execute("component.properties", &json!({"id": inst})).unwrap();
+    assert_eq!(props["properties"][0]["value"], json!(heart.0), "{star:?}");
+}
diff --git a/crates/ui-egui/src/devmode_tail_tests.rs b/crates/ui-egui/src/devmode_tail_tests.rs
new file mode 100644
index 000000000..7008e9e52
--- /dev/null
+++ b/crates/ui-egui/src/devmode_tail_tests.rs
@@ -0,0 +1,110 @@
+//! Dev Mode in the UI, the tail: the compare view compares with a saved version picked at its
+//! bottom, and falls back when that version goes away.
+
+use figcraft_engine::Session;
+use serde_json::json;
+
+use crate::dev_compare::CompareView;
+use crate::present_tests::{Ui, id};
+
+#[test]
+fn compare_view_compares_with_a_saved_version() {
+    let mut s = Session::new();
+    let f = id(&s.execute("frame.create", &json!({"x": 0, "y": 0, "width": 300, "height": 400, "name": "Login"})).unwrap());
+    let r = id(&s.execute("shape.rectangle", &json!({"x": 20, "y": 300, "width": 120, "height": 40, "parent": f})).unwrap());
+    let mut u = Ui::new(s);
+    u.app.ui.right_tab = crate::RightTab::Inspect;
+    u.frame(vec![]);
+    // Neither ready for dev nor any version: nothing to compare with, the view doesn't stay.
+    u.app.ui.dev.compare = Some(CompareView::new(f, None));
+    u.frames(2, Vec::new);
+    assert!(u.app.ui.dev.compare.is_none());
+    let v = u.run("file.saveVersion", json!({"name": "Kickoff"}));
+    let v = v["id"].as_str().unwrap().to_string();
+    u.run("node.set", json!({"id": r, "props": {"width": 160}}));
+    u.run("dev.compare", json!({"id": f, "version": v, "show": true}));
+    u.frames(2, Vec::new);
+    assert_eq!(u.app.inspect()["devCompare"]["version"], json!(v));
+    // Opened without one, a layer that isn't ready compares with the newest version.
+    u.app.ui.dev.compare = Some(CompareView::new(f, None));
+    u.frames(2, Vec::new);
+    assert_eq!(u.app.inspect()["devCompare"]["version"], json!(v));
+    // Ready for dev: the snapshot from when it was marked is there too, and a deleted version
+    // falls back to it.
+    u.run("node.set", json!({"id": f, "props": {"devStatus": "readyForDev"}}));
+    u.run("node.set", json!({"id": r, "props": {"height": 48}}));
+    u.run("version.delete", json!({"id": v}));
+    u.frames(2, Vec::new);
+    assert_eq!(u.app.inspect()["devCompare"]["version"], json!(null));
+    assert!(u.app.ui.dev.compare.is_some());
+}
+
+#[test]
+fn dev_mode_keys_refuse_design_edits_and_say_why() {
+    let mut s = Session::new();
+    let f = id(&s.execute("frame.create", &json!({"x": 0, "y": 0, "width": 300, "height": 400, "name": "Login"})).unwrap());
+    let r = id(&s.execute("shape.rectangle", &json!({"x": 20, "y": 30, "width": 120, "height": 40, "parent": f})).unwrap());
+    s.execute("select.set", &json!({"ids": [r]})).unwrap();
+    let mut u = Ui::new(s);
+    u.app.ui.right_tab = crate::RightTab::Inspect;
+    u.frame(vec![]);
+    let at = egui::pos2(700.0, 450.0);
+    let x = |u: &Ui| u.app.session.doc().unwrap().node(r).map(|n| n.transform.as_coeffs()[4]);
+    for key in [egui::Key::Delete, egui::Key::ArrowRight, egui::Key::Num5, egui::Key::R] {
+        u.key(at, key);
+    }
+    assert!(u.app.session.doc().unwrap().contains(r), "not deleted");
+    assert_eq!(x(&u), Some(20.0), "not nudged");
+    assert_eq!(u.app.session.doc().unwrap().node(r).map(|n| n.opacity), Some(1.0), "opacity kept");
+    assert_eq!(u.app.session.tool.tool, figcraft_engine::tools::ToolId::Move, "no drawing tool");
+    assert!(u.app.ui.toast.as_ref().is_some_and(|(m, _)| m.contains("Shift+D")));
+    // In the design the same keys edit.
+    u.app.ui.right_tab = crate::RightTab::Design;
+    u.frame(vec![]);
+    u.key(at, egui::Key::ArrowRight);
+    assert_eq!(x(&u), Some(21.0));
+}
+
+#[test]
+fn read_only_plugins_run_from_the_inspect_tab_show_their_panel() {
+    use base64::Engine as _;
+    let wasm = base64::engine::general_purpose::STANDARD.encode(crate::plugin_panel_tests::panel_module());
+    let manifest = json!({"id": "org.test.inspect", "name": "Inspect panel", "main": "p.wasm", "api": 2, "permissions": {"access": "read"}});
+    let mut s = Session::new();
+    s.execute("plugin.import", &json!({"manifest": manifest, "wasm": wasm})).unwrap();
+    let mut u = Ui::new(s);
+    u.app.ui.right_tab = crate::RightTab::Inspect;
+    u.frame(vec![]);
+    // What the Inspect tab's Plugins row runs.
+    crate::plugins_ui::start(&mut u.app, "org.test.inspect", "run");
+    u.frame(vec![]);
+    assert_eq!(u.app.session.plugins.panels.len(), 1, "its panel shows");
+    // Its callbacks only read: the button that would draw is refused and the design stays.
+    let layers = |u: &Ui| u.app.session.doc().unwrap().ids().count();
+    let before = layers(&u);
+    assert!(u.app.session.execute("plugin.event", &json!({"id": "org.test.inspect", "control": "go"})).is_err());
+    assert_eq!(layers(&u), before);
+}
+
+/// A clipboard holding only text.
+struct TextClip(String);
+
+impl crate::Services for TextClip {
+    fn clipboard_get_text(&mut self) -> Option<String> {
+        Some(self.0.clone())
+    }
+}
+
+#[test]
+fn dev_mode_pastes_only_a_comments_link() {
+    let mut s = Session::new();
+    let c = s.execute("comment.add", &json!({"x": 10, "y": 10, "text": "Check the spacing"})).unwrap()["id"].as_u64().unwrap();
+    let layers = |app: &crate::FigApp| app.session.doc().unwrap().node(app.session.page().unwrap()).unwrap().children.len();
+    let mut app = crate::FigApp::new(s, Box::new(TextClip("Pasted words".into())));
+    app.ui.right_tab = crate::RightTab::Inspect;
+    crate::menus::paste(&mut app, None, None);
+    assert_eq!(layers(&app), 0, "text doesn't paste into the design in Dev Mode");
+    app.services = Box::new(TextClip(format!("figcraft://comment/{c}")));
+    crate::menus::paste(&mut app, None, None);
+    assert_eq!(app.ui.comments.open, Some(c), "the link opens its thread");
+}
diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rs
index 236f8e0d0..85d8ca150 100644
--- a/crates/ui-egui/src/dialogs.rs
+++ b/crates/ui-egui/src/dialogs.rs
@@ -1,17 +1,18 @@
 //! Dialogs: About, Preferences, keyboard shortcuts, find & replace, rename layers, variables,
 //! export.
 
-use egui::{Align2, Color32, Context, CornerRadius, RichText, Sense, Stroke, vec2};
+use std::path::Path;
+
+use egui::{Align2, Context, CornerRadius, RichText, Sense, Stroke, vec2};
 use figcraft_color::ColorProfile;
 use figcraft_doc::{ExportFormat, ExportSetting, ExportSize, NodeId};
 use figcraft_engine::cmd::file::{export_jobs, exportable_layers};
-use serde_json::json;
+use serde_json::{Value, json};
 
 use crate::FigApp;
 use crate::export_panel::{export_layers, save_one, suggested_name};
 use crate::i18n::{self, tr, tr_noop, trf, trn};
-use crate::icons::{self, Icon};
-use crate::theme::{ACCENT, Tokens, regular, semibold};
+use crate::theme::{Tokens, regular, semibold};
 
 pub const VERSION: &str = env!("CARGO_PKG_VERSION");
 
@@ -71,6 +72,14 @@ pub enum AboutTab {
     Models,
 }
 
+/// Values collected by a menu or Actions command before dispatching it to the engine.
+#[derive(Clone, Debug, PartialEq)]
+pub enum MenuInput {
+    Link(String),
+    Offset(f64),
+    MoveToPage,
+}
+
 impl AboutTab {
     pub const ALL: [AboutTab; 3] = [AboutTab::About, AboutTab::Contributors, AboutTab::Models];
 
@@ -84,7 +93,7 @@ impl AboutTab {
 }
 
 /// The About window's width, the same on every tab (the Contributors table needs the room).
-pub const ABOUT_WIDTH: f32 = 640.0;
+pub const ABOUT_WIDTH: f32 = 660.0;
 
 /// The About window's tab row, drawn like the Design / Prototype tabs of the right panel.
 /// A row of tabs (the About window's, the shortcuts panel's): the current one highlighted.
@@ -112,10 +121,10 @@ pub(crate) fn tab_strip<T: Copy + PartialEq>(ui: &mut egui::Ui, t: &Tokens, tabs
 fn about_body(ui: &mut egui::Ui, t: &Tokens) {
     ui.horizontal(|ui| {
         let (r, _) = ui.allocate_exact_size(vec2(48.0, 48.0), Sense::hover());
-        ui.painter().rect_filled(r, CornerRadius::same(10), ACCENT);
-        icons::paint(ui.painter(), r.shrink(10.0), Icon::Logo, Color32::WHITE);
+        crate::theme::paint_app_icon(ui, r);
         ui.vertical(|ui| {
-            ui.label(RichText::new("FigCraft").font(semibold(18.0)));
+            let (wordmark, _) = ui.allocate_exact_size(vec2(130.0, 23.0), Sense::hover());
+            crate::theme::paint_wordmark(ui.painter(), egui::pos2(wordmark.min.x, wordmark.center().y), 18.0, t);
             ui.label(RichText::new(trf("Version {version}", &[("version", &VERSION)])).color(t.text_secondary));
         });
     });
@@ -133,12 +142,19 @@ fn about_body(ui: &mut egui::Ui, t: &Tokens) {
 }
 
 /// Escape closes the topmost simple dialog (one without menus of its own), before the canvas's
-/// shortcuts see it (it doesn't deselect), like a system dialog: from one of its fields too.
+/// shortcuts see it (it doesn't deselect), like a system dialog: from one of its fields too. A menu
+/// open over the dialog (Preferences ▸ Interface size) takes the first Escape and closes alone.
 pub fn keys(app: &mut FigApp, ctx: &Context) {
+    if egui::Popup::is_any_open(ctx) {
+        return;
+    }
     let u = &mut app.ui;
     let open = u.color_profile.is_some()
+        || u.menu_input.is_some()
         || u.find.is_some()
         || u.batch_rename.is_some()
+        || u.import_report.is_some()
+        || u.missing_fonts.is_some()
         || u.confirm_close
         || u.export_preview
         || u.shortcuts_panel
@@ -147,7 +163,13 @@ pub fn keys(app: &mut FigApp, ctx: &Context) {
     if !open || !ctx.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::Escape)) {
         return;
     }
-    if u.color_profile.take().is_some() || u.find.take().is_some() || u.batch_rename.take().is_some() {
+    if u.menu_input.take().is_some()
+        || u.color_profile.take().is_some()
+        || u.find.take().is_some()
+        || u.batch_rename.take().is_some()
+        || u.import_report.take().is_some()
+        || u.missing_fonts.take().is_some()
+    {
         return;
     }
     for flag in [&mut u.confirm_close, &mut u.export_preview, &mut u.shortcuts_panel, &mut u.preferences, &mut u.about] {
@@ -160,6 +182,8 @@ pub fn keys(app: &mut FigApp, ctx: &Context) {
 pub fn show(app: &mut FigApp, ctx: &Context) {
     // Dropped files waiting to open: their card, then (once it has shown) the files.
     crate::pending_open::pending_opens(app, ctx);
+    crate::import_report::show(app, ctx);
+    crate::missing_fonts::show(app, ctx);
     let t = Tokens::get(ctx);
     if app.ui.about {
         let mut open = true;
@@ -202,6 +226,9 @@ pub fn show(app: &mut FigApp, ctx: &Context) {
             if !cfg!(target_arch = "wasm32") && crate::widgets::checkbox(ui, prefs.auto_save, tr("Save files automatically")) {
                 toggles.push("pref.autoSave");
             }
+            if !cfg!(target_arch = "wasm32") && crate::widgets::checkbox(ui, prefs.start_on_home, tr("Start on the Home screen")) {
+                toggles.push("pref.startOnHome");
+            }
             for c in toggles {
                 app.run(c, json!({}));
             }
@@ -252,6 +279,8 @@ pub fn show(app: &mut FigApp, ctx: &Context) {
                 }
             });
             ui.add_space(8.0);
+            interface_size(app, ui, prefs.ui_scale);
+            ui.add_space(8.0);
             ui.horizontal(|ui| {
                 ui.label(tr("Theme"));
                 for (l, c) in [(tr_noop("Light"), "view.themeLight"), (tr_noop("Dark"), "view.themeDark"), (tr_noop("System"), "view.themeSystem")] {
@@ -264,12 +293,26 @@ pub fn show(app: &mut FigApp, ctx: &Context) {
             ui.horizontal(|ui| {
                 ui.label(tr("Language"));
                 // Each language by its own name; System follows the OS (the browser on the web).
-                let langs = i18n::languages().iter().filter(|l| crate::cjk::can_show(l.code)).map(|l| (l.code, l.name));
-                for (code, name) in [("system", tr("System"))].into_iter().chain(langs) {
-                    if ui.selectable_label(app.session.prefs.language.eq_ignore_ascii_case(code), name).clicked() {
-                        app.run("pref.language", json!({"language": code}));
-                        ui.ctx().request_repaint();
+                let langs = || {
+                    [("system", tr("System"))]
+                        .into_iter()
+                        .chain(i18n::languages().iter().filter(|l| crate::cjk::can_show(l.code)).map(|l| (l.code, l.name)))
+                };
+                let on = |code: &str| app.session.prefs.language.eq_ignore_ascii_case(code);
+                let selected = langs().find(|(code, _)| on(code)).map_or(tr("System"), |(_, name)| name);
+                let resp = crate::widgets::dropdown(ui, selected, 220.0, None);
+                let mut pick = None;
+                crate::right::menu_popup(&resp).show(|ui| {
+                    for (code, name) in langs() {
+                        if crate::right::menu_check(ui, on(code), name, "") {
+                            pick = Some(code);
+                            ui.close();
+                        }
                     }
+                });
+                if let Some(code) = pick {
+                    app.run("pref.language", json!({"language": code}));
+                    ui.ctx().request_repaint();
                 }
             });
             if let Some(lang) = i18n::current().filter(|l| l.draft) {
@@ -321,6 +364,7 @@ pub fn show(app: &mut FigApp, ctx: &Context) {
         app.ui.find = if open { Some((find, replace)) } else { None };
     }
     batch_rename_dialog(app, ctx);
+    menu_input_dialog(app, ctx);
     crate::variables_panel::show(app, ctx);
     crate::dev_compare::show(app, ctx);
     crate::branch_ui::show(app, ctx);
@@ -335,6 +379,72 @@ pub fn show(app: &mut FigApp, ctx: &Context) {
     crate::windows::confirm_close(app, ctx);
 }
 
+/// Menus and Actions cannot pass a value themselves. Gather it here, then run the regular
+/// command so the same validation and undo behaviour apply as for programmatic callers.
+fn menu_input_dialog(app: &mut FigApp, ctx: &Context) {
+    let Some(mut input) = app.ui.menu_input.take() else { return };
+    let t = Tokens::get(ctx);
+    let title = match &input {
+        MenuInput::Link(_) => i18n::command("text.link", "Create link"),
+        MenuInput::Offset(_) => i18n::command("vector.offset", "Offset path"),
+        MenuInput::MoveToPage => i18n::command("object.moveToPage", "Move to page"),
+    };
+    let mut open = true;
+    let mut action: Option<(&str, serde_json::Value)> = None;
+    window(&title, ctx).open(&mut open).show(ctx, |ui| {
+        ui.set_width(320.0);
+        match &mut input {
+            MenuInput::Link(url) => {
+                ui.horizontal(|ui| {
+                    let field = crate::widgets::text_input(ui, egui::Id::new("menu_input_link"), url, 250.0, "https://");
+                    let enter = field.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter));
+                    let ok = !url.trim().is_empty();
+                    if (crate::widgets::button(ui, tr("Done"), true, ok).clicked() || enter) && ok {
+                        action = Some(("text.link", json!({"url": url.trim()})));
+                    }
+                });
+            }
+            MenuInput::Offset(offset) => {
+                ui.horizontal(|ui| {
+                    let id = egui::Id::new("menu_input_offset");
+                    if let Some(crate::widgets::FieldEdit::Set(v) | crate::widgets::FieldEdit::Scrub(v, _)) =
+                        crate::widgets::number_field(ui, id, crate::widgets::Lead::None, Some(*offset), "", 120.0, 1.0)
+                    {
+                        *offset = v.clamp(-100_000.0, 100_000.0);
+                    }
+                    if crate::widgets::button(ui, tr("Offset"), true, true).clicked() {
+                        action = Some(("vector.offset", json!({"offset": *offset})));
+                    }
+                });
+            }
+            MenuInput::MoveToPage => {
+                let mut choices = 0;
+                if let Ok(ds) = app.session.ds() {
+                    for &page in &ds.doc.pages {
+                        if page == ds.page || ds.doc.is_divider(page) {
+                            continue;
+                        }
+                        if let Some(node) = ds.doc.node(page)
+                            && crate::widgets::button(ui, &node.name, false, true).clicked()
+                        {
+                            action = Some(("object.moveToPage", json!({"page": page})));
+                        }
+                        choices += 1;
+                    }
+                }
+                if choices == 0 {
+                    crate::widgets::label(ui, tr("No other pages"), t.text_secondary);
+                }
+            }
+        }
+    });
+    if let Some((id, params)) = action {
+        app.run(id, params);
+    } else if open {
+        app.ui.menu_input = Some(input);
+    }
+}
+
 /// The Rename layers dialog's fields.
 #[derive(Clone, Debug, Default, PartialEq)]
 pub struct BatchRenameUi {
@@ -371,6 +481,76 @@ pub(crate) fn batch_rename_params(b: &BatchRenameUi) -> serde_json::Value {
     p
 }
 
+/// Preferences ▸ Interface size: a size relative to the system's display scale (100 % is the
+/// system's own), as a drop-down that takes effect at once. The browser has its own zoom, so there
+/// the row only says so.
+fn interface_size(app: &mut FigApp, ui: &mut egui::Ui, chosen: f64) {
+    let t = Tokens::get(ui.ctx());
+    if cfg!(target_arch = "wasm32") {
+        ui.label(tr("Interface size"));
+        crate::widgets::label(ui, tr("Use your browser's zoom to change the interface size."), t.text_secondary);
+        return;
+    }
+    let percent = |size: f64| trf("{percent}%", &[("percent", &crate::ui_scale::percent(size as f32))]);
+    let shown = percent(chosen);
+    ui.horizontal(|ui| {
+        ui.label(tr("Interface size"));
+        let resp = crate::widgets::dropdown(ui, &shown, 120.0, None);
+        crate::a11y::combo(&resp, tr("Interface size"), &shown, crate::a11y::menu_open(&resp));
+        crate::right::menu_popup(&resp).show(|ui| {
+            let focused = ui.memory(|memory| memory.focused());
+            let step = ui.input(|input| {
+                if input.key_pressed(egui::Key::ArrowDown) || (input.key_pressed(egui::Key::Tab) && !input.modifiers.shift) {
+                    1
+                } else if input.key_pressed(egui::Key::ArrowUp) || (input.key_pressed(egui::Key::Tab) && input.modifiers.shift) {
+                    -1
+                } else {
+                    0
+                }
+            });
+            let mut rows = Vec::with_capacity(crate::ui_scale::SIZES.len());
+            for size in crate::ui_scale::SIZES {
+                let label = percent(size);
+                let selected = (chosen - size).abs() < 1e-6;
+                let row = crate::right::menu_row(ui, &format!("{}{label}", if selected { "✓ " } else { "    " }), "", 0.0, |_, _, _| {});
+                crate::a11y::menu_item(&row, &label, "", Some(selected));
+                if row.has_focus() {
+                    ui.memory_mut(|memory| memory.set_focus_lock_filter(row.id, egui::EventFilter { tab: true, ..Default::default() }));
+                }
+                rows.push(row.id);
+                if row.clicked() {
+                    app.run("pref.uiScale", json!({"scale": size}));
+                    ui.close();
+                }
+            }
+            // Spatial focus can jump to a control behind the popup when the menu overlaps the
+            // Preferences window. Once an item is focused, walk the menu's own rows instead.
+            if step != 0
+                && let Some(index) = rows.iter().position(|id| Some(*id) == focused)
+            {
+                let next = index.saturating_add_signed(step).min(rows.len() - 1);
+                ui.memory_mut(|memory| {
+                    memory.request_focus(rows[next]);
+                    memory.move_focus(egui::FocusDirection::None);
+                });
+            }
+        });
+    });
+    crate::widgets::label(
+        ui,
+        tr("Relative to your system's display scaling (100% is the system's own size). Document zoom is separate."),
+        t.text_secondary,
+    );
+    // Said in words, not only by the menu's value: the window is too small for the size chosen.
+    if app.ui.ui_scale.limited {
+        let note = trf(
+            "The window is too small for {size}%, so the interface is drawn at {drawn}%. Make the window larger to use {size}%.",
+            &[("size", &crate::ui_scale::percent(chosen as f32)), ("drawn", &crate::ui_scale::percent(app.ui.ui_scale.zoom))],
+        );
+        crate::widgets::label(ui, &note, t.text_secondary);
+    }
+}
+
 /// Rename layers: Match, Rename to with buttons for the current name and numbers, where numbers
 /// start, a preview of the first new names, then one `object.batchRename`.
 fn batch_rename_dialog(app: &mut FigApp, ctx: &Context) {
@@ -505,17 +685,35 @@ fn color_profile_dialog(app: &mut FigApp, ctx: &Context) {
     }
 }
 
+/// A `.fig` Save as result is an export; only native saves report that the document was saved.
+pub(crate) fn file_saved(app: &mut FigApp, result: &Value) {
+    if result["format"] == "fig" {
+        fig_exported(app, result);
+    } else {
+        app.toast(trf("Saved {name}", &[("name", &result_file_name(result))]));
+    }
+}
+
+fn result_file_name(result: &Value) -> String {
+    result["path"].as_str().and_then(|p| Path::new(p).file_name()).map(|f| f.to_string_lossy().into_owned()).unwrap_or_default()
+}
+
+/// The `.fig` result stays an export: native save state is unchanged, and omissions are reported.
+pub(crate) fn fig_exported(app: &mut FigApp, result: &Value) {
+    let file = result_file_name(result);
+    let left_out = result["warnings"].as_array().map_or(0, Vec::len);
+    app.toast(match left_out {
+        0 => trf("Exported {name}", &[("name", &file)]),
+        n => trn("Exported {name}; {n} kinds of content were left out", n, &[("name", &file)]),
+    });
+}
+
 /// Save the whole file as `.fig`; the toast says how much was left out.
 fn save_fig(app: &mut FigApp, name: &str) {
     let filename = format!("{name}.fig");
     app.pick_save(tr("Export"), &filename, &["fig"], |app, p| {
-        let file = p.file_name().map(|f| f.to_string_lossy().to_string()).unwrap_or_default();
         if let Some(r) = app.run("file.export", json!({"format": "fig", "path": p.to_string_lossy()})) {
-            let left_out = r["warnings"].as_array().map_or(0, Vec::len);
-            app.toast(match left_out {
-                0 => trf("Exported {name}", &[("name", &file)]),
-                n => trn("Exported {name}; {n} kinds of content were left out", n, &[("name", &file)]),
-            });
+            fig_exported(app, &r);
         }
     });
 }
diff --git a/crates/ui-egui/src/export_panel.rs b/crates/ui-egui/src/export_panel.rs
index ade5df297..8617c35a8 100644
--- a/crates/ui-egui/src/export_panel.rs
+++ b/crates/ui-egui/src/export_panel.rs
@@ -60,20 +60,23 @@ pub fn section(app: &mut FigApp, ui: &mut Ui, doc: &Document, sel: &[NodeId]) {
     }
 }
 
-/// One export setting: size (typed or picked), suffix, format, advanced options and remove; a
-/// PDF's print settings under it.
+/// One export setting: size (typed or picked; images only, SVG and PDF are vector), suffix,
+/// format, advanced options and remove; a PDF's print settings under it.
 fn setting_row(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId], i: usize, e: &ExportSetting) {
     row(ui, 32.0, |ui| {
         // Tighter spacing so the advanced options and remove buttons fit beside the fields.
         ui.spacing_mut().item_spacing.x = 4.0;
-        let (size_w, format_w, button, gap) = (52.0, 54.0, 22.0, ui.spacing().item_spacing.x);
-        let suffix_w = (ui.available_width() - size_w - format_w - button * 2.0 - gap * 4.0).max(32.0);
-        let presets: Vec<String> =
-            ExportSize::SCALES.iter().map(|value| ExportSize::Scale { value: *value }.label()).chain(["512w".into(), "512h".into()]).collect();
-        if let Some(s) = widgets::combo_field(ui, Id::new(("export_size", i)), &e.size.label(), size_w, &presets)
-            && ExportSize::parse(&s) != Some(e.size)
-        {
-            app.run("export.update", json!({"ids": ids, "index": i, "size": s}));
+        let (format_w, button, gap) = (54.0, 22.0, ui.spacing().item_spacing.x);
+        let size_w = e.format.is_raster().then_some(52.0);
+        let suffix_w = (ui.available_width() - size_w.map_or(0.0, |w| w + gap) - format_w - button * 2.0 - gap * 3.0).max(32.0);
+        if let Some(size_w) = size_w {
+            let presets: Vec<String> =
+                ExportSize::SCALES.iter().map(|value| ExportSize::Scale { value: *value }.label()).chain(["512w".into(), "512h".into()]).collect();
+            if let Some(s) = widgets::combo_field(ui, Id::new(("export_size", i)), &e.size.label(), size_w, &presets)
+                && ExportSize::parse(&s) != Some(e.size)
+            {
+                app.run("export.update", json!({"ids": ids, "index": i, "size": s}));
+            }
         }
         if let Some(sfx) = widgets::text_field(ui, Id::new(("export_suffix", i)), &e.suffix, suffix_w, tr("Suffix"))
             && sfx != e.suffix
diff --git a/crates/ui-egui/src/export_preview_tests.rs b/crates/ui-egui/src/export_preview_tests.rs
index 3d536a017..d57e294dd 100644
--- a/crates/ui-egui/src/export_preview_tests.rs
+++ b/crates/ui-egui/src/export_preview_tests.rs
@@ -1,6 +1,7 @@
 //! The Export section's Preview row: a slice paints nothing itself, so its preview must show the
 //! page content under it — the same thing exporting the slice writes — and not a blank
-//! transparency checkerboard next to a correct export.
+//! transparency checkerboard next to a correct export. And its setting rows: a size only for
+//! images.
 
 use figcraft_doc::{Document, NodeId};
 use figcraft_engine::Session;
@@ -50,3 +51,28 @@ fn other_layers_preview_themselves() {
     assert_eq!([pix.width(), pix.height()], [200, 100], "the layer's own area");
     assert!(paints(&pix));
 }
+
+/// SVG and PDF are vector: their export rows offer no size, which their export ignores (#256).
+#[test]
+fn export_rows_offer_a_size_for_images_only() {
+    let mut s = Session::new();
+    let r = crate::present_tests::id(&s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 100, "height": 80})).unwrap());
+    s.execute("select.set", &json!({"ids": [r]})).unwrap();
+    s.execute("export.add", &json!({"ids": [r]})).unwrap();
+    let mut u = crate::layers_drag_tests::Ui::new(s);
+    let size_menu = |u: &crate::layers_drag_tests::Ui| u.ctx.read_response(egui::Id::new(("export_size", 0)).with("menu")).is_some();
+    u.frame(vec![]);
+    assert!(size_menu(&u), "PNG has sizes");
+    for format in ["svg", "pdf"] {
+        u.app.run("export.update", json!({"ids": [r], "index": 0, "format": format}));
+        u.frame(vec![]);
+        u.frame(vec![]);
+        assert!(!size_menu(&u), "{format} is vector: no size");
+    }
+    for format in ["jpg", "webp"] {
+        u.app.run("export.update", json!({"ids": [r], "index": 0, "format": format}));
+        u.frame(vec![]);
+        u.frame(vec![]);
+        assert!(size_menu(&u), "{format} has sizes again");
+    }
+}
diff --git a/crates/ui-egui/src/field_tests.rs b/crates/ui-egui/src/field_tests.rs
index 492fdc018..dd63988a0 100644
--- a/crates/ui-egui/src/field_tests.rs
+++ b/crates/ui-egui/src/field_tests.rs
@@ -370,6 +370,58 @@ fn arithmetic_commits_tab_moves_on_and_escape_restores() {
     assert_eq!(geom(&u, a).0, 78.0);
 }
 
+/// Answers a Save as dialog with `path`, once, and counts the dialogs asked for.
+struct SaveAsPicker {
+    path: Option<std::path::PathBuf>,
+    asked: std::rc::Rc<std::cell::Cell<usize>>,
+}
+
+impl crate::Services for SaveAsPicker {
+    fn pick_save(&mut self, _title: &str, _name: &str, _exts: &[&str]) -> crate::DialogFuture {
+        self.asked.set(self.asked.get() + 1);
+        Box::pin(std::future::ready(self.path.take()))
+    }
+}
+
+/// The x of layer `a` in the file at `path`, opened again.
+fn saved_x(path: &std::path::Path, a: NodeId) -> f64 {
+    let mut back = Session::new();
+    back.execute("file.open", &json!({"path": path.to_string_lossy()})).unwrap();
+    back.doc().unwrap().world_bounds(a).unwrap().x0
+}
+
+#[test]
+fn the_save_shortcut_saves_from_a_field_with_what_was_typed() {
+    // Cmd/Ctrl+S with the keyboard in a panel field saved nothing (#1157). It commits the field
+    // first (as clicking away does), then saves; the field lets go of the keyboard.
+    // Shift+Cmd/Ctrl+S does the same through Save as.
+    let cmd = if cfg!(target_os = "macos") { Modifiers::COMMAND } else { Modifiers::COMMAND.plus(Modifiers::CTRL) };
+    let (mut u, a, _) = setup();
+    let dir = std::env::temp_dir().join(format!("figcraft-save-from-field-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let (path, copy) = (dir.join("doc.figcraft"), dir.join("copy.figcraft"));
+    u.app.session.execute("file.saveAs", &json!({"path": path.to_string_lossy()})).unwrap();
+    let asked = std::rc::Rc::new(std::cell::Cell::new(0));
+    u.app.services = Box::new(SaveAsPicker { path: Some(copy.clone()), asked: asked.clone() });
+    for (shortcut, mods, x, file) in [("Cmd/Ctrl+S", cmd, 77.0, &path), ("Shift+Cmd/Ctrl+S", cmd.plus(Modifiers::SHIFT), 66.0, &copy)] {
+        let (p, _) = field(&mut u, "X");
+        click(&mut u, p);
+        assert!(crate::a11y::field_focused(&u.ctx), "{shortcut}: the field has the keyboard");
+        u.frame(vec![Event::Text(x.to_string())]);
+        key(&mut u, Key::S, mods);
+        for _ in 0..3 {
+            u.frame(vec![]);
+        }
+        assert_eq!(geom(&u, a).0, x, "{shortcut}: what was typed is committed");
+        assert!(!crate::a11y::field_focused(&u.ctx), "{shortcut}: the field let go");
+        assert!(!u.app.session.ds().unwrap().is_dirty(), "{shortcut}: saved");
+        assert_eq!(saved_x(file, a), x, "{shortcut}: the file on disk has the typed value");
+    }
+    assert_eq!(asked.get(), 1, "only Save as asked where");
+    assert_eq!(saved_x(&path, a), 77.0, "Save as left the first file alone");
+    std::fs::remove_dir_all(&dir).ok();
+}
+
 #[test]
 fn mixed_values_take_edits_relative_to_each_layer() {
     let (mut u, a, b) = setup();
@@ -473,3 +525,164 @@ fn scrubbing_the_scale_panel_width_scales_live_in_one_undo_step() {
     let (_, _, w, h) = geom(&u, a);
     assert_eq!((w, h, undo_steps(&u)), (60.0, 45.0, steps + 1), "40×30 scaled to a width of 60");
 }
+
+/// The texts painted in the last frame: what they say, whether they end in an ellipsis, and where
+/// they show (within their clip).
+fn painted_texts(shapes: &[egui::epaint::ClippedShape]) -> Vec<(String, bool, egui::Rect)> {
+    fn walk(shape: &egui::Shape, clip: egui::Rect, out: &mut Vec<(String, bool, egui::Rect)>) {
+        match shape {
+            egui::Shape::Vec(v) => v.iter().for_each(|s| walk(s, clip, out)),
+            egui::Shape::Text(t) => out.push((t.galley.text().to_string(), t.galley.elided, t.visual_bounding_rect().intersect(clip))),
+            _ => {}
+        }
+    }
+    let mut out = Vec::new();
+    shapes.iter().for_each(|c| walk(&c.shape, c.clip_rect, &mut out));
+    out
+}
+
+/// The glass effect's light intensity field is labelled (#256): drawn in the Design panel with the
+/// effect's settings open.
+#[test]
+fn the_glass_light_intensity_field_has_a_label() {
+    let mut s = Session::new();
+    let r = NodeId(s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 100, "height": 80})).unwrap()["id"].as_u64().unwrap());
+    s.execute("select.set", &json!({"ids": [r]})).unwrap();
+    s.execute("effect.add", &json!({"type": "glass"})).unwrap();
+    let mut u = Ui::new(s);
+    u.ctx.data_mut(|d| d.insert_temp(Id::new(("fx_open", 0usize)), true));
+    u.frame(vec![]);
+    let shapes = u.frame_output(vec![]).shapes;
+    let lead = u.ctx.read_response(Id::new(("fx_gi", 0usize)).with("lead")).expect("the intensity field is shown").rect;
+    let labels: Vec<(String, bool)> =
+        painted_texts(&shapes).into_iter().filter(|(_, _, at)| lead.contains(at.center())).map(|(text, cut, _)| (text, cut)).collect();
+    assert_eq!(labels, [("Intensity".to_string(), false)], "labelled, and not cut short");
+    let field = u.ctx.read_response(Id::new(("fx_gi", 0usize)).with("field")).expect("its value").rect;
+    assert_eq!(field.max.x - lead.min.x, GLASS_FIELD_W, "the width the next test measures against");
+}
+
+/// A glass settings field's width in the Design panel at its default width.
+const GLASS_FIELD_W: f32 = 98.5;
+
+/// The light intensity label this fix adds fits whole beside its value in every language (#256).
+/// Other glass labels may end in "…" in some languages (es "Profundidad"); a longer
+/// "Intensity" translation fails here.
+#[test]
+fn the_intensity_label_fits_whole_in_every_language() {
+    use crate::i18n::{self, Text};
+    let ctx = egui::Context::default();
+    let mut out = ctx.run_ui(Default::default(), |ui| {
+        let width = |s: &str| ui.painter().layout_no_wrap(s.to_string(), crate::theme::regular(11.0), egui::Color32::WHITE).size().x;
+        for lang in i18n::languages() {
+            let label = lang.ui.iter().find(|(k, _)| *k == "Intensity").map_or("Intensity", |(_, t)| match t {
+                Text::Plain(s) | Text::Plural { other: s, .. } => s,
+            });
+            let lead = crate::widgets::text_lead_width(ui, label, GLASS_FIELD_W);
+            assert!(lead >= 12.0 + width(label), "{}: {label:?} would end in \"…\"", lang.code);
+        }
+    });
+    out.textures_delta.clear();
+}
+
+#[test]
+fn a_label_too_long_for_its_field_ends_in_an_ellipsis_before_the_value() {
+    let ctx = egui::Context::default();
+    let mut field = egui::Rect::NOTHING;
+    let mut out = ctx.run_ui(Default::default(), |ui| {
+        let lead = crate::widgets::Lead::Text("A label much wider than its field");
+        let _ = crate::widgets::number_field(ui, Id::new("long"), lead, Some(80.0), "%", 60.0, 1.0);
+        field = ui.min_rect();
+    });
+    out.textures_delta.clear();
+    let texts = painted_texts(&out.shapes);
+    let [(_, label_cut, l), (value, value_cut, v)] = texts.as_slice() else { panic!("the label and the value: {texts:?}") };
+    assert!(*label_cut, "the label ends in an ellipsis");
+    assert_eq!((value.as_str(), *value_cut), ("80%", false), "the value shows whole");
+    assert!(field.contains_rect(*l) && field.contains_rect(*v), "both inside the field {field:?}: {l:?} {v:?}");
+    assert!(l.max.x < v.min.x, "the label stops before the value: {l:?} {v:?}");
+}
+
+/// The middle of the field with response `id`.
+fn at(u: &Ui, id: Id) -> Pos2 {
+    u.ctx.read_response(id.with("field")).unwrap_or_else(|| panic!("no field {id:?}")).rect.center()
+}
+
+/// Type `text` into the field whose response is `id` and press Enter.
+fn type_at(u: &mut Ui, id: Id, text: &str) {
+    let p = at(u, id);
+    click(u, p);
+    u.frame(vec![Event::Text(text.into())]);
+    key(u, Key::Enter, Modifiers::NONE);
+    u.frame(vec![]);
+}
+
+/// A frame with one layout grid, its settings open in the Design panel.
+fn grid_ui(grid: serde_json::Value) -> (Ui, NodeId) {
+    let mut s = Session::new();
+    let f = id(s.execute("frame.create", &json!({"x": 0, "y": 0, "width": 400, "height": 300})).unwrap());
+    s.execute("node.set", &json!({"ids": [f], "props": {"grids": [grid]}})).unwrap();
+    s.execute("select.set", &json!({"ids": [f]})).unwrap();
+    let mut u = Ui::new(s);
+    u.ctx.data_mut(|d| d.insert_temp(Id::new(("grid_open", 0usize)), true));
+    u.frame(vec![]);
+    (u, f)
+}
+
+/// Scroll the Design panel (over its own field `id`) until that field is on the test screen: the
+/// grid settings sit below the fold.
+fn scroll_to(u: &mut Ui, id: Id) {
+    let wheel = Event::MouseWheel {
+        unit: egui::MouseWheelUnit::Point,
+        delta: egui::vec2(0.0, -300.0),
+        phase: egui::TouchPhase::Move,
+        modifiers: Modifiers::NONE,
+    };
+    for _ in 0..10 {
+        let p = at(u, id);
+        if p.y < 860.0 {
+            break;
+        }
+        u.frame(vec![Event::PointerMoved(pos2(p.x, 500.0)), wheel.clone()]);
+        // Let the scroll settle.
+        for _ in 0..30 {
+            u.frame(vec![]);
+        }
+    }
+}
+
+/// The word for Auto types 0 only where 0 *is* the automatic value: a fixed layout grid's count
+/// does, an auto layout's gap (Auto there is "Space between") does not. Keying it on the field's
+/// placeholder said 0 everywhere, which turned the gap's mode off.
+#[test]
+fn typing_auto_is_zero_only_where_zero_is_the_automatic_value() {
+    let count_id = Id::new(("grid_field", "count", 0usize));
+    let (mut u, f) = grid_ui(json!({"kind": "columns", "align": "min", "count": 3, "size": 8, "gutter": 10}));
+    let count = |u: &Ui| u.app.session.doc().unwrap().node(f).unwrap().grids[0].count;
+    scroll_to(&mut u, count_id);
+    type_at(&mut u, count_id, "Auto");
+    assert_eq!(count(&u), 0, "a fixed grid's count: Auto is 0");
+    type_at(&mut u, count_id, "4");
+    assert_eq!(count(&u), 4, "and a number is that count");
+    // A stretched grid works its width out from the frame: the field shows Auto and takes no edit.
+    let (mut u, f) = grid_ui(json!({"kind": "columns", "align": "stretch", "count": 3, "size": 0}));
+    let size_id = Id::new(("grid_field", "size", 0usize));
+    scroll_to(&mut u, size_id);
+    type_at(&mut u, size_id, "40");
+    assert_eq!(u.app.session.doc().unwrap().node(f).unwrap().grids[0].size, 0.0, "a stretched grid's width isn't set");
+    // Nor its count: a stretched grid has at least one band, so the word commits nothing.
+    type_at(&mut u, count_id, "Auto");
+    assert_eq!(u.app.session.doc().unwrap().node(f).unwrap().grids[0].count, 3, "a stretched grid keeps its count");
+
+    // The auto layout's gap: its placeholder says Auto, but Auto is a mode, not 0.
+    let mut s = Session::new();
+    let f = id(s.execute("frame.create", &json!({"x": 0, "y": 0, "width": 400, "height": 300})).unwrap());
+    s.execute("layout.add", &json!({"ids": [f], "direction": "vertical"})).unwrap();
+    s.execute("node.set", &json!({"ids": [f], "props": {"mainAlign": "spaceBetween"}})).unwrap();
+    s.execute("select.set", &json!({"ids": [f]})).unwrap();
+    let mut u = Ui::new(s);
+    u.frame(vec![]);
+    let gap = |u: &Ui| u.app.session.doc().unwrap().node(f).unwrap().layout.as_ref().unwrap().gap;
+    let before = gap(&u);
+    type_at(&mut u, Id::new("al_gap"), "Auto");
+    assert_eq!(gap(&u), before, "the word isn't a value where Auto is a mode");
+}
diff --git a/crates/ui-egui/src/frame_label_tests.rs b/crates/ui-egui/src/frame_label_tests.rs
index 38ebef0a1..687669e87 100644
--- a/crates/ui-egui/src/frame_label_tests.rs
+++ b/crates/ui-egui/src/frame_label_tests.rs
@@ -1,6 +1,6 @@
 //! Frame name labels on the canvas, driven through egui headless: an upright frame's label sits
 //! just above its top-left corner, a rotated frame's runs along its turned top edge, and pressing
-//! either label selects and drags its frame.
+//! either label selects and drags its frame; double-clicking one renames the frame or section there.
 
 use egui::{Event, Pos2, pos2, vec2};
 use figcraft_doc::NodeId;
@@ -79,3 +79,80 @@ fn pressing_a_rotated_label_selects_and_drags_the_frame() {
     assert!(after.x0 > before.x0 + 1.0 && after.y0 > before.y0 + 1.0, "{before:?} → {after:?}");
     assert_eq!(u.app.session.ds().unwrap().history.undo.len(), undo + 1);
 }
+
+fn key(k: egui::Key) -> Vec<Event> {
+    vec![
+        Event::Key { key: k, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() },
+        Event::Key { key: k, physical_key: None, pressed: false, repeat: false, modifiers: Default::default() },
+    ]
+}
+
+/// Double-click `f`'s label and wait for the field to take the keyboard.
+fn double_click_label(u: &mut Ui, f: NodeId) {
+    let at = mid(&label(u, f));
+    for _ in 0..2 {
+        u.button(at, true);
+        u.button(at, false);
+    }
+    u.frame(vec![]);
+    u.frame(vec![]);
+}
+
+fn name(u: &Ui, f: NodeId) -> String {
+    u.app.session.doc().unwrap().node(f).unwrap().name.clone()
+}
+
+#[test]
+fn double_clicking_a_label_renames_the_frame_there() {
+    let (mut u, a, b) = setup();
+    let before = u.app.session.doc().unwrap().world_bounds(a).unwrap();
+    double_click_label(&mut u, a);
+    assert_eq!(u.app.session.selection(), vec![a]);
+    assert_eq!(u.app.ui.rename_label.map(|r| r.id), Some(a), "a field over the label");
+    // The name starts selected: typing replaces it, Enter keeps it.
+    u.frame(vec![Event::Text("Sign in".into())]);
+    u.frame(key(egui::Key::Enter));
+    u.frame(vec![]);
+    assert_eq!(name(&u, a), "Sign in");
+    assert!(u.app.ui.rename_label.is_none());
+    // The double-click didn't move the frame or rename the other one.
+    assert_eq!(u.app.session.doc().unwrap().world_bounds(a).unwrap(), before);
+    assert_eq!(name(&u, b), "Turned");
+    // One undo step puts the old name back.
+    u.app.session.undo().unwrap();
+    assert_eq!(name(&u, a), "Upright");
+}
+
+#[test]
+fn escape_leaves_a_label_rename_with_the_old_name() {
+    let (mut u, _, b) = setup();
+    double_click_label(&mut u, b);
+    assert_eq!(u.app.ui.rename_label.map(|r| r.id), Some(b), "rotated labels rename too");
+    u.frame(vec![Event::Text("Nope".into())]);
+    u.frame(key(egui::Key::Escape));
+    u.frame(vec![]);
+    assert_eq!(name(&u, b), "Turned");
+    assert!(u.app.ui.rename_label.is_none());
+}
+
+#[test]
+fn a_sections_label_renames_it_and_a_click_elsewhere_commits() {
+    let mut s = Session::new();
+    let a = id(s.execute("node.create", &json!({"type": "section", "x": 0, "y": 0, "width": 300, "height": 200, "name": "Area"})).unwrap());
+    s.execute("select.none", &json!({})).unwrap();
+    let mut u = Ui::new(s);
+    u.frame(vec![]);
+    let undo = u.app.session.ds().unwrap().history.undo.len();
+    double_click_label(&mut u, a);
+    assert_eq!(u.app.ui.rename_label.map(|r| r.id), Some(a), "a field over the section's label");
+    assert_eq!(u.app.session.selection(), vec![a]);
+    u.frame(vec![Event::Text("Zone".into())]);
+    let at = mid(&label(&u, a));
+    let away = pos2(at.x + 200.0, at.y + 500.0);
+    u.button(away, true);
+    u.button(away, false);
+    u.frame(vec![]);
+    assert_eq!(name(&u, a), "Zone", "a click on the canvas commits");
+    assert!(u.app.ui.rename_label.is_none());
+    assert_eq!(u.app.session.ds().unwrap().history.undo.len(), undo + 1, "one undo step");
+}
diff --git a/crates/ui-egui/src/frame_labels.rs b/crates/ui-egui/src/frame_labels.rs
index 2718fddd1..9e8b2e7ab 100644
--- a/crates/ui-egui/src/frame_labels.rs
+++ b/crates/ui-egui/src/frame_labels.rs
@@ -103,7 +103,7 @@ pub fn draw(app: &FigApp, painter: &Painter, t: &Tokens, doc: &Document, id: Nod
     let col = if is_comp {
         COMPONENT
     } else if selected || hovered {
-        ACCENT
+        crate::theme::canvas_accent(painter.ctx())
     } else {
         t.text_secondary
     };
@@ -151,6 +151,28 @@ pub fn draw(app: &FigApp, painter: &Painter, t: &Tokens, doc: &Document, id: Nod
     Some([area.left_top(), area.right_top(), area.right_bottom(), area.left_bottom()].map(|p| tl + rot * (p - tl)))
 }
 
+/// The field over a frame's or section's name label being renamed (`UiState::rename_label`, from a
+/// double-click on the label): Enter or a click elsewhere renames the layer, Escape keeps the name.
+/// The rename ends when the field lets go of the keyboard or the label is gone.
+pub fn rename_field(app: &mut FigApp, ui: &mut egui::Ui) {
+    let Some(r) = app.ui.rename_label else { return };
+    let quad = app.session.tool.labels.iter().find(|(i, _)| *i == r.id).map(|(_, q)| q.map(|p| app.to_screen(p.x, p.y)));
+    let name = app.session.doc().ok().and_then(|d| d.node(r.id)).map(|n| n.name.clone());
+    let (Some(quad), Some(name)) = (quad, name) else {
+        app.ui.rename_label = None;
+        return;
+    };
+    let area = Rect::from_points(&quad);
+    let font = regular(11.0);
+    let text_w = ui.painter().layout_no_wrap(name.clone(), font.clone(), Color32::WHITE).size().x;
+    let rect = Rect::from_min_size(pos2(area.min.x, area.max.y - 16.0), vec2((text_w + 24.0).max(area.width()).clamp(80.0, 480.0), 16.0));
+    let (done, open) = crate::widgets::rename_field(ui, egui::Id::new(("frame_label_rename", r.id)), &name, rect, font, r.start);
+    app.ui.rename_label = open.then_some(crate::layers::Rename { id: r.id, start: false });
+    if let Some(new) = done {
+        app.run("object.rename", serde_json::json!({"ids": [r.id], "name": new}));
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/ui-egui/src/handles.rs b/crates/ui-egui/src/handles.rs
index 282e351ff..ec489bf82 100644
--- a/crates/ui-egui/src/handles.rs
+++ b/crates/ui-egui/src/handles.rs
@@ -11,10 +11,17 @@ use figcraft_geom::Point;
 use serde_json::json;
 
 use crate::colorpicker::PickerTarget;
-use crate::theme::{ACCENT, semibold};
+use crate::theme::semibold;
 use crate::{FigApp, RightTab};
 
-const PINK: Color32 = Color32::from_rgb(0xF2, 0x48, 0x8C);
+pub(crate) const PINK: Color32 = Color32::from_rgb(0xF2, 0x48, 0x8C);
+
+pub(crate) fn pink_label(painter: &egui::Painter, label: String, center: Pos2) {
+    let galley = painter.layout_no_wrap(label, semibold(10.0), Color32::WHITE);
+    let rect = Rect::from_center_size(center, galley.size() + vec2(8.0, 4.0));
+    painter.rect_filled(rect, CornerRadius::same(3), PINK);
+    painter.galley(rect.min + vec2(4.0, 2.0), galley, Color32::WHITE);
+}
 
 #[derive(Clone, Debug)]
 enum Drag {
@@ -286,7 +293,12 @@ pub fn draw(app: &FigApp, painter: &egui::Painter) {
             painter.rect_filled(r, CornerRadius::same(2), crate::theme::doc_c32(painter.ctx(), s.color.with_alpha(1.0)));
             painter.rect_stroke(r, CornerRadius::same(2), Stroke::new(2.0, Color32::WHITE), StrokeKind::Outside);
             if i == selected {
-                painter.rect_stroke(r.expand(2.0), CornerRadius::same(3), Stroke::new(1.5, ACCENT), StrokeKind::Outside);
+                painter.rect_stroke(
+                    r.expand(2.0),
+                    CornerRadius::same(3),
+                    Stroke::new(1.5, crate::theme::canvas_accent(painter.ctx())),
+                    StrokeKind::Outside,
+                );
             }
         }
         for (i, p) in [a, b, c].iter().enumerate() {
@@ -294,7 +306,7 @@ pub fn draw(app: &FigApp, painter: &egui::Painter) {
                 continue;
             }
             painter.circle_filled(*p, 5.0, Color32::WHITE);
-            painter.circle_stroke(*p, 5.0, Stroke::new(1.5, ACCENT));
+            painter.circle_stroke(*p, 5.0, Stroke::new(1.5, crate::theme::canvas_accent(painter.ctx())));
         }
         return;
     }
@@ -304,8 +316,8 @@ pub fn draw(app: &FigApp, painter: &egui::Painter) {
         painter.line_segment([a, b], Stroke::new(1.0, Color32::from_black_alpha(120)));
         // The start is hollow (least blur), the end filled (most blur by default).
         painter.circle_filled(a, 5.0, Color32::WHITE);
-        painter.circle_stroke(a, 5.0, Stroke::new(1.5, ACCENT));
-        painter.circle_filled(b, 5.0, ACCENT);
+        painter.circle_stroke(a, 5.0, Stroke::new(1.5, crate::theme::canvas_accent(painter.ctx())));
+        painter.circle_filled(b, 5.0, crate::theme::canvas_accent(painter.ctx()));
         painter.circle_stroke(b, 5.0, Stroke::new(1.5, Color32::WHITE));
         return;
     }
@@ -313,11 +325,11 @@ pub fn draw(app: &FigApp, painter: &egui::Painter) {
         let Some(c) = crop_corners(app, id, r) else { return };
         let outline = vec![c[0], c[1], c[2], c[3], c[0]];
         painter.add(Shape::line(outline.clone(), Stroke::new(2.0, Color32::WHITE)));
-        painter.add(Shape::line(outline, Stroke::new(1.0, ACCENT)));
+        painter.add(Shape::line(outline, Stroke::new(1.0, crate::theme::canvas_accent(painter.ctx()))));
         for p in c {
             let hr = Rect::from_center_size(p, vec2(8.0, 8.0));
             painter.rect_filled(hr, CornerRadius::ZERO, Color32::WHITE);
-            painter.rect_stroke(hr, CornerRadius::ZERO, Stroke::new(1.0, ACCENT), StrokeKind::Inside);
+            painter.rect_stroke(hr, CornerRadius::ZERO, Stroke::new(1.0, crate::theme::canvas_accent(painter.ctx())), StrokeKind::Inside);
         }
         return;
     }
@@ -338,11 +350,7 @@ pub fn draw(app: &FigApp, painter: &egui::Painter) {
         let hot = hover.is_some_and(|h| r.contains(h)) || active_side == Some(*side);
         if hot {
             painter.rect_filled(*r, CornerRadius::ZERO, PINK.gamma_multiply(0.25));
-            let label = crate::canvas::fmt(*v);
-            let galley = painter.layout_no_wrap(label, semibold(10.0), Color32::WHITE);
-            let lr = Rect::from_center_size(r.center(), galley.size() + vec2(8.0, 4.0));
-            painter.rect_filled(lr, CornerRadius::same(3), PINK);
-            painter.galley(lr.min + vec2(4.0, 2.0), galley, Color32::WHITE);
+            pink_label(painter, crate::canvas::fmt(*v), r.center());
         }
     }
     let drag_key = match &dragging {
@@ -356,10 +364,7 @@ pub fn draw(app: &FigApp, painter: &egui::Painter) {
             painter.rect_filled(r, CornerRadius::ZERO, PINK.gamma_multiply(0.3));
             let c = r.center();
             painter.line_segment([pos2(c.x - 3.0, c.y), pos2(c.x + 3.0, c.y)], Stroke::new(1.0, PINK));
-            let galley = painter.layout_no_wrap(crate::canvas::fmt(g.value), semibold(10.0), Color32::WHITE);
-            let lr = Rect::from_center_size(c, galley.size() + vec2(8.0, 4.0));
-            painter.rect_filled(lr, CornerRadius::same(3), PINK);
-            painter.galley(lr.min + vec2(4.0, 2.0), galley, Color32::WHITE);
+            pink_label(painter, crate::canvas::fmt(g.value), c);
         }
     }
     let _ = Align2::CENTER_CENTER;
diff --git a/crates/ui-egui/src/home.rs b/crates/ui-egui/src/home.rs
index abbd04404..326a3b142 100644
--- a/crates/ui-egui/src/home.rs
+++ b/crates/ui-egui/src/home.rs
@@ -51,6 +51,8 @@ impl Section {
 #[derive(Default)]
 pub struct Home {
     pub section: Section,
+    /// Searches known files and starter templates together from the home sidebar.
+    pub file_query: String,
     /// The Templates search text and kind filter.
     pub query: String,
     pub kind: Option<Kind>,
@@ -143,7 +145,7 @@ pub fn show(app: &mut FigApp, ui: &mut Ui) {
         let left = Rect::from_min_size(rect.min, vec2(SIDEBAR, rect.height()));
         ui.painter().line_segment([left.right_top(), left.right_bottom()], Stroke::new(1.0, t.border));
         sidebar(app, ui, &t, left);
-        if app.ui.home_view.section == Section::Online {
+        if app.ui.home_view.file_query.trim().is_empty() && app.ui.home_view.section == Section::Online {
             // Your online files lay themselves out in the area (and scroll their own list).
             let area = Rect::from_min_max(pos2(left.max.x + 40.0, rect.min.y + 24.0), rect.max - vec2(40.0, 24.0));
             crate::online::section(app, ui, area, &t);
@@ -155,9 +157,14 @@ pub fn show(app: &mut FigApp, ui: &mut Ui) {
             egui::ScrollArea::vertical().id_salt("home").auto_shrink([false, false]).show(ui, |ui| {
                 egui::Frame::NONE.inner_margin(egui::Margin::symmetric(40, 24)).show(ui, |ui| {
                     ui.spacing_mut().item_spacing = vec2(GAP, 0.0);
-                    match app.ui.home_view.section {
-                        Section::Templates => templates(app, ui, &t),
-                        _ => recents(app, ui, &t),
+                    if app.ui.home_view.file_query.trim().is_empty() {
+                        match app.ui.home_view.section {
+                            Section::Templates => templates(app, ui, &t),
+                            _ => recents(app, ui, &t),
+                        }
+                    } else {
+                        search_results(app, ui, &t);
+                        opened_join(app);
                     }
                 });
             });
@@ -173,35 +180,33 @@ pub fn show(app: &mut FigApp, ui: &mut Ui) {
 fn dropped(app: &mut FigApp, ctx: &egui::Context) {
     let files = ctx.input(|i| i.raw.dropped_files.clone());
     for f in files {
-        let path = f.path().to_path_buf();
-        if !crate::opens(&path) {
+        if !crate::opens(f.path()) {
             app.toast(tr("Drop a .figcraft, .fig, .json, .svg or image file."));
             continue;
         }
-        // `opens` saw an extension, so there is a file name to tell the format by.
-        let name = path.file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_default();
-        let params = if path.exists() {
-            json!({"path": path.to_string_lossy()})
-        } else if let Some(bytes) = crate::dropped_bytes(&f) {
-            use base64::Engine as _;
-            let data = base64::engine::general_purpose::STANDARD.encode(&bytes);
-            json!({"data": data, "name": name})
-        } else {
-            continue;
-        };
-        app.ui.pending_opens.push(crate::pending_open::PendingOpen { label: name, params, command: "file.open", target: None });
+        crate::pending_open::open_dropped(app, &f);
     }
 }
 
 fn sidebar(app: &mut FigApp, ui: &mut Ui, t: &Tokens, left: Rect) {
     let mut y = left.min.y + 20.0;
-    icons::paint(ui.painter(), Rect::from_min_size(pos2(left.min.x + 16.0, y), vec2(20.0, 20.0)), Icon::Logo, ACCENT);
-    ui.painter().text(pos2(left.min.x + 44.0, y + 10.0), Align2::LEFT_CENTER, "FigCraft", semibold(14.0), t.text);
-    y += 48.0;
+    crate::theme::paint_app_icon(ui, Rect::from_min_size(pos2(left.min.x + 12.0, y - 4.0), vec2(32.0, 32.0)));
+    crate::theme::paint_wordmark(ui.painter(), pos2(left.min.x + 52.0, y + 12.0), 16.0, t);
+    y += 52.0;
+    let search = Rect::from_min_size(pos2(left.min.x + 8.0, y), vec2(SIDEBAR - 16.0, widgets::FIELD_H));
+    ui.scope_builder(egui::UiBuilder::new().max_rect(search), |ui| {
+        let response =
+            widgets::text_input(ui, Id::new("home_file_search"), &mut app.ui.home_view.file_query, search.width(), tr("Search files and templates"));
+        a11y::text(&response, tr("Search files and templates"), &app.ui.home_view.file_query);
+        if (response.has_focus() || response.lost_focus()) && ui.input(|i| i.key_pressed(egui::Key::Escape)) {
+            app.ui.home_view.file_query.clear();
+        }
+    });
+    y += widgets::FIELD_H + 12.0;
     for (section, icon, label) in Section::ALL {
         let r = Rect::from_min_size(pos2(left.min.x + 8.0, y), vec2(SIDEBAR - 16.0, 32.0));
         let resp = ui.interact(r, ui.id().with(("home_section", label)), Sense::click());
-        let current = app.ui.home_view.section == section;
+        let current = app.ui.home_view.file_query.trim().is_empty() && app.ui.home_view.section == section;
         a11y::tab(&resp, tr(label), current);
         if current || resp.hovered() {
             ui.painter().rect_filled(r, CornerRadius::same(5), if current { t.selected_row } else { t.hover });
@@ -211,11 +216,65 @@ fn sidebar(app: &mut FigApp, ui: &mut Ui, t: &Tokens, left: Rect) {
         ui.painter().text(pos2(r.min.x + 36.0, r.center().y), Align2::LEFT_CENTER, tr(label), regular(12.0), t.text);
         if resp.clicked() {
             app.ui.home_view.section = section;
+            app.ui.home_view.file_query.clear();
         }
         y += 34.0;
     }
 }
 
+fn file_matches(name: &str, location: &str, query: &str) -> bool {
+    name.to_lowercase().contains(query) || location.to_lowercase().contains(query)
+}
+
+/// One search over known files and starter templates. It never sends a query or owner token to a
+/// server; online files are opened through their existing owner-token command only on click.
+fn search_results(app: &mut FigApp, ui: &mut Ui, t: &Tokens) {
+    heading(ui, t, tr("Search results"));
+    let query = app.ui.home_view.file_query.trim().to_lowercase();
+    let mut count = open_files(app, ui, t, &query);
+    count += crate::home_recents::section(app, ui, t, &query);
+
+    let online: Vec<_> = app.session.prefs.online_files.iter().filter(|f| file_matches(&f.name, &f.server, &query)).cloned().collect();
+    let mut open_online = None;
+    if !online.is_empty() {
+        subheading(ui, t, tr("Online files"));
+        for f in &online {
+            count += 1;
+            let host = figcraft_engine::online::server_host(&f.server);
+            let icon = crate::online::mark(f.shared.is_some());
+            let row = FileRow {
+                mark: Some((icon, if f.shared.is_some() { t.success } else { t.icon_secondary })),
+                name: &f.name,
+                ink: t.text,
+                detail: host,
+                detail_size: 11.0,
+                detail_ink: t.text_secondary,
+            };
+            if listed(ui, t, ui.id().with(("search_online", &f.server, &f.file)), 36.0, &row) {
+                open_online = Some(f.clone());
+            }
+        }
+    }
+    let templates: Vec<&Template> = TEMPLATES.iter().filter(|template| matches(template, &query, None)).collect();
+    if !templates.is_empty() {
+        subheading(ui, t, tr("Templates"));
+        template_grid(app, ui, t, &templates);
+    }
+    if count == 0 && templates.is_empty() {
+        ui.label(egui::RichText::new(tr("No files or templates match your search")).font(semibold(13.0)).color(t.text));
+        ui.add_space(6.0);
+        widgets::label(ui, tr("Try another search, or browse templates."), t.text_secondary);
+        ui.add_space(16.0);
+        if widgets::button(ui, tr("Show all templates"), false, true).clicked() {
+            app.ui.home_view.file_query.clear();
+            app.ui.home_view.section = Section::Templates;
+        }
+    }
+    if let Some(file) = open_online {
+        crate::online::open(app, &file);
+    }
+}
+
 /// A ring around a card or row that has the keyboard.
 fn focus_ring(ui: &Ui, t: &Tokens, rect: Rect, resp: &Response, radius: u8) {
     if resp.has_focus() {
@@ -253,8 +312,8 @@ fn action_card(ui: &mut Ui, t: &Tokens, icon: Icon, title: &str, sub: &str) -> b
     }
     card_frame(ui, t, r, &resp);
     let ir = Rect::from_min_size(pos2(r.min.x + 16.0, r.center().y - 16.0), vec2(32.0, 32.0));
-    ui.painter().rect_filled(ir, CornerRadius::same(6), ACCENT);
-    icons::paint(ui.painter(), ir.shrink(8.0), icon, Color32::WHITE);
+    ui.painter().rect_filled(ir, CornerRadius::same(6), t.accent);
+    icons::paint(ui.painter(), ir.shrink(8.0), icon, t.accent_on);
     ui.painter().text(pos2(r.min.x + 60.0, r.center().y - 8.0), Align2::LEFT_CENTER, title_shown, semibold(12.0), t.text);
     ui.painter().text(pos2(r.min.x + 60.0, r.center().y + 9.0), Align2::LEFT_CENTER, sub_shown, regular(11.0), t.text_secondary);
     resp.clicked()
@@ -262,13 +321,14 @@ fn action_card(ui: &mut Ui, t: &Tokens, icon: Icon, title: &str, sub: &str) -> b
 
 fn recents(app: &mut FigApp, ui: &mut Ui, t: &Tokens) {
     heading(ui, t, tr("Recents"));
-    let (mut new_file, mut open) = (false, false);
-    ui.horizontal(|ui| {
-        new_file = action_card(ui, t, Icon::Plus, tr("New design file"), tr("Start from a blank canvas"));
+    let (mut new_file, mut new_board, mut open) = (false, false, false);
+    ui.horizontal_wrapped(|ui| {
+        new_file = action_card(ui, t, Icon::PenNib, tr("New design file"), tr("Start from a blank canvas"));
+        new_board = action_card(ui, t, Icon::Board, tr("New board"), tr("Sticky notes, shapes and connectors"));
         open = action_card(ui, t, Icon::Page, tr("Open file"), tr("Open .figcraft, .svg or images"));
     });
-    if new_file {
-        app.run("file.new", json!({}));
+    if new_file || new_board {
+        app.run(if new_board { "file.newBoard" } else { "file.new" }, json!({}));
         app.ui.home = false;
     }
     if open {
@@ -290,24 +350,8 @@ fn recents(app: &mut FigApp, ui: &mut Ui, t: &Tokens) {
         ui.add_space(28.0);
         getting_started(app, ui, t);
     }
-    if !app.session.docs.is_empty() {
-        subheading(ui, t, tr("Open files"));
-        let mut switch = None;
-        for (i, d) in app.session.docs.iter().enumerate() {
-            let detail = d.path.as_deref().unwrap_or_default();
-            let row =
-                FileRow { mark: Some((Icon::Logo, ACCENT)), name: &d.doc.name, ink: t.text, detail, detail_size: 11.0, detail_ink: t.text_secondary };
-            if listed(ui, t, ui.id().with(("open", d.uid)), 36.0, &row) {
-                switch = Some(i);
-            }
-        }
-        if let Some(i) = switch {
-            app.run("doc.switch", json!({"index": i}));
-            app.ui.home = false;
-        }
-    }
-    let recents = app.session.prefs.recent_files.clone();
-    if recents.is_empty() {
+    open_files(app, ui, t, "");
+    if crate::home_recents::listed(&app.session.prefs.recent_files).next().is_none() {
         // A first run: nothing to reopen yet, so offer something to start from.
         subheading(ui, t, tr("Start from a template"));
         let shown: Vec<&Template> = TEMPLATES.iter().take(FIRST_RUN).collect();
@@ -318,7 +362,38 @@ fn recents(app: &mut FigApp, ui: &mut Ui, t: &Tokens) {
         }
         return;
     }
-    crate::home_recents::section(app, ui, t);
+    crate::home_recents::section(app, ui, t, "");
+}
+
+/// The Open files list: the documents whose name or path has `query` (lower case; all for ""), a
+/// row each; choosing one shows its tab. How many are listed.
+fn open_files(app: &mut FigApp, ui: &mut Ui, t: &Tokens, query: &str) -> usize {
+    let hit = |d: &&figcraft_engine::DocState| file_matches(&d.doc.name, d.path.as_deref().unwrap_or_default(), query);
+    let count = app.session.docs.iter().filter(hit).count();
+    if count == 0 {
+        return 0;
+    }
+    subheading(ui, t, tr("Open files"));
+    let mut switch = None;
+    for (i, d) in app.session.docs.iter().enumerate().filter(|(_, d)| hit(d)) {
+        let detail = d.path.as_deref().unwrap_or_default();
+        let row = FileRow {
+            mark: Some((icons::file_mark(d.doc.kind), ACCENT)),
+            name: &d.doc.name,
+            ink: t.text,
+            detail,
+            detail_size: 11.0,
+            detail_ink: t.text_secondary,
+        };
+        if listed(ui, t, ui.id().with(("open", d.uid)), 36.0, &row) {
+            switch = Some(i);
+        }
+    }
+    if let Some(i) = switch {
+        app.run("doc.switch", json!({"index": i}));
+        app.ui.home = false;
+    }
+    count
 }
 
 /// The file joined from the home screen (a code, or one of your online files) opened in a tab of
diff --git a/crates/ui-egui/src/home_recents.rs b/crates/ui-egui/src/home_recents.rs
index d633f7762..2d39c6fe1 100644
--- a/crates/ui-egui/src/home_recents.rs
+++ b/crates/ui-egui/src/home_recents.rs
@@ -10,6 +10,7 @@
 use std::collections::HashMap;
 use std::path::Path;
 
+use chrono::Datelike;
 use egui::{Align2, Color32, CornerRadius, Id, Key, Rect, Response, Sense, Stroke, StrokeKind, Ui, pos2, vec2};
 use figcraft_engine::Prefs;
 use figcraft_format::thumbnail::{FileKind, Preview};
@@ -200,18 +201,35 @@ const MONTHS: [&str; 12] = [
     tr_noop("Dec"),
 ];
 
-/// `secs` since 1970 as a date in UTC: "Mar 4, 2026".
+/// (days since 1970-01-01, seconds-of-day, nanos) → (proleptic Gregorian year, the same wall-clock
+/// instant moved into chrono's range by whole 400-year cycles). The calendar repeats every 400
+/// years (146_097 days), so month, day and time of day come from chrono and only the year is
+/// carried, which keeps the result exact for any `i64` day count. This is not hand-rolled calendar
+/// math: chrono still does the date, the cycle count just shifts the year.
+fn utc_parts(days: i64, sod: u32, nanos: u32) -> (i64, chrono::NaiveDateTime) {
+    let (cycles, rest) = (days.div_euclid(146_097), days.rem_euclid(146_097));
+    // `rest + 719_163` (1970-01-01 is CE day 719_163) is always a valid CE day, and `sod` < 86_400.
+    let date = i32::try_from(rest + 719_163).ok().and_then(chrono::NaiveDate::from_num_days_from_ce_opt);
+    let time = chrono::NaiveTime::from_num_seconds_from_midnight_opt(sod.min(86_399), nanos.min(999_999_999));
+    match (date, time) {
+        (Some(d), Some(t)) => {
+            let y = i128::from(d.year()) + i128::from(cycles) * 400;
+            (i64::try_from(y).unwrap_or(if y < 0 { i64::MIN } else { i64::MAX }), d.and_time(t))
+        }
+        _ => (1970, chrono::NaiveDateTime::default()), // unreachable
+    }
+}
+
+/// `secs` since 1970 as a date in UTC: "Mar 4, 2026". Years past chrono's own range (262143) keep
+/// converting: the instant is moved into range by whole 400-year cycles and the real year restored,
+/// so every `u64` reads as the date the old hand-rolled conversion produced.
 fn date(secs: u64) -> String {
-    // Days to a civil date (Howard Hinnant's days_from_civil, inverted).
-    let z = i64::try_from(secs / 86_400).unwrap_or(0) + 719_468;
-    let era = z.div_euclid(146_097);
-    let doe = z.rem_euclid(146_097);
-    let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
-    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
-    let mp = (5 * doy + 2) / 153;
-    let day = doy - (153 * mp + 2) / 5 + 1;
-    let month = if mp < 10 { mp + 3 } else { mp - 9 };
-    let year = yoe + era * 400 + i64::from(month <= 2);
+    // The day count of any `u64` seconds fits in `i64` (`u64::MAX / 86_400` ≈ 2.1e14), so the
+    // conversion is always exact (no epoch fallback). Splitting with `u64` arithmetic (as the old
+    // code did) avoids the `i64` seconds overflow near `u64::MAX`.
+    let (days, sod) = (i64::try_from(secs / 86_400).unwrap_or(i64::MAX), (secs % 86_400) as u32);
+    let (year, dt) = utc_parts(days, sod, 0);
+    let (month, day) = (i64::from(dt.month()), i64::from(dt.day()));
     let name = usize::try_from(month - 1).ok().and_then(|m| MONTHS.get(m)).map_or("", |m| tr(m));
     trf("{month} {day}, {year}", &[("month", &name), ("day", &day), ("year", &year)])
 }
@@ -234,6 +252,8 @@ pub struct Shown {
     pub name: String,
     /// `None` until the file has been looked at.
     pub stat: Option<Stat>,
+    /// A design file or a board (design until its picture has been read).
+    pub kind: figcraft_doc::FileKind,
 }
 
 impl Shown {
@@ -241,7 +261,7 @@ impl Shown {
         // Shown without its extension, like a document's name; the full path is the tooltip.
         let p = Path::new(path);
         let name = p.file_stem().or_else(|| p.file_name()).map_or_else(|| path.to_string(), |f| f.to_string_lossy().into_owned());
-        Shown { path: path.to_string(), name, stat }
+        Shown { path: path.to_string(), name, stat, kind: figcraft_doc::FileKind::Design }
     }
 
     fn date(&self, key: SortKey) -> Option<u64> {
@@ -293,6 +313,7 @@ struct Ready {
     modified: Option<u64>,
     page: Option<Color32>,
     texture: Option<egui::TextureHandle>,
+    kind: figcraft_doc::FileKind,
     /// When it came in (for its fade).
     arrived: f64,
 }
@@ -461,7 +482,7 @@ impl Recents {
                         let page = preview.page.map(|[r, g, b, a]| crate::theme::c32(figcraft_color::Color { r, g, b, a }));
                         // A changed file's new picture shows at once; a first one fades in.
                         let arrived = if k.shown.is_some() { f64::NEG_INFINITY } else { time };
-                        k.shown = Some(Ready { modified, page, texture, arrived });
+                        k.shown = Some(Ready { modified, page, texture, kind: preview.kind, arrived });
                         k.wanted = None;
                     }
                 }
@@ -501,12 +522,18 @@ impl Recents {
 
     /// The files as listed, with what is known about them.
     fn shown(&self, paths: &[String]) -> Vec<Shown> {
-        paths.iter().map(|p| Shown::new(p, self.files.get(p).and_then(|k| k.stat))).collect()
+        paths
+            .iter()
+            .map(|p| {
+                let k = self.files.get(p);
+                Shown { kind: k.and_then(|k| k.shown.as_ref()).map_or_else(Default::default, |r| r.kind), ..Shown::new(p, k.and_then(|k| k.stat)) }
+            })
+            .collect()
     }
 
     /// For `ui.inspect`: each file listed, whether it is there and whether its picture is in.
     pub fn inspect(&self, prefs: &Prefs) -> Value {
-        let paths: Vec<String> = prefs.recent_files.iter().take(SHOWN).cloned().collect();
+        let paths: Vec<String> = listed(&prefs.recent_files).take(SHOWN).cloned().collect();
         let files: Vec<Value> = sorted(self.shown(&paths), Sort::of(prefs))
             .iter()
             .map(|f| {
@@ -525,6 +552,12 @@ impl Recents {
     }
 }
 
+/// The recent files that may be listed: all of them, or, when the app runs confined to automation
+/// roots, those inside them (no name or picture of another file is shown).
+pub(crate) fn listed(recents: &[String]) -> impl Iterator<Item = &String> {
+    recents.iter().filter(|p| figcraft_engine::file_access::allowed(p, figcraft_engine::file_access::Access::Read))
+}
+
 /// The recent files for `ui.inspect`: `{view, sort, order, files: [{path, name, exists, picture,
 /// selected}]}` in the order shown (`picture`: `none`, `loading`, `picture`, `page` or
 /// `placeholder`).
@@ -548,16 +581,27 @@ enum Action {
     View(View),
 }
 
-/// The Recent files heading, its toolbar and the files as cards or a table.
-pub fn section(app: &mut FigApp, ui: &mut Ui, t: &Tokens) {
-    let paths: Vec<String> = app.session.prefs.recent_files.iter().take(SHOWN).cloned().collect();
+/// The Recent files heading, its toolbar and the files as cards or a table. With a `query` (lower
+/// case, from the Home search) only the files not open whose path has it, from every recent file;
+/// nothing at all when none has it. How many files are shown.
+pub fn section(app: &mut FigApp, ui: &mut Ui, t: &Tokens, query: &str) -> usize {
+    let searching = !query.is_empty();
+    // A search reaches every recent file; the files shown without one stay known through it.
+    let paths: Vec<String> = listed(&app.session.prefs.recent_files).take(if searching { usize::MAX } else { SHOWN }).cloned().collect();
     let time = ui.input(|i| i.time);
     let now = figcraft_engine::cmd::comment::now_secs();
     let reduce_motion = app.reduce_motion();
     let (view, sort) = (View::of(&app.session.prefs), Sort::of(&app.session.prefs));
     let state = &mut app.ui.home_view.recents;
     state.refresh(ui.ctx(), &paths, time);
-    let files = sorted(state.shown(&paths), sort);
+    let mut files = sorted(state.shown(&paths), sort);
+    if searching {
+        let docs = &app.session.docs;
+        files.retain(|f| f.path.to_lowercase().contains(query) && !docs.iter().any(|d| d.path.as_deref() == Some(f.path.as_str())));
+        if files.is_empty() {
+            return 0;
+        }
+    }
     let with_created = files.iter().any(|f| f.stat.is_some_and(|s| s.created.is_some()));
     let mut action = toolbar(ui, t, view, sort, with_created);
     ui.add_space(16.0);
@@ -568,7 +612,7 @@ pub fn section(app: &mut FigApp, ui: &mut Ui, t: &Tokens) {
     action = action.or(chosen);
     match action {
         Some(Action::Open(path)) => {
-            if app.run("file.open", json!({"path": path})).is_some() {
+            if app.run_user("file.open", json!({"path": path})).is_some() {
                 app.ui.home = false;
             }
         }
@@ -587,6 +631,7 @@ pub fn section(app: &mut FigApp, ui: &mut Ui, t: &Tokens) {
         }
         None => {}
     }
+    files.len()
 }
 
 /// "Recent files", and at the right the sort menu and the grid and list buttons.
@@ -715,13 +760,13 @@ fn arrows(ui: &Ui, recents: &mut Recents, files: &[Shown], across: usize, down:
     }
 }
 
-/// The square file-type mark before a name.
-fn file_icon(ui: &Ui, t: &Tokens, center: egui::Pos2, path: &str) {
+/// The square file-type mark before a name (a design file's pen nib, a board's note).
+fn file_icon(ui: &Ui, t: &Tokens, center: egui::Pos2, file: &Shown) {
     let r = Rect::from_center_size(center, vec2(16.0, 16.0));
-    match FileKind::of(Path::new(path)) {
+    match FileKind::of(Path::new(&file.path)) {
         FileKind::FigCraft | FileKind::Fig => {
-            ui.painter().rect_filled(r, CornerRadius::same(4), ACCENT);
-            icons::paint(ui.painter(), r.shrink(3.0), Icon::Logo, Color32::WHITE);
+            ui.painter().rect_filled(r, CornerRadius::same(4), t.accent);
+            icons::paint(ui.painter(), r.shrink(3.0), icons::file_mark(file.kind), t.accent_on);
         }
         kind => {
             ui.painter().rect_filled(r, CornerRadius::same(4), t.field);
@@ -831,7 +876,7 @@ fn card(
     }
     p.line_segment([pos2(rect.min.x, area.max.y + 0.5), pos2(rect.max.x, area.max.y + 0.5)], Stroke::new(1.0, t.border));
     let y = area.max.y + 1.0 + FOOTER_H / 2.0;
-    file_icon(ui, t, pos2(rect.min.x + 24.0, y), &file.path);
+    file_icon(ui, t, pos2(rect.min.x + 24.0, y), file);
     let (x, w) = (rect.min.x + 44.0, rect.width() - 56.0);
     let name = widgets::elide_font(ui, &file.name, w, semibold(12.5));
     p.text(pos2(x, y - 8.0), Align2::LEFT_CENTER, name, semibold(12.5), t.text);
@@ -899,6 +944,8 @@ fn list(ui: &mut Ui, t: &Tokens, recents: &mut Recents, files: &[Shown], now: u6
         if !ui.is_rect_visible(r) {
             continue;
         }
+        // The row's mark says what kind of file it is: read it like a card's picture.
+        recents.picture(&file.path, true, ui.input(|i| i.time));
         let selected = recents.selected.as_deref() == Some(file.path.as_str());
         let p = ui.painter();
         if selected {
@@ -909,7 +956,7 @@ fn list(ui: &mut Ui, t: &Tokens, recents: &mut Recents, files: &[Shown], now: u6
         if resp.has_focus() && !selected {
             p.rect_stroke(r, CornerRadius::same(5), Stroke::new(2.0, t.focus), StrokeKind::Inside);
         }
-        file_icon(ui, t, pos2(r.min.x + 20.0, r.center().y), &file.path);
+        file_icon(ui, t, pos2(r.min.x + 20.0, r.center().y), file);
         let name_w = date_x(1) - 52.0;
         p.text(
             pos2(r.min.x + 40.0, r.center().y),
@@ -947,3 +994,24 @@ fn list(ui: &mut Ui, t: &Tokens, recents: &mut Recents, files: &[Shown], now: u6
     arrows(ui, recents, files, 0, 1);
     action
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// `date` keeps the exact "Mon D, YYYY" (UTC) output the hand-rolled days-from-civil code
+    /// produced. With no catalog loaded the month and format strings pass through in English.
+    #[test]
+    fn date_formats_seconds_since_1970_in_utc() {
+        assert_eq!(date(0), "Jan 1, 1970");
+        assert_eq!(date(951_782_400), "Feb 29, 2000");
+        assert_eq!(date(1_709_164_800), "Feb 29, 2024");
+        assert_eq!(date(1_741_046_400), "Mar 4, 2025");
+        // A year past chrono's own `NaiveDate` range (262143): the instant is moved into range by
+        // whole 400-year cycles and the real year restored.
+        assert_eq!(date(253_402_300_800), "Jan 1, 10000");
+        // Past chrono's year range, `u64::MAX` keeps the old hand-rolled output instead of falling
+        // back to the epoch.
+        assert_eq!(date(u64::MAX), "Nov 9, 584554051223");
+    }
+}
diff --git a/crates/ui-egui/src/home_recents_tests.rs b/crates/ui-egui/src/home_recents_tests.rs
index 1c3235ddb..d01e5222a 100644
--- a/crates/ui-egui/src/home_recents_tests.rs
+++ b/crates/ui-egui/src/home_recents_tests.rs
@@ -74,7 +74,7 @@ fn columns_follow_the_width() {
 
 fn shown(path: &str, modified: Option<u64>, created: Option<u64>) -> Shown {
     let stat = Some(Stat { exists: modified.is_some(), modified, created });
-    Shown { path: path.into(), name: Path::new(path).file_stem().unwrap().to_string_lossy().into(), stat }
+    Shown { path: path.into(), name: Path::new(path).file_stem().unwrap().to_string_lossy().into(), stat, kind: Default::default() }
 }
 
 #[test]
@@ -256,9 +256,11 @@ fn rects_of(s: &[Shape], c: egui::Color32) -> usize {
     s.iter().filter(|s| matches!(s, Shape::Rect(r) if r.fill == c)).count()
 }
 
-/// Images drawn (meshes with a texture of their own).
+/// Preview images in the main content area, excluding the branded sidebar icon.
 fn images(s: &[Shape]) -> usize {
-    s.iter().filter(|s| matches!(s, Shape::Mesh(m) if m.texture_id != egui::TextureId::default())).count()
+    s.iter()
+        .filter(|s| matches!(s, Shape::Mesh(m) if m.texture_id != egui::TextureId::default() && m.vertices.iter().any(|v| v.pos.x > 240.0)))
+        .count()
 }
 
 #[test]
diff --git a/crates/ui-egui/src/home_tests.rs b/crates/ui-egui/src/home_tests.rs
index 873636561..ebbf6d95e 100644
--- a/crates/ui-egui/src/home_tests.rs
+++ b/crates/ui-egui/src/home_tests.rs
@@ -6,6 +6,7 @@
 use egui::accesskit::Role;
 use egui::{Event, Key, Modifiers, PointerButton, Pos2, Rect, Shape};
 use figcraft_engine::Session;
+use figcraft_engine::online::OnlineFile;
 use figcraft_engine::templates::TEMPLATES;
 use serde_json::json;
 
@@ -184,6 +185,161 @@ fn typing_in_the_search_field_filters() {
     assert!(u.app.session.docs.is_empty(), "typing opens nothing");
 }
 
+#[test]
+fn home_search_finds_known_files_and_opens_an_existing_tab() {
+    let mut session = Session::new();
+    session.execute("file.rename", &json!({"name": "North Trail"})).unwrap();
+    session.docs[0].path = Some("C:/designs/North Trail.figcraft".into());
+    session.prefs.recent_files =
+        vec!["C:/designs/North Trail.figcraft".into(), "C:/designs/South Trail.figcraft".into(), "C:/designs/Other.figcraft".into()];
+    session.prefs.online_files.push(OnlineFile {
+        server: "wss://share.example/".into(),
+        file: "trail".into(),
+        name: "Trail Live".into(),
+        owner: "test-only-secret".into(),
+        ..OnlineFile::default()
+    });
+    let mut u = Ui::new(session);
+    u.app.ui.home = true;
+    u.app.ui.home_view.file_query = "  TRAIL  ".into();
+    let s = settle(&mut u);
+    assert!(has_text(&s, "Search results"));
+    assert!(has_text(&s, "North Trail") && has_text(&s, "South Trail") && has_text(&s, "Trail Live"));
+    assert!(!has_text(&s, "Other") && !has_text(&s, "test-only-secret"));
+    assert_eq!(texts(&s).iter().filter(|(name, pos, _)| name == "North Trail" && pos.y > 90.0).count(), 1, "an open file is not repeated in recents");
+    assert_eq!(u.app.inspect()["homeSearch"], "  TRAIL  ");
+
+    u.app.ui.home_view.file_query = "nothing matches".into();
+    let s = shapes(&mut u);
+    assert!(has_text(&s, "No files or templates match your search"));
+    assert!(!has_text(&s, "Trail Live") && !has_text(&s, "South Trail"));
+    assert!(!texts(&s).iter().any(|(name, pos, _)| name == "North Trail" && pos.y > 90.0));
+
+    u.app.ui.home_view.file_query = "north".into();
+    let s = shapes(&mut u);
+    click(&mut u, text_center(&s, "North Trail"));
+    assert!(!u.app.ui.home, "choosing an open result shows its editor tab");
+    assert_eq!(u.app.session.docs.len(), 1);
+}
+
+#[test]
+fn home_search_shows_a_saved_files_preview() {
+    let dir = std::env::temp_dir().join(format!("figcraft-home-search-preview-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("Search preview.figcraft");
+    let image = image::RgbaImage::from_pixel(64, 32, image::Rgba([30, 140, 210, 255]));
+    let mut png = Vec::new();
+    image.write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).unwrap();
+    let doc = figcraft_doc::Document::new("Search preview");
+    std::fs::write(&path, figcraft_format::save_bytes(&doc, Some(&png)).unwrap()).unwrap();
+
+    let mut session = Session::empty();
+    session.prefs.recent_files.push(path.to_string_lossy().into_owned());
+    let mut u = Ui::new(session);
+    u.app.ui.home_view.file_query = "Search preview".into();
+    for _ in 0..400 {
+        u.frame(vec![]);
+        if u.app.inspect()["homeRecents"]["files"][0]["picture"] == "picture" {
+            break;
+        }
+        std::thread::sleep(std::time::Duration::from_millis(5));
+    }
+    let s = shapes(&mut u);
+    assert!(has_text(&s, "Search preview"));
+    assert!(s.iter().any(|s| matches!(s, Shape::Mesh(m) if m.texture_id != egui::TextureId::default())), "the saved preview is drawn");
+    let _ = std::fs::remove_file(path);
+    let _ = std::fs::remove_dir(dir);
+}
+
+#[test]
+fn home_search_field_filters_as_typed_and_a_section_click_clears_it() {
+    let mut u = first_run();
+    u.app.session.prefs.recent_files = vec!["C:/designs/Glacier.figcraft".into(), "C:/designs/Forest.figcraft".into()];
+    let s = shapes(&mut u);
+    click(&mut u, text_center(&s, "Search files and templates"));
+    u.frame(vec![Event::Text("glacier".into())]);
+    let s = settle(&mut u);
+    assert_eq!(u.app.ui.home_view.file_query, "glacier");
+    assert!(has_text(&s, "Glacier") && !has_text(&s, "Forest"));
+    click(&mut u, text_center(&s, "Recents"));
+    assert!(u.app.ui.home_view.file_query.is_empty());
+    let s = shapes(&mut u);
+    assert!(has_text(&s, "Forest"));
+    // Escape in the field clears the search too.
+    click(&mut u, text_center(&s, "Search files and templates"));
+    u.frame(vec![Event::Text("forest".into())]);
+    assert_eq!(u.app.ui.home_view.file_query, "forest");
+    u.frame(vec![Event::Key { key: Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE }]);
+    assert!(u.app.ui.home_view.file_query.is_empty(), "Escape clears the search");
+}
+
+/// A search keeps what the recent files it doesn't match know: back from it, their pictures and
+/// the selection are still there (nothing is read again).
+#[test]
+fn a_search_keeps_the_other_recent_files_pictures_and_the_selection() {
+    let dir = std::env::temp_dir().join(format!("figcraft-home-search-cache-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let mut png = Vec::new();
+    image::RgbaImage::from_pixel(8, 8, image::Rgba([30, 140, 210, 255]))
+        .write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png)
+        .unwrap();
+    let paths: Vec<String> = ["Alpine", "Basin"]
+        .into_iter()
+        .map(|name| {
+            let path = dir.join(format!("{name}.figcraft"));
+            std::fs::write(&path, figcraft_format::save_bytes(&figcraft_doc::Document::new(name), Some(&png)).unwrap()).unwrap();
+            path.to_string_lossy().into_owned()
+        })
+        .collect();
+    let mut session = Session::empty();
+    session.prefs.recent_files = paths.clone();
+    let mut u = Ui::new(session);
+    let pictures = |u: &mut Ui| -> Vec<serde_json::Value> {
+        u.app.inspect()["homeRecents"]["files"].as_array().unwrap().iter().map(|f| f["picture"].clone()).collect()
+    };
+    for _ in 0..400 {
+        u.frame(vec![]);
+        if pictures(&mut u).iter().all(|p| p == "picture") {
+            break;
+        }
+        std::thread::sleep(std::time::Duration::from_millis(5));
+    }
+    assert!(pictures(&mut u).iter().all(|p| p == "picture"), "both pictures are in");
+    u.app.ui.home_view.recents.selected = Some(paths[1].clone());
+    u.app.ui.home_view.file_query = "alpine".into();
+    let s = shapes(&mut u);
+    assert!(has_text(&s, "Alpine") && !has_text(&s, "Basin"));
+    u.app.ui.home_view.file_query.clear();
+    u.frame(vec![]);
+    assert!(pictures(&mut u).iter().all(|p| p == "picture"), "no picture is read again");
+    assert_eq!(u.app.ui.home_view.recents.selected.as_deref(), Some(paths[1].as_str()), "the selection stays");
+    let _ = std::fs::remove_dir_all(dir);
+}
+
+#[test]
+fn home_search_includes_templates_and_opens_a_matching_card() {
+    let mut u = first_run();
+    u.app.ui.home_view.file_query = "MOBILE".into();
+    let s = settle(&mut u);
+    assert!(has_text(&s, "Templates") && has_text(&s, "Mobile app"));
+    assert!(!has_text(&s, "Dashboard"));
+    click(&mut u, text_center(&s, "Mobile app"));
+    assert_eq!(u.app.session.doc().unwrap().name, "Mobile app");
+    assert!(!u.app.ui.home);
+}
+
+#[test]
+fn empty_home_search_can_browse_all_templates() {
+    let mut u = first_run();
+    u.app.ui.home_view.file_query = "no such design".into();
+    let s = shapes(&mut u);
+    assert!(has_text(&s, "No files or templates match your search"));
+    click(&mut u, text_center(&s, "Show all templates"));
+    assert!(u.app.ui.home_view.file_query.is_empty());
+    assert_eq!(u.app.ui.home_view.section, Section::Templates);
+    assert!(has_text(&settle(&mut u), "Dashboard"));
+}
+
 #[test]
 fn thumbnails_are_cached_per_theme() {
     let mut u = first_run();
@@ -380,6 +536,108 @@ fn drop_file(u: &mut Ui, path: &std::path::Path) -> Vec<Shape> {
     hovering
 }
 
+/// A file dropped with its contents but no file on disk (a virtual file from another app).
+#[derive(Debug)]
+struct DroppedBytes(std::path::PathBuf, Vec<u8>);
+
+impl egui::DroppedFile for DroppedBytes {
+    fn path(&self) -> &std::path::Path {
+        &self.0
+    }
+
+    fn bytes(&self) -> Result<Vec<u8>, String> {
+        Ok(self.1.clone())
+    }
+}
+
+#[test]
+fn dropping_a_file_without_one_on_disk_opens_it_as_a_new_unsaved_document() {
+    let dir = Temp::new();
+    let path = dir.path("virtual.svg");
+    assert!(!path.exists());
+    let svg = br#"<svg xmlns="http://www.w3.org/2000/svg" width="40" height="20"><rect width="40" height="20" fill="red"/></svg>"#.to_vec();
+    let mut u = first_run();
+    u.app.ui.home = true;
+    let file: egui::DroppedFileHandle = std::sync::Arc::new(DroppedBytes(path.clone(), svg));
+    u.frame_raw(egui::RawInput { dropped_files: vec![file], ..Default::default() });
+    assert_eq!(u.app.ui.pending_opens.len(), 1);
+    for _ in 0..3 {
+        u.frame(vec![]);
+    }
+    assert!(u.app.ui.pending_opens.is_empty());
+    assert_eq!(u.app.ui.last_error, None);
+    assert_eq!(u.app.session.docs.len(), 1, "the dropped contents open");
+    assert_eq!(u.app.session.docs[0].path, None, "with no save path made up for them");
+    assert!(u.app.session.docs[0].doc.nodes().any(|n| matches!(n.kind, figcraft_doc::NodeKind::Rectangle)), "the SVG's content");
+    assert!(!u.app.ui.home, "and the editor shows it");
+    assert!(!path.exists(), "nothing is written");
+}
+
+/// What a drop's read gives, once it has arrived.
+type Arrival = std::rc::Rc<std::cell::RefCell<Option<Result<Vec<u8>, String>>>>;
+
+/// A drop whose contents arrive later, as every drop in the browser does: pending until `arrived`
+/// holds them.
+fn later(arrived: &Arrival) -> crate::ReadFuture {
+    let arrived = arrived.clone();
+    Box::pin(std::future::poll_fn(move |_| match arrived.borrow_mut().take() {
+        Some(bytes) => std::task::Poll::Ready(bytes),
+        None => std::task::Poll::Pending,
+    }))
+}
+
+#[test]
+fn a_dropped_file_whose_contents_arrive_later_opens_once_they_do() {
+    let svg = br#"<svg xmlns="http://www.w3.org/2000/svg" width="40" height="20"><rect width="40" height="20" fill="red"/></svg>"#.to_vec();
+    let arrived = std::rc::Rc::new(std::cell::RefCell::new(None));
+    let mut u = first_run();
+    u.app.ui.home = true;
+    u.app.ui.pending_opens.push(crate::pending_open::PendingOpen {
+        label: "Browser drop.svg".into(),
+        params: json!({"name": "Browser drop.svg"}),
+        command: "file.open",
+        target: None,
+        read: Some(later(&arrived)),
+    });
+    // egui lays a new card out invisibly on its first frame.
+    u.frame(vec![]);
+    for _ in 0..5 {
+        let s = flat(&u.frame_output(vec![]).shapes);
+        assert!(has_text(&s, "Browser drop.svg"), "the card shows while the contents are read");
+    }
+    assert!(u.app.session.docs.is_empty(), "nothing opens before the contents arrive");
+    *arrived.borrow_mut() = Some(Ok(svg));
+    for _ in 0..3 {
+        u.frame(vec![]);
+    }
+    assert!(u.app.ui.pending_opens.is_empty());
+    assert_eq!(u.app.ui.last_error, None);
+    assert_eq!(u.app.session.docs.len(), 1, "the contents open");
+    assert_eq!(u.app.session.docs[0].path, None);
+    assert!(u.app.session.docs[0].doc.nodes().any(|n| matches!(n.kind, figcraft_doc::NodeKind::Rectangle)), "the SVG's content");
+    assert!(!u.app.ui.home);
+}
+
+#[test]
+fn a_dropped_file_that_cannot_be_read_says_so_and_opens_nothing() {
+    let arrived = std::rc::Rc::new(std::cell::RefCell::new(Some(Err(crate::unreadable("Unreadable.figcraft")))));
+    let mut u = first_run();
+    u.app.ui.home = true;
+    u.app.ui.pending_opens.push(crate::pending_open::PendingOpen {
+        label: "Unreadable.figcraft".into(),
+        params: json!({"name": "Unreadable.figcraft"}),
+        command: "file.open",
+        target: None,
+        read: Some(later(&arrived)),
+    });
+    for _ in 0..3 {
+        u.frame(vec![]);
+    }
+    assert!(u.app.ui.pending_opens.is_empty());
+    assert!(u.app.session.docs.is_empty());
+    assert_eq!(u.app.ui.last_error.as_deref(), Some("Couldn't read Unreadable.figcraft."));
+}
+
 #[test]
 fn dropping_a_native_file_on_the_home_screen_opens_it() {
     let dir = Temp::new();
@@ -410,9 +668,8 @@ fn dropping_a_native_file_on_the_home_screen_opens_it() {
 #[test]
 fn dropping_a_native_file_on_canvas_keeps_its_receiving_document_after_tab_switch() {
     let dir = Temp::new();
-    let path = dir.path("Canvas import.figcraft");
-    let mut source = Session::new();
-    source.execute("file.saveAs", &json!({"path": path.to_string_lossy()})).unwrap();
+    let path = dir.path("Canvas import.svg");
+    std::fs::write(&path, r#"<svg xmlns="http://www.w3.org/2000/svg" width="20" height="10"><rect width="20" height="10"/></svg>"#).unwrap();
 
     let mut session = Session::new();
     let target_uid = session.ds().unwrap().uid;
@@ -438,7 +695,82 @@ fn dropping_a_native_file_on_canvas_keeps_its_receiving_document_after_tab_switc
     u.frame(vec![]);
 
     assert_eq!(u.app.session.ds().unwrap().uid, other_uid, "the user's active tab stays in front");
-    assert_eq!(u.app.session.docs.iter().map(|doc| doc.doc.pages.len()).collect::<Vec<_>>(), [2, 1]);
+    let layers = |uid: u64| {
+        let doc = &u.app.session.docs.iter().find(|doc| doc.uid == uid).unwrap().doc;
+        doc.node(doc.pages[0]).unwrap().children.len()
+    };
+    assert_eq!((layers(target_uid), layers(other_uid)), (1, 0), "the drop lands in the tab that received it");
+}
+
+#[test]
+fn dropping_a_document_on_canvas_opens_it_as_a_new_file() {
+    let dir = Temp::new();
+    let path = dir.path("Dropped.figcraft");
+    let mut saved = Session::new();
+    saved.execute("file.saveAs", &json!({"path": path.to_string_lossy()})).unwrap();
+    let mut u = Ui::new(Session::new());
+    u.app.ui.home = false;
+    u.frame(vec![]);
+    let before = u.app.session.doc().unwrap().clone();
+    let s = drop_file(&mut u, &path);
+    assert!(has_text(&s, "Drop to open"), "dragging a document over the canvas says it opens");
+    let s = flat(&u.frame_output(vec![]).shapes);
+    assert!(has_text(&s, "Opening as a new file"), "the card says so too");
+    u.frame(vec![]);
+    assert!(u.app.ui.pending_opens.is_empty());
+    assert_eq!(u.app.session.docs.len(), 2, "a tab of its own");
+    assert_eq!(u.app.session.ds().unwrap().path.as_deref(), Some(path.to_string_lossy().as_ref()), "in front");
+    assert_eq!(u.app.session.docs[0].doc.as_ref(), &before, "the file that was open gets no pages added");
+}
+
+#[test]
+fn a_document_dropped_on_canvas_without_a_file_on_disk_opens_as_a_new_file() {
+    // Every drop in the browser (#916).
+    let dir = Temp::new();
+    let saved = dir.path("Saved.figcraft");
+    Session::new().execute("file.saveAs", &json!({"path": saved.to_string_lossy()})).unwrap();
+    let bytes = std::fs::read(&saved).unwrap();
+    let mut u = Ui::new(Session::new());
+    u.app.ui.home = false;
+    u.frame(vec![]);
+    let pos = u.app.canvas.rect.center();
+    let file: egui::DroppedFileHandle = std::sync::Arc::new(DroppedBytes("Shared.figcraft".into(), bytes));
+    u.frame_raw(egui::RawInput { events: vec![Event::PointerMoved(pos)], dropped_files: vec![file], ..Default::default() });
+    for _ in 0..3 {
+        u.frame(vec![]);
+    }
+    assert!(u.app.ui.pending_opens.is_empty());
+    assert_eq!(u.app.ui.last_error, None);
+    assert_eq!(u.app.session.docs.len(), 2, "a tab of its own");
+    assert_eq!(u.app.session.docs[0].doc.pages.len(), 1, "no pages added to the open file");
+    assert_eq!(u.app.session.docs[1].path, None, "with no save path made up for it");
+}
+
+#[test]
+fn dropping_several_files_on_canvas_places_them_side_by_side() {
+    let dir = Temp::new();
+    let svg = r##"<svg xmlns="http://www.w3.org/2000/svg" width="20" height="10"><rect width="20" height="10" fill="#f00"/></svg>"##;
+    let paths: Vec<_> = ["a.svg", "b.svg", "c.svg"].iter().map(|n| dir.path(n)).collect();
+    for path in &paths {
+        std::fs::write(path, svg).unwrap();
+    }
+    let mut u = Ui::new(Session::new());
+    u.app.ui.home = false;
+    u.frame(vec![]);
+    let pos = u.app.canvas.rect.center();
+    let files: Vec<egui::DroppedFileHandle> = paths.iter().map(|p| std::sync::Arc::new(Dropped(p.clone())) as egui::DroppedFileHandle).collect();
+    u.frame_raw(egui::RawInput { events: vec![Event::PointerMoved(pos)], dropped_files: files, ..Default::default() });
+    for _ in 0..4 {
+        u.frame(vec![]);
+    }
+    assert!(u.app.ui.pending_opens.is_empty());
+    let doc = u.app.session.doc().unwrap();
+    let page = u.app.session.page().unwrap();
+    let rects: Vec<_> = doc.node(page).unwrap().children.iter().map(|c| doc.world_bounds(*c).unwrap()).collect();
+    assert_eq!(rects.len(), 3);
+    for pair in rects.windows(2) {
+        assert!(pair[1].x0 > pair[0].x1, "left to right with a gap: {rects:?}");
+    }
 }
 
 #[test]
diff --git a/crates/ui-egui/src/i18n.rs b/crates/ui-egui/src/i18n.rs
index d30130fbd..9faff0016 100644
--- a/crates/ui-egui/src/i18n.rs
+++ b/crates/ui-egui/src/i18n.rs
@@ -27,7 +27,8 @@ pub struct Lang {
     pub code: &'static str,
     /// The language's own name for itself (the language picker shows it untranslated).
     pub name: &'static str,
-    /// Machine-drafted, waiting for a native speaker's review (`[meta] status`).
+    /// A draft (`[meta] status` set): waiting for a native speaker's review, or reviewed and waiting for
+    /// a maintainer's approval.
     pub draft: bool,
     /// Index into [`LANGS`] of the catalog a regional one overlays ("es" under "es-419": it lists
     /// only what differs), else 0 (English).
@@ -108,9 +109,14 @@ fn lookup(lang: usize, key: &str) -> Option<&'static Text> {
 /// The UI string for `key` (its English text) in the current language. One English text that needs
 /// two translations gets a context after `|` ("Fill|sizing"); the English catalog maps it back.
 pub fn tr(key: &str) -> &str {
-    match lookup(CURRENT.load(Ordering::Relaxed), key) {
-        Some(Text::Plain(s) | Text::Plural { other: s, .. }) => s,
-        None => key,
+    try_tr(key).unwrap_or(key)
+}
+
+/// [`tr`] for text that comes from data and may have no catalog entry (an importer's notes, say):
+/// `None` when the catalog doesn't have it.
+pub fn try_tr(key: &str) -> Option<&str> {
+    match lookup(CURRENT.load(Ordering::Relaxed), key)? {
+        Text::Plain(s) | Text::Plural { other: s, .. } => Some(s),
     }
 }
 
@@ -166,9 +172,10 @@ fn plural(code: &str, n: usize) -> Plural {
         "cs" if n == 1 => Plural::One,
         "cs" if (2..=4).contains(&n) => Plural::Few,
         "cs" => Plural::Other,
+        "pl" if n == 1 => Plural::One,
         "ru" if n % 10 == 1 && n % 100 != 11 => Plural::One,
-        "ru" if (2..=4).contains(&(n % 10)) && !(12..=14).contains(&(n % 100)) => Plural::Few,
-        "ru" => Plural::Many,
+        "ru" | "pl" if (2..=4).contains(&(n % 10)) && !(12..=14).contains(&(n % 100)) => Plural::Few,
+        "ru" | "pl" => Plural::Many,
         "ja" | "ko" | "zh-Hans" => Plural::Other,
         "fr" | "pt-BR" if n <= 1 => Plural::One,
         _ if n == 1 => Plural::One,
@@ -177,7 +184,7 @@ fn plural(code: &str, n: usize) -> Plural {
 }
 
 // CLDR's million-count "many" in French, Spanish and Portuguese still reads their existing
-// "other" wording. Czech supplies separate few forms; Russian supplies few/many forms.
+// "other" wording. Czech supplies separate few forms; Russian and Polish supply few/many forms.
 
 /// Whether count `n` takes the "one" form: 0 and 1 in French and Brazilian Portuguese, never in
 /// Japanese, Korean and Chinese (no plural forms: always "other"), 1 elsewhere (CLDR's integer rules).
diff --git a/crates/ui-egui/src/i18n_tests.rs b/crates/ui-egui/src/i18n_tests.rs
index 07f320374..fa7da946b 100644
--- a/crates/ui-egui/src/i18n_tests.rs
+++ b/crates/ui-egui/src/i18n_tests.rs
@@ -1,13 +1,11 @@
 //! The catalog checks: every key the code looks up is in the English catalog, no catalog has keys
-//! the code doesn't use, placeholders match English, and complete languages translate everything.
+//! the code doesn't use, and placeholders match English. A missing translation reads English and
+//! fails nothing: [`missing_translations_report`] lists them (`cargo xtask i18n-report`).
 
 use std::collections::BTreeSet;
 
 use super::*;
 
-/// Languages that must translate every UI string and command label.
-const COMPLETE: &[&str] = &["es"];
-
 /// Keys looked up from data rather than written as `tr("…")` in the code: the main menu's
 /// submenu names (the engine's menu catalog) and labels of engine and document enums.
 fn dynamic_keys() -> BTreeSet<String> {
@@ -132,9 +130,13 @@ fn dynamic_labels() -> Vec<&'static str> {
     use figcraft_engine::keymap::{GESTURES, Group};
     let mut v: Vec<&'static str> = figcraft_engine::ToolId::ALL.iter().map(|t| t.label()).collect();
     v.extend(figcraft_engine::vectoredit::VTool::ALL.iter().map(|t| t.label()));
+    // Board shapes and stamps (the board tools' flyouts and the contextual bar).
+    v.extend(figcraft_doc::BoardShape::ALL.iter().map(|b| b.label()));
+    v.extend(figcraft_doc::Stamp::ALL.iter().map(|b| b.label()));
     v.extend(Group::ALL.iter().map(|g| g.label()));
     v.extend(GESTURES.iter().flat_map(|(_, label, mac, other)| [*label, *mac, *other]));
     v.extend(DATA_LABELS);
+    v.push(figcraft_engine::live::TOO_LARGE_TO_JOIN);
     // The starter templates' names, descriptions and kinds.
     v.extend(figcraft_engine::templates::TEMPLATES.iter().flat_map(|t| [t.name, t.description, t.kind.label()]));
     v
@@ -160,15 +162,39 @@ fn used_keys() -> BTreeSet<String> {
         if !name.ends_with(".rs") || name.ends_with("_tests.rs") || name == "i18n.rs" {
             continue;
         }
-        keys.extend(literals(&std::fs::read_to_string(&path).unwrap()));
+        keys.extend(literals(&std::fs::read_to_string(&path).unwrap(), LOOKUPS));
     }
     keys
 }
 
-/// The first-argument string literals of the lookup functions in `src`.
-fn literals(src: &str) -> Vec<String> {
+/// The importers' fixed notes: the string literals passed to `warn` in the `.fig` and REST import
+/// sources. The import report shows a note translated when the catalog has it, so each one is a key
+/// `en.toml` (and every complete language) must have, and an entry for a note the importers no
+/// longer give shows up as unused.
+fn importer_notes() -> BTreeSet<String> {
+    let src = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../format/src");
+    let mut keys = BTreeSet::new();
+    for dir in ["fig", "rest"] {
+        for entry in std::fs::read_dir(src.join(dir)).unwrap().flatten() {
+            let path = entry.path();
+            let name = path.file_name().unwrap().to_string_lossy().into_owned();
+            // export.rs warns about what a `.fig` export leaves out, not about an import.
+            if !name.ends_with(".rs") || name.contains("tests") || name == "export.rs" {
+                continue;
+            }
+            keys.extend(literals(&std::fs::read_to_string(&path).unwrap(), &["warn("]));
+        }
+    }
+    keys
+}
+
+/// The lookup functions whose first argument is a catalog key.
+const LOOKUPS: &[&str] = &["tr(", "trf(", "trn(", "tr_noop("];
+
+/// The first-argument string literals of the functions `fns` (each with its `(`) in `src`.
+fn literals(src: &str, fns: &[&str]) -> Vec<String> {
     let mut out = Vec::new();
-    for f in ["tr(", "trf(", "trn(", "tr_noop("] {
+    for f in fns {
         let mut from = 0;
         while let Some(i) = src.get(from..).and_then(|s| s.find(f)) {
             let at = from + i;
@@ -226,7 +252,7 @@ fn english() -> &'static Lang {
 
 #[test]
 fn every_key_in_the_code_is_in_the_english_catalog_and_no_other() {
-    let used: BTreeSet<String> = used_keys().into_iter().chain(dynamic_keys()).collect();
+    let used: BTreeSet<String> = used_keys().into_iter().chain(dynamic_keys()).chain(importer_notes()).collect();
     let en: BTreeSet<String> = english().ui.iter().map(|(k, _)| k.to_string()).collect();
     let missing: Vec<_> = used.difference(&en).collect();
     let unused: Vec<_> = en.difference(&used).collect();
@@ -249,14 +275,19 @@ fn english_text_is_its_key_except_plurals() {
     assert!(english().commands.is_empty() && english().menu.is_empty(), "English command labels come from the engine");
 }
 
-#[test]
-fn catalogs_have_known_keys_and_matching_placeholders() {
-    let en = english();
-    let ids: BTreeSet<&str> = figcraft_engine::all_commands()
+/// The ids `[commands]` entries translate: every command and every main-menu item.
+fn command_ids() -> BTreeSet<&'static str> {
+    figcraft_engine::all_commands()
         .iter()
         .map(|c| c.id)
         .chain(figcraft_engine::catalog::MENU.iter().map(|m| m.id).filter(|id| !id.is_empty()))
-        .collect();
+        .collect()
+}
+
+#[test]
+fn catalogs_have_known_keys_and_matching_placeholders() {
+    let en = english();
+    let ids = command_ids();
     for lang in LANGS {
         assert!(!lang.name.is_empty(), "{}: [meta] name is missing", lang.code);
         for (k, t) in lang.ui {
@@ -277,13 +308,29 @@ fn catalogs_have_known_keys_and_matching_placeholders() {
         for (id, _) in lang.menu {
             assert!(menu_worded_differently().contains(id), "{}: [menu] {id:?} reads like the command; [commands] covers it", lang.code);
         }
-        if COMPLETE.contains(&lang.code) {
-            let missing: Vec<_> = en.ui.iter().filter(|(k, _)| find(lang.ui, k).is_none()).map(|(k, _)| k).collect();
-            assert!(missing.is_empty(), "{}: untranslated: {missing:?}", lang.code);
-            let missing: Vec<_> = ids.iter().filter(|id| find(lang.commands, id).is_none()).collect();
-            assert!(missing.is_empty(), "{}: untranslated commands: {missing:?}", lang.code);
-            let missing: Vec<_> = menu_worded_differently().into_iter().filter(|id| find(lang.menu, id).is_none()).collect();
-            assert!(missing.is_empty(), "{}: menu items worded unlike their command, missing from [menu]: {missing:?}", lang.code);
+    }
+}
+
+/// What each language lacks: UI strings, command labels and menu wordings that read as in English
+/// because neither its catalog nor the one it overlays has them. It prints them and always passes.
+#[test]
+fn missing_translations_report() {
+    let ids = command_ids();
+    let worded = menu_worded_differently();
+    for (i, lang) in LANGS.iter().enumerate().filter(|(_, l)| l.code != "en") {
+        let own = || chain(i).filter(|l| l.code != "en");
+        let ui: Vec<_> = english().ui.iter().map(|(k, _)| *k).filter(|k| own().all(|l| find(l.ui, k).is_none())).collect();
+        let commands: Vec<_> = ids.iter().filter(|id| own().all(|l| find(l.commands, id).is_none())).collect();
+        let menu: Vec<_> = worded.iter().filter(|id| own().all(|l| find(l.menu, id).is_none())).collect();
+        println!("{}: {} UI strings, {} command labels, {} menu wordings missing", lang.code, ui.len(), commands.len(), menu.len());
+        for k in ui {
+            println!("  {k:?}");
+        }
+        for id in commands {
+            println!("  [commands] {id}");
+        }
+        for id in menu {
+            println!("  [menu] {id}");
         }
     }
 }
@@ -303,6 +350,14 @@ fn lookups_fall_back_to_english_and_fill_placeholders() {
     assert!(matches!(lookup(es, k), Some(x) if std::ptr::eq(x, t)));
 }
 
+#[test]
+fn a_live_failure_the_ui_knows_is_read_back_for_translation() {
+    use figcraft_engine::live::TOO_LARGE_TO_JOIN;
+    let reason = TOO_LARGE_TO_JOIN.replace("{mb}", "1024");
+    assert!(matches!(crate::live::failure_text(&reason), std::borrow::Cow::Owned(t) if t == reason));
+    assert!(matches!(crate::live::failure_text("Couldn't reach the server"), std::borrow::Cow::Borrowed(_)));
+}
+
 #[test]
 fn system_languages_pick_the_first_one_with_a_catalog() {
     let code = |pref: &str, system: Option<&str>| LANGS[resolve(pref, system)].code;
@@ -311,19 +366,18 @@ fn system_languages_pick_the_first_one_with_a_catalog() {
     assert_eq!(code("system", Some("cs_CZ.UTF-8")), "cs");
     assert_eq!(code("system", Some("cs-CZ,en-US")), "cs");
     assert_eq!(code("cs", None), "cs");
-    assert_eq!(LANGS[resolve("cs", None)].name, "Čeština");
-    assert!(LANGS[resolve("cs", None)].draft);
     assert_eq!(code("system", Some("pt-BR")), "pt-BR");
     assert_eq!(code("system", Some("tr_TR.UTF-8")), "tr");
     assert_eq!(code("system", Some("id_ID.UTF-8")), "id");
     // Portugal's Portuguese and a bare "pt" read the Brazilian catalog.
     assert_eq!(code("system", Some("pt-PT")), "pt-BR");
     assert_eq!(code("pt", None), "pt-BR");
-    // An OS list: the first language there is a catalog for (English counts).
-    assert_eq!(code("system", Some("nl-NL,de-DE,en-US")), "de");
-    assert_eq!(code("system", Some("nl-NL, en-US,fr-FR")), "en");
-    assert_eq!(code("system", Some("nl,da")), "en");
-    assert_eq!(code("system", Some("nl,sv")), "sv");
+    // An OS list: the first language there is a catalog for (English counts). Hindi has no
+    // catalog (Dutch gained one; `hi` keeps exercising the no-catalog path).
+    assert_eq!(code("system", Some("hi-IN,de-DE,en-US")), "de");
+    assert_eq!(code("system", Some("hi-IN, en-US,fr-FR")), "en");
+    assert_eq!(code("system", Some("hi,da")), "en");
+    assert_eq!(code("system", Some("hi,sv")), "sv");
     assert_eq!(code("fr", Some("de-DE")), "fr", "a chosen language beats the system's");
 }
 
@@ -334,8 +388,6 @@ fn swedish_is_picked_for_swedish_locales() {
         assert_eq!(code("system", Some(tag)), "sv", "{tag}");
     }
     let sv = LANGS.iter().position(|l| l.code == "sv").unwrap();
-    assert_eq!(LANGS[sv].name, "Svenska");
-    assert!(!LANGS[sv].draft);
     assert!(!plural_one(sv, 0) && plural_one(sv, 1) && !plural_one(sv, 2));
 }
 
@@ -353,10 +405,11 @@ fn latin_american_spanish_overlays_spanish() {
     assert_eq!(LANGS[la].parent, es);
     assert!(es < la, "the picker lists Español first");
     // Its own wording, else Spanish's, else English's.
-    assert!(matches!(lookup(la, "Add fill"), Some(Text::Plain("Agregar relleno"))));
-    assert!(matches!(lookup(la, "Fill"), Some(Text::Plain("Relleno"))));
+    for (k, _) in LANGS[es].ui.iter().filter(|(k, _)| find(LANGS[la].ui, k).is_none()) {
+        assert!(lookup(la, k).is_some_and(|t| std::ptr::eq(t, find(LANGS[es].ui, k).unwrap())), "{k:?}");
+    }
     let undo = |i: usize| chain(i).find_map(|l| find(l.commands, "edit.undo")).map(forms);
-    assert!(undo(es).is_some() && undo(la) == undo(es), "command labels fall back too");
+    assert_eq!(undo(la), undo(es), "command labels fall back too");
     // An overlay lists only what differs from the catalog under it.
     for lang in LANGS.iter().filter(|l| l.parent != 0) {
         let under = &LANGS[lang.parent];
@@ -375,7 +428,7 @@ fn french_and_portuguese_count_zero_as_singular() {
     for code in ["fr", "pt-BR"] {
         assert!(one(code, 0) && one(code, 1) && !one(code, 2), "{code}");
     }
-    for code in ["en", "es", "de", "cs"] {
+    for code in ["en", "es", "de", "cs", "pl"] {
         for n in [0, 1, 2, 3, 4, 5, 21] {
             assert_eq!(one(code, n), n == 1, "{code}: {n}");
         }
@@ -396,6 +449,33 @@ fn japanese_korean_and_chinese_have_no_plural_forms() {
     }
 }
 
+#[test]
+fn georgian_is_picked_for_georgian_locales() {
+    let code = |pref: &str, system: Option<&str>| LANGS[resolve(pref, system)].code;
+    for tag in ["ka", "ka-GE", "ka_GE.UTF-8"] {
+        assert_eq!(code("system", Some(tag)), "ka", "{tag}");
+    }
+}
+
+/// Release builds embed craft-fonts' Noto Sans Georgian (`theme::install_fonts`' built-in faces),
+/// since Inter and egui's fonts have no Georgian: it draws every Georgian letter the catalog uses.
+#[test]
+fn the_built_in_georgian_face_draws_the_georgian_catalog() {
+    let Some(face) = figcraft_text::find_face("Noto Sans Georgian", "Regular").filter(|f| f.family == "Noto Sans Georgian") else {
+        eprintln!("built without craft-fonts' Noto Sans Georgian; skipping");
+        return;
+    };
+    let ka = &LANGS[LANGS.iter().position(|l| l.code == "ka").unwrap()];
+    let georgian = |c: &char| matches!(u32::from(*c), 0x10A0..=0x10FF | 0x1C90..=0x1CBF | 0x2D00..=0x2D2F);
+    let mut letters: BTreeSet<char> = BTreeSet::new();
+    for (_, t) in ka.ui.iter().chain(ka.commands).chain(ka.menu) {
+        letters.extend(forms(t).into_iter().flat_map(str::chars).filter(georgian));
+    }
+    assert!(letters.len() > 30, "{letters:?}");
+    let missing: String = letters.iter().filter(|c| !face.has_char(**c)).collect();
+    assert!(missing.is_empty(), "no glyph for {missing:?}");
+}
+
 #[test]
 fn chinese_reads_simplified_and_traditional_has_no_catalog() {
     let code = |pref: &str, system: Option<&str>| LANGS[resolve(pref, system)].code;
@@ -408,7 +488,6 @@ fn chinese_reads_simplified_and_traditional_has_no_catalog() {
         assert_eq!(code(tag, None), "en", "{tag}");
     }
     assert_eq!(code("system", Some("zh-TW,ja-JP")), "ja");
-    assert_eq!(LANGS[resolve("zh-Hans", None)].name, "简体中文");
 }
 
 #[test]
@@ -416,62 +495,59 @@ fn the_key_scanner_reads_rust_literals() {
     let src = r#"x(tr("A \"b\"")); trf(
         "C {n}", &[]); attr("no"); tr_noop("D\
           E"); tr(label);"#;
-    assert_eq!(literals(src), vec!["A \"b\"", "C {n}", "DE"]);
+    assert_eq!(literals(src, LOOKUPS), vec!["A \"b\"", "C {n}", "DE"]);
+    assert_eq!(literals(r#"self.warn("a note"); s.warn(format!("{n}")); forewarn("no")"#, &["warn("]), vec!["a note"]);
 }
 
 #[test]
 fn czech_integer_plurals() {
-    let cs = LANGS.iter().position(|l| l.code == "cs").unwrap();
     assert_eq!(plural("cs", 1), Plural::One);
-    assert_eq!(fill(counted(cs, "{n} layers", 1), &[("n", &1)]), "1 vrstva");
     for n in [2, 3, 4] {
         assert_eq!(plural("cs", n), Plural::Few, "{n}");
-        assert_eq!(fill(counted(cs, "{n} layers", n), &[("n", &n)]), format!("{n} vrstvy"));
     }
     for n in [0, 5, 11, 12, 21, 22, 100, 1_000_000] {
         assert_eq!(plural("cs", n), Plural::Other, "{n}");
-        assert_eq!(fill(counted(cs, "{n} layers", n), &[("n", &n)]), format!("{n} vrstev"));
-    }
-    for (key, text) in LANGS[cs].ui {
-        if let Text::Plural { one, few, .. } = text {
-            assert!(one.is_some() && few.is_some(), "{key}: missing Czech plural forms");
-        }
     }
 }
 
 #[test]
 fn russian_language_tags_and_integer_plurals() {
     let ru = LANGS.iter().position(|l| l.code == "ru").unwrap();
-    assert_eq!(LANGS[ru].name, "Русский");
     for tag in ["ru", "ru-RU", "ru_RU.UTF-8", "RU", "ru-BY", "ru-Cyrl-RU"] {
         assert_eq!(resolve(tag, None), ru, "{tag}");
         assert_eq!(resolve("system", Some(tag)), ru, "{tag}");
     }
-    assert_eq!(resolve("system", Some("nl,ru-RU,en-US")), ru);
+    assert_eq!(resolve("system", Some("hi,ru-RU,en-US")), ru);
     for n in [1, 21, 31, 101, 1_001] {
         assert_eq!(plural("ru", n), Plural::One, "{n}");
-        assert_eq!(fill(counted(ru, "{n} layers", n), &[("n", &n)]), format!("{n} слой"));
     }
     for n in [2, 3, 4, 22, 23, 24, 102, 104, 1_002] {
         assert_eq!(plural("ru", n), Plural::Few, "{n}");
-        assert_eq!(fill(counted(ru, "{n} layers", n), &[("n", &n)]), format!("{n} слоя"));
     }
     for n in [0, 5, 10, 11, 12, 13, 14, 19, 20, 25, 100, 111, 112, 114, 1_000_000] {
         assert_eq!(plural("ru", n), Plural::Many, "{n}");
-        assert_eq!(fill(counted(ru, "{n} layers", n), &[("n", &n)]), format!("{n} слоёв"));
     }
-    for (key, text) in LANGS[ru].ui {
-        if let Text::Plural { one, few, many, .. } = text {
-            assert!(one.is_some() && few.is_some() && many.is_some(), "{key}: missing Russian plural forms");
-        }
+}
+
+#[test]
+fn polish_integer_plurals() {
+    assert_eq!(plural("pl", 1), Plural::One);
+    for n in [2, 3, 4, 22, 23, 24, 102, 104, 1_002] {
+        assert_eq!(plural("pl", n), Plural::Few, "{n}");
+    }
+    for n in [0, 5, 10, 11, 12, 13, 14, 19, 20, 21, 25, 31, 100, 101, 111, 112, 114, 1_000_000] {
+        assert_eq!(plural("pl", n), Plural::Many, "{n}");
     }
 }
 
 #[test]
 fn plural_fallback_uses_the_language_of_its_catalog() {
+    // A plural es-419 doesn't overlay reads Spanish's entry under Spanish's rule.
+    let es = LANGS.iter().position(|l| l.code == "es").unwrap();
     let la = LANGS.iter().position(|l| l.code == "es-419").unwrap();
-    assert_eq!(counted(la, "{n} layers", 1), "{n} capa");
-    assert_eq!(counted(la, "{n} layers", 21), "{n} capas");
+    for n in [1, 21] {
+        assert_eq!(counted(la, "{n} layers", n), counted(es, "{n} layers", n), "{n}");
+    }
     // Unsupported optional categories use other; existing one/other languages are unchanged.
     for code in ["en", "es", "de"] {
         for n in [0, 2, 11, 21, 1_000_000] {
diff --git a/crates/ui-egui/src/icons.rs b/crates/ui-egui/src/icons.rs
index 867b08944..8275df5e5 100644
--- a/crates/ui-egui/src/icons.rs
+++ b/crates/ui-egui/src/icons.rs
@@ -83,7 +83,15 @@ icons! {
     FlipH,
     FlipV,
     CornerRadius,
+    /// Individual corners: the rounded corner each field sets.
+    CornerTopLeft,
+    CornerTopRight,
+    CornerBottomRight,
+    CornerBottomLeft,
+    Angle,
     IndependentCorners,
+    /// Individual padding: a frame with one inward tick per side, each set alone.
+    IndependentPadding,
     LinkOn,
     LinkOff,
     LayoutH,
@@ -138,6 +146,11 @@ icons! {
     Fixed,
     PaddingH,
     PaddingV,
+    /// Individual padding sides: a frame with the controlled side filled.
+    PaddingTop,
+    PaddingRight,
+    PaddingBottom,
+    PaddingLeft,
     Gap,
     Reset,
     Detach,
@@ -185,6 +198,17 @@ icons! {
     LiveShared,
     /// A file of yours on a server that only you get into: a point inside a closed ring.
     LivePrivate,
+    /// A design file: a pen nib leaning to the left, its grip filled.
+    PenNib,
+    /// A board file (and the sticky note tool): a note with its bottom corner folded up.
+    Board,
+    /// Board tools: a chisel-tipped marker; a broad highlighter over its band; a connector
+    /// between two boxes; shapes (a square behind a circle); a stamp (a badge with a check).
+    Marker,
+    Highlighter,
+    Connector,
+    Shapes,
+    Stamp,
 }
 
 /// Points along a circular arc from angle `a0` to `a1` (radians, y down: increasing is clockwise).
@@ -420,6 +444,7 @@ pub fn paint(painter: &Painter, rect: Rect, icon: Icon, color: Color32) {
     draw(&p, icon);
 }
 
+/// Draw `icon` on the 16-unit grid through `p`, which maps grid units to the target box.
 fn draw(p: &P, icon: Icon) {
     use Icon::*;
     match icon {
@@ -445,18 +470,23 @@ fn draw(p: &P, icon: Icon) {
             p.path(&h, false);
         }
         Frame => {
-            p.line(5.5, 2.0, 5.5, 14.0);
-            p.line(10.5, 2.0, 10.5, 14.0);
-            p.line(2.0, 5.5, 14.0, 5.5);
-            p.line(2.0, 10.5, 14.0, 10.5);
+            // Inset a unit from the box: four long hinted strokes read heavier than the
+            // anti-aliased outlines beside them at full size (#737).
+            p.line(5.5, 3.0, 5.5, 13.0);
+            p.line(10.5, 3.0, 10.5, 13.0);
+            p.line(3.0, 5.5, 13.0, 5.5);
+            p.line(3.0, 10.5, 13.0, 10.5);
         }
         Section | Section2 => {
             p.rect(2.5, 5.5, 13.5, 13.5, 1.0);
             p.fill_rect(2.0, 2.0, 9.0, 6.0, 1.0);
         }
         Slice => {
-            p.rect(2.5, 2.5, 13.5, 13.5, 0.0);
-            p.line(2.5, 13.5, 13.5, 2.5);
+            // A knife, one silhouette (#739): a slim blade to the top right, outlined like the
+            // rest of the row, and a solid handle whose end overlaps the blade's base so the two
+            // join at every size.
+            p.poly(&[(13.5, 2.5), (5.0, 8.0), (8.0, 11.0)], true);
+            p.fill(&capsule((2.8, 13.2), (5.9, 10.1), 1.3));
         }
         Bend => {
             // A curve with a smooth point and its handle line.
@@ -522,11 +552,12 @@ fn draw(p: &P, icon: Icon) {
             p.line(9.0, 4.5, 11.5, 7.0);
         }
         Text => {
-            p.line(2.0, 3.5, 13.0, 3.5);
-            p.line(7.5, 3.0, 7.5, 13.0);
-            p.line(2.5, 3.0, 2.5, 6.0);
-            p.line(12.5, 3.0, 12.5, 6.0);
-            p.line(5.0, 12.5, 10.0, 12.5);
+            // Inset like the Frame mark, so its long strokes don't outweigh the outlines (#737).
+            p.line(3.0, 3.5, 12.0, 3.5);
+            p.line(7.5, 3.0, 7.5, 12.5);
+            p.line(3.5, 3.0, 3.5, 5.5);
+            p.line(11.5, 3.0, 11.5, 5.5);
+            p.line(5.5, 12.5, 9.5, 12.5);
         }
         Comment => {
             let mut b: Vec<(f32, f32)> = arc_pts(8.5, 7.5, 5.0, 2.75, TAU + 1.95).collect();
@@ -693,12 +724,29 @@ fn draw(p: &P, icon: Icon) {
             p.poly(&[(3.5, 5.5), (12.5, 5.5), (12.5, 1.5)], true);
             p.fill(&[(3.0, 9.0), (13.0, 9.0), (13.0, 14.0)]);
         }
-        CornerRadius => p.corner(2.5, 2.5, 1.0, 1.0, 11.5, 6.0),
+        CornerRadius | CornerTopLeft => p.corner(2.5, 2.5, 1.0, 1.0, 11.5, 6.0),
+        CornerTopRight => p.corner(13.5, 2.5, -1.0, 1.0, 11.5, 6.0),
+        CornerBottomRight => p.corner(13.5, 13.5, -1.0, -1.0, 11.5, 6.0),
+        CornerBottomLeft => p.corner(2.5, 13.5, 1.0, -1.0, 11.5, 6.0),
+        Angle => {
+            // Two rays from a vertex, the arc between them marking the angle (all unhinted, so
+            // the arc meets the rays at every size).
+            p.path(&[(13.5, 13.0), (2.5, 13.0), (10.5, 3.0)], false);
+            p.path(&arc_pts(2.5, 13.0, 6.0, (-10.0f32).atan2(8.0), 0.0).collect::<Vec<_>>(), false);
+        }
         IndependentCorners => {
             for (x, y, dx, dy) in [(2.5, 2.5, 1.0, 1.0), (13.5, 2.5, -1.0, 1.0), (2.5, 13.5, 1.0, -1.0), (13.5, 13.5, -1.0, -1.0)] {
                 p.corner(x, y, dx, dy, 4.0, 2.0);
             }
         }
+        IndependentPadding => {
+            // A frame outline with one inward tick per side: each side's padding, set alone.
+            p.rect(2.5, 2.5, 13.5, 13.5, 2.0);
+            p.line(8.0, 2.5, 8.0, 5.0);
+            p.line(13.5, 8.0, 11.0, 8.0);
+            p.line(8.0, 13.5, 8.0, 11.0);
+            p.line(2.5, 8.0, 5.0, 8.0);
+        }
         LinkOn | Link => {
             p.path(&capsule((4.0, 12.0), (6.5, 9.5), 2.4), true);
             p.path(&capsule((9.5, 6.5), (12.0, 4.0), 2.4), true);
@@ -916,12 +964,32 @@ fn draw(p: &P, icon: Icon) {
             p.line(3.0, 7.5, 13.0, 7.5);
         }
         PaddingH => {
-            p.rect(2.5, 3.5, 13.5, 12.5, 1.0);
-            p.fill_rect(5.0, 6.0, 11.0, 10.0, 0.0);
+            // Horizontal padding: bars down the padded left and right sides in their frame.
+            p.rect(2.5, 2.5, 13.5, 13.5, 1.0);
+            p.fill_rect(2.5, 2.5, 5.5, 13.5, 1.0);
+            p.fill_rect(10.5, 2.5, 13.5, 13.5, 1.0);
         }
         PaddingV => {
-            p.rect(3.5, 2.5, 12.5, 13.5, 1.0);
-            p.fill_rect(6.0, 5.0, 10.0, 11.0, 0.0);
+            // Vertical padding: bars across the padded top and bottom in their frame.
+            p.rect(2.5, 2.5, 13.5, 13.5, 1.0);
+            p.fill_rect(2.5, 2.5, 13.5, 5.5, 1.0);
+            p.fill_rect(2.5, 10.5, 13.5, 13.5, 1.0);
+        }
+        PaddingTop => {
+            p.rect(2.5, 2.5, 13.5, 13.5, 1.0);
+            p.fill_rect(2.5, 2.5, 13.5, 5.5, 1.0);
+        }
+        PaddingRight => {
+            p.rect(2.5, 2.5, 13.5, 13.5, 1.0);
+            p.fill_rect(10.5, 2.5, 13.5, 13.5, 1.0);
+        }
+        PaddingBottom => {
+            p.rect(2.5, 2.5, 13.5, 13.5, 1.0);
+            p.fill_rect(2.5, 10.5, 13.5, 13.5, 1.0);
+        }
+        PaddingLeft => {
+            p.rect(2.5, 2.5, 13.5, 13.5, 1.0);
+            p.fill_rect(2.5, 2.5, 5.5, 13.5, 1.0);
         }
         Online => {
             p.circle(8.0, 8.0, 5.5);
@@ -1069,6 +1137,49 @@ fn draw(p: &P, icon: Icon) {
             p.line(8.0, 6.0, 8.0, 9.5);
             p.dot(8.0, 11.5, 0.9);
         }
+        PenNib => {
+            // Drawn pointing down, then leant 35° to the left about the middle.
+            let (sin, cos) = (0.61f32, 0.79f32);
+            let at = |x: f32, y: f32| (8.0 + x * cos - y * sin, 8.0 + x * sin + y * cos);
+            let nib: Vec<(f32, f32)> = [(0.0, 6.5), (3.4, 1.0), (2.4, -2.5), (-2.4, -2.5), (-3.4, 1.0)].iter().map(|&(x, y)| at(x, y)).collect();
+            p.path(&nib, true);
+            let (a, b) = (at(0.0, 6.5), at(0.0, 2.0));
+            p.path(&[a, b], false);
+            let (dx, dy) = at(0.0, 0.6);
+            p.dot(dx, dy, 1.0);
+            let grip: Vec<(f32, f32)> = [(-2.4, -3.4), (2.4, -3.4), (2.4, -5.6), (-2.4, -5.6)].iter().map(|&(x, y)| at(x, y)).collect();
+            p.fill(&grip);
+        }
+        Board => {
+            p.poly(&[(2.5, 2.5), (13.5, 2.5), (13.5, 9.5), (9.5, 13.5), (2.5, 13.5)], true);
+            p.fill(&[(9.5, 13.5), (9.5, 9.5), (13.5, 9.5)]);
+            p.line(5.0, 6.5, 11.0, 6.5);
+            p.line(5.0, 9.5, 8.0, 9.5);
+        }
+        Marker => {
+            p.poly(&[(3.0, 13.0), (3.0, 10.5), (10.0, 3.5), (12.5, 6.0), (5.5, 13.0)], true);
+            p.line(8.5, 5.0, 11.0, 7.5);
+            p.fill(&[(2.0, 14.0), (2.0, 11.5), (4.5, 14.0)]);
+        }
+        Highlighter => {
+            p.poly(&[(4.0, 10.0), (10.5, 3.5), (13.5, 6.5), (7.0, 13.0)], true);
+            p.poly(&[(4.0, 10.0), (2.5, 12.5), (4.5, 12.5), (7.0, 13.0)], false);
+            p.fill_rect(1.0, 14.0, 15.0, 15.5, 0.0);
+        }
+        Connector => {
+            p.rect(1.5, 1.5, 6.5, 6.5, 1.0);
+            p.rect(9.5, 9.5, 14.5, 14.5, 1.0);
+            p.poly(&[(6.5, 4.0), (12.0, 4.0), (12.0, 9.0)], false);
+            p.head((12.0, 9.0), FRAC_PI_2, 2.4);
+        }
+        Shapes => {
+            p.rect(1.5, 5.5, 9.5, 13.5, 1.0);
+            p.circle(10.5, 5.5, 4.0);
+        }
+        Stamp => {
+            p.circle(8.0, 8.0, 6.0);
+            p.poly(&[(5.0, 8.3), (7.2, 10.5), (11.0, 6.0)], false);
+        }
         Logo => {
             // FigCraft's own mark: the curled tail of the chameleon on the app icon. One bold
             // stroke: a shaft along the bottom, then three half turns, each tighter than the last.
@@ -1113,6 +1224,46 @@ pub fn button(ui: &mut egui::Ui, icon: Icon, size: f32, active: bool, tooltip: &
     resp
 }
 
+/// The mark of a file of `kind` on tabs and file rows: a pen nib for design files, a sticky note
+/// for boards.
+pub fn file_mark(kind: figcraft_doc::FileKind) -> Icon {
+    match kind {
+        figcraft_doc::FileKind::Design => Icon::PenNib,
+        figcraft_doc::FileKind::Board => Icon::Board,
+    }
+}
+
+/// SVG path data outlines on a `size`-unit box, painted into `rect`: each part filled, or
+/// stroked `width` box units wide. Board shapes and stamp marks are drawn this way in the UI from
+/// the same outlines the canvas has.
+pub fn paint_outlines(painter: &Painter, rect: Rect, size: f64, parts: &[(&figcraft_geom::BezPath, bool)], color: Color32, width: f32) {
+    let s = rect.width().min(rect.height()) / size as f32;
+    let px = 1.0 / painter.ctx().pixels_per_point();
+    let o = rect.center() - Vec2::splat(size as f32 * s / 2.0);
+    let p = P { painter, o, s, px, stroke: Stroke::new((width * s).max(px), color), color };
+    for (path, filled) in parts {
+        let mut sub: Vec<(f32, f32)> = Vec::new();
+        let flush = |sub: &mut Vec<(f32, f32)>, closed: bool| {
+            if sub.len() >= 2 {
+                if *filled { p.fill(sub) } else { p.path(sub, closed) }
+            }
+            sub.clear();
+        };
+        let mut closed = false;
+        figcraft_geom::kurbo::flatten(path.iter(), 0.25, |el| match el {
+            figcraft_geom::kurbo::PathEl::MoveTo(q) => {
+                flush(&mut sub, closed);
+                closed = false;
+                sub.push((q.x as f32, q.y as f32));
+            }
+            figcraft_geom::kurbo::PathEl::LineTo(q) => sub.push((q.x as f32, q.y as f32)),
+            figcraft_geom::kurbo::PathEl::ClosePath => closed = true,
+            _ => {}
+        });
+        flush(&mut sub, closed);
+    }
+}
+
 /// Every icon at the sizes the UI uses, labelled: for reviewing the set (`ui.set {iconGallery}`).
 pub fn gallery(ctx: &egui::Context) {
     let t = crate::theme::Tokens::get(ctx);
@@ -1181,4 +1332,111 @@ mod tests {
         assert_eq!(triangulate(&rev).len(), (arrow.len() - 2) * 3);
         assert!(triangulate(&arrow[..2]).is_empty());
     }
+
+    /// The points painted inside `area`, relative to the top left of what's painted there (in
+    /// quarter points), so the same icon gives the same marks wherever its field puts it.
+    fn marks(shapes: &[egui::epaint::ClippedShape], area: Rect) -> Vec<(i32, i32)> {
+        fn walk(shape: &Shape, out: &mut Vec<Pos2>) {
+            match shape {
+                Shape::Vec(v) => v.iter().for_each(|s| walk(s, out)),
+                Shape::LineSegment { points, .. } => out.extend(points),
+                Shape::Path(p) => out.extend(&p.points),
+                Shape::Circle(c) => out.push(c.center),
+                _ => {}
+            }
+        }
+        let mut pts = Vec::new();
+        shapes.iter().for_each(|c| walk(&c.shape, &mut pts));
+        pts.retain(|p| area.contains(*p));
+        let x0 = pts.iter().map(|p| p.x).fold(f32::INFINITY, f32::min);
+        let y0 = pts.iter().map(|p| p.y).fold(f32::INFINITY, f32::min);
+        let mut out: Vec<(i32, i32)> = pts.into_iter().map(|p| (((p.x - x0) * 4.0).round() as i32, ((p.y - y0) * 4.0).round() as i32)).collect();
+        out.sort_unstable();
+        out.dedup();
+        out
+    }
+
+    /// The Design panel's Rotation field shows an icon of its own, not Corner radius's (#256).
+    #[test]
+    fn rotation_and_corner_radius_fields_show_different_icons() {
+        let mut s = figcraft_engine::Session::new();
+        let r = s.execute("shape.rectangle", &serde_json::json!({"x": 0, "y": 0, "width": 100, "height": 80})).unwrap()["id"].clone();
+        s.execute("select.set", &serde_json::json!({"ids": [r]})).unwrap();
+        let mut u = crate::layers_drag_tests::Ui::new(s);
+        u.frame(vec![]);
+        let shapes = u.frame_output(vec![]).shapes;
+        let lead = |name: &str| u.ctx.read_response(egui::Id::new(name).with("lead")).map(|r| r.rect).unwrap_or_else(|| panic!("{name} is shown"));
+        let (rotation, radius) = (marks(&shapes, lead("pos_rot")), marks(&shapes, lead("ap_rad")));
+        assert!(!rotation.is_empty() && !radius.is_empty(), "both draw an icon");
+        assert_ne!(rotation, radius);
+    }
+
+    /// The shapes `icon` paints in a 32-point box at the origin: two points per grid unit.
+    fn shapes_at_32(icon: Icon) -> Vec<Shape> {
+        let ctx = egui::Context::default();
+        let mut out =
+            ctx.run_ui(egui::RawInput::default(), |ui| paint(ui.painter(), Rect::from_min_size(Pos2::ZERO, Vec2::splat(32.0)), icon, Color32::WHITE));
+        out.textures_delta.clear();
+        out.shapes.into_iter().map(|c| c.shape).collect()
+    }
+
+    /// Frame and Text stay a grid unit inside the box, so their long hinted strokes don't
+    /// outweigh the outlines beside them in the toolbar (#737).
+    #[test]
+    fn frame_and_text_marks_are_inset() {
+        for icon in [Icon::Frame, Icon::Text] {
+            let pts: Vec<Pos2> = shapes_at_32(icon)
+                .iter()
+                .flat_map(|s| match s {
+                    Shape::LineSegment { points, .. } => points.to_vec(),
+                    other => panic!("{icon:?} draws straight strokes only: {other:?}"),
+                })
+                .collect();
+            assert!(!pts.is_empty());
+            for p in pts {
+                // Grid units 3..13, two points each.
+                assert!((6.0..=26.0).contains(&p.x) && (6.0..=26.0).contains(&p.y), "{icon:?} reaches {p:?}");
+            }
+        }
+    }
+
+    /// Slice is one knife (#739): an outlined blade and a solid handle that covers the middle of
+    /// the blade's base, so the two read as one mark rather than separate pieces.
+    #[test]
+    fn slice_is_one_connected_knife() {
+        let shapes = shapes_at_32(Icon::Slice);
+        let paths: Vec<_> = shapes
+            .iter()
+            .map(|s| match s {
+                Shape::Path(p) => p,
+                other => panic!("Slice draws paths only: {other:?}"),
+            })
+            .collect();
+        let blade = paths.iter().find(|p| p.closed && p.fill == Color32::TRANSPARENT).expect("an outlined blade");
+        let handle = paths.iter().find(|p| p.fill != Color32::TRANSPARENT).expect("a solid handle");
+        assert_eq!((paths.len(), blade.points.len()), (2, 3), "a blade and a handle, nothing else");
+        // The blade's base runs between its second and third points; the handle is convex.
+        let base = blade.points[1] + (blade.points[2] - blade.points[1]) / 2.0;
+        let h = &handle.points;
+        let side = |i: usize| {
+            let (a, b) = (h[i], h[(i + 1) % h.len()]);
+            (b - a).x * (base - a).y - (b - a).y * (base - a).x
+        };
+        let inside = (0..h.len()).all(|i| side(i) >= 0.0) || (0..h.len()).all(|i| side(i) <= 0.0);
+        assert!(inside, "the handle covers the blade's base at {base:?}");
+    }
+
+    /// Each corner's icon shows its own corner: no two of the four draw alike.
+    #[test]
+    fn corner_icons_differ() {
+        let drawn: Vec<String> = [Icon::CornerTopLeft, Icon::CornerTopRight, Icon::CornerBottomRight, Icon::CornerBottomLeft]
+            .iter()
+            .map(|&icon| format!("{:?}", shapes_at_32(icon)))
+            .collect();
+        for (i, a) in drawn.iter().enumerate() {
+            for b in &drawn[i + 1..] {
+                assert_ne!(a, b);
+            }
+        }
+    }
 }
diff --git a/crates/ui-egui/src/idle_tests.rs b/crates/ui-egui/src/idle_tests.rs
index b78c7474c..192073b32 100644
--- a/crates/ui-egui/src/idle_tests.rs
+++ b/crates/ui-egui/src/idle_tests.rs
@@ -26,6 +26,10 @@ pub(crate) struct Harness {
 
 impl Harness {
     pub(crate) fn new(s: Session) -> Self {
+        // The one system font scan bumps the layout generation, which makes the canvas render
+        // again: scanned here, before the first frame, rather than by whichever test happens to
+        // run first while this one waits for idle (#333).
+        figcraft_text::scan_system_fonts();
         Self { ctx: egui::Context::default(), app: FigApp::new(s, Box::new(NoServices)), time: 0.0 }
     }
 
@@ -332,9 +336,10 @@ fn cjk_names_are_looked_for_in_edits_not_on_every_pan() {
 }
 
 #[test]
-fn a_hidden_window_answers_requests_that_need_no_frame() {
-    // #269: minimised or covered, the window draws no frames, but the app's logic still runs: it
-    // answers edits, inspection and saves; what needs a frame waits for the window to show.
+fn a_hidden_window_answers_at_once() {
+    // #269, #720: minimised or covered, the window draws no frames, but the app's logic still runs:
+    // it answers edits, inspection, saves and the interface's state; what needs a frame (a capture
+    // of the window) is an error at once instead of waiting for the window to show.
     let dir = std::env::temp_dir().join(format!("figcraft-hidden-save-{}", std::process::id()));
     std::fs::create_dir_all(&dir).unwrap();
     let path = dir.join("hidden.figcraft");
@@ -350,6 +355,7 @@ fn a_hidden_window_answers_requests_that_need_no_frame() {
     };
     h.app.control_queue.push(request(1, "engine.execute", json!({"command": "file.save", "params": {"path": path.to_string_lossy()}})));
     h.app.control_queue.push(request(2, "ui.inspect", json!({})));
+    h.app.control_queue.push(request(3, "ui.screenshot", json!({"path": dir.join("shot.png").to_string_lossy()})));
     let mut hidden = RawInput::default();
     hidden.viewports.insert(ViewportId::ROOT, egui::ViewportInfo { minimized: Some(true), ..Default::default() });
     let app = &mut h.app;
@@ -357,10 +363,13 @@ fn a_hidden_window_answers_requests_that_need_no_frame() {
     let saved = rx.try_recv().unwrap();
     assert_eq!(saved.id, json!(1));
     assert!(saved.result.is_ok() && path.exists(), "saved while hidden: {:?}", saved.result);
-    assert!(rx.try_recv().is_err(), "the interface's state waits for a frame");
-    // Shown again: the next frame answers it.
-    h.frame(vec![]);
-    assert_eq!(rx.try_recv().unwrap().id, json!(2));
+    let inspected = rx.try_recv().unwrap();
+    assert_eq!(inspected.id, json!(2));
+    assert!(inspected.result.is_ok(), "the interface's state: {:?}", inspected.result);
+    let shot = rx.try_recv().unwrap();
+    assert_eq!(shot.id, json!(3));
+    assert!(shot.result.unwrap_err().contains("minimised or hidden"), "a capture needs the window on screen");
+    assert!(h.app.control_queue.is_empty(), "nothing waits for the window");
     let _ = std::fs::remove_dir_all(&dir);
 }
 
diff --git a/crates/ui-egui/src/ime_tests.rs b/crates/ui-egui/src/ime_tests.rs
new file mode 100644
index 000000000..a6db0cbdd
--- /dev/null
+++ b/crates/ui-egui/src/ime_tests.rs
@@ -0,0 +1,87 @@
+//! IME composition in a text layer, driven through egui headless with the events macOS sends for
+//! Pinyin ("nihao", then a candidate picked): the platform keeps the IME on every frame of the
+//! edit (an idle frame too) with the candidate window at the caret, the composition shows without
+//! entering the document, keys pressed while composing are the IME's, and the commit lands once.
+
+use egui::{Event, ImeEvent, Key, Modifiers, RawInput, Rect};
+use figcraft_doc::{NodeId, NodeKind};
+use figcraft_engine::Session;
+use serde_json::json;
+
+use crate::layers_drag_tests::Ui;
+
+fn key(key: Key, pressed: bool) -> Event {
+    Event::Key { key, physical_key: None, pressed, repeat: false, modifiers: Modifiers::NONE }
+}
+
+fn preedit(text: &str) -> Event {
+    let n = text.chars().count();
+    Event::Ime(ImeEvent::Preedit { text: text.into(), active_range_chars: (n > 0).then_some(n..n) })
+}
+
+#[expect(deprecated, reason = "egui still delivers these, and the editor must ignore them")]
+fn enabled_disabled() -> (Event, Event) {
+    (Event::Ime(ImeEvent::Enabled), Event::Ime(ImeEvent::Disabled))
+}
+
+fn text(u: &Ui, id: NodeId) -> String {
+    match &u.app.session.doc().unwrap().node(id).unwrap().kind {
+        NodeKind::Text(t) => t.characters.clone(),
+        _ => panic!("not text"),
+    }
+}
+
+/// One frame; the IME output it leaves for the platform (`None` turns the IME off).
+fn ime(u: &mut Ui, events: Vec<Event>) -> Rect {
+    let ime = u.frame_raw(RawInput { events, ..Default::default() }).platform_output.ime.expect("the IME stays on while editing");
+    assert_eq!(ime.rect, ime.cursor_rect, "the desktop places candidates by `rect`: the caret");
+    ime.cursor_rect
+}
+
+fn composing(u: &Ui) -> Option<String> {
+    u.app.session.ds().unwrap().text_edit.as_ref().expect("still editing").preedit.as_ref().map(|p| p.text.clone())
+}
+
+#[test]
+fn pinyin_composes_inline_and_commits_once_with_the_ime_on_every_frame() {
+    // The text is measured with a font: without craft-fonts a system one, scanned here rather than
+    // by whichever test happens to run first (#333).
+    figcraft_text::scan_system_fonts();
+    let mut s = Session::new();
+    let t = NodeId(s.execute("text.create", &json!({"text": "Hi", "x": 40, "y": 40})).unwrap()["id"].as_u64().unwrap());
+    // On a machine without any font nothing lays out and every caret sits at the start.
+    let fonts = figcraft_text::layout_node(s.doc().unwrap().node(t).unwrap()).is_some_and(|(l, _)| !l.glyphs.is_empty());
+    let mut u = Ui::new(s);
+    figcraft_engine::textedit::begin(&mut u.app.session, t, Some(2), false).unwrap();
+    // An idle frame (the caret blinking) keeps the IME on, or macOS drops the composition.
+    let caret = ime(&mut u, vec![]);
+    let ds = u.app.session.ds().unwrap();
+    let b = ds.doc.world_bounds(t).unwrap();
+    let layer = Rect::from_two_pos(u.app.to_screen(b.x0, b.y0), u.app.to_screen(b.x1, b.y1)).expand(1.0);
+    assert!(layer.contains(caret.center()), "candidates open at the caret ({caret:?} in {layer:?})");
+
+    let (enabled, disabled) = enabled_disabled();
+    ime(&mut u, vec![enabled, preedit("n")]);
+    ime(&mut u, vec![]);
+    let mid = ime(&mut u, vec![preedit("ni")]);
+    assert!(!fonts || mid.min.x > caret.min.x, "the IME cursor follows the composition");
+    // A key the platform leaks while composing (Backspace) belongs to the IME, not the text.
+    ime(&mut u, vec![key(Key::Backspace, true), preedit("nih"), key(Key::Backspace, false)]);
+    ime(&mut u, vec![preedit("nihao")]);
+    assert_eq!(composing(&u).as_deref(), Some("nihao"));
+    assert_eq!(text(&u, t), "Hi", "the composition isn't in the document yet");
+
+    // Enter confirms the candidate: no newline, editing goes on.
+    let after = ime(&mut u, vec![key(Key::Enter, true), preedit(""), Event::Ime(ImeEvent::Commit("你好".into())), disabled, key(Key::Enter, false)]);
+    assert_eq!(text(&u, t), "Hi你好");
+    assert_eq!(composing(&u), None);
+    let te = u.app.session.ds().unwrap().text_edit.clone().unwrap();
+    assert_eq!((te.caret, te.anchor), (4, 4));
+    assert!(!fonts || after.min.x > caret.min.x, "the caret moved past the committed text");
+    ime(&mut u, vec![]);
+    assert_eq!(text(&u, t), "Hi你好", "committed once");
+
+    // Keys are the editor's again once the composition is over.
+    ime(&mut u, vec![key(Key::Enter, true), key(Key::Enter, false), Event::Text("!".into())]);
+    assert_eq!(text(&u, t), "Hi你好\n!");
+}
diff --git a/crates/ui-egui/src/import_report.rs b/crates/ui-egui/src/import_report.rs
new file mode 100644
index 000000000..5b5247273
--- /dev/null
+++ b/crates/ui-egui/src/import_report.rs
@@ -0,0 +1,179 @@
+//! The import report: what a successful `.fig`, REST JSON or SVG import left out or changed, shown
+//! in a dialog window after the file opens, so the notes don't vanish with a toast.
+
+use egui::RichText;
+use serde_json::{Value, json};
+
+use crate::FigApp;
+use crate::i18n::{tr, trn, try_tr};
+use crate::theme::{Tokens, regular};
+
+/// A report stays small even when a damaged input produces many or very long notes.
+pub const MAX_NOTES: usize = 500;
+pub const MAX_NOTE_CHARS: usize = 2_000;
+
+#[derive(Clone, Debug)]
+pub struct Report {
+    pub name: String,
+    pub pages: Option<u64>,
+    pub layers: Option<u64>,
+    pub images: Option<u64>,
+    /// The pages of an imported file were added to the open document.
+    pub appended: bool,
+    /// An SVG was placed on the current page of the open document.
+    pub placed: bool,
+    /// The document the report belongs to: it goes when that document closes.
+    pub uid: u64,
+    pub notes: Vec<String>,
+    /// `notes` as the window shows them, in the UI language (worked out once, not every frame).
+    pub shown: Vec<String>,
+    pub note_count: usize,
+}
+
+impl Report {
+    /// Only successful `file.open` and `file.import` results with import `warnings` create a report;
+    /// a native file's `repairs` are shown by the engine's own message, and an SVG opened without
+    /// notes has nothing to report. `params` are the command's, for the file's name.
+    pub fn from_result(command: &str, params: &Value, result: &Value) -> Option<Self> {
+        if !matches!(command, "file.open" | "file.openRecent" | "file.import") {
+            return None;
+        }
+        let warnings = result.get("warnings").and_then(Value::as_array)?;
+        let file_name = params.get("path").and_then(Value::as_str).and_then(|p| std::path::Path::new(p).file_name()).and_then(|n| n.to_str());
+        if command != "file.import" && warnings.is_empty() && file_name.is_some_and(|n| n.to_ascii_lowercase().ends_with(".svg")) {
+            return None;
+        }
+        // `file.import` of an SVG places a frame on the current page (no `pages`): its notes
+        // are reported, but no pages were appended.
+        let appended = command == "file.import" && result.get("pages").is_some();
+        if command == "file.import" && !appended && warnings.is_empty() {
+            return None;
+        }
+        let summary = result.get("summary");
+        let count = |key: &str| summary.and_then(|s| s.get(key)).and_then(Value::as_u64);
+        let name = summary
+            .and_then(|s| s.get("name"))
+            .and_then(Value::as_str)
+            .or(file_name)
+            .or_else(|| params.get("name").and_then(Value::as_str))
+            .unwrap_or(tr("Imported document"));
+        let mut report = Self {
+            name: name.chars().take(512).collect(),
+            pages: count("pages"),
+            layers: count("layers"),
+            images: count("images"),
+            appended,
+            placed: command == "file.import" && !appended,
+            uid: 0,
+            notes: Vec::new(),
+            shown: Vec::new(),
+            note_count: 0,
+        };
+        for note in warnings.iter().filter_map(Value::as_str) {
+            report.add_note(note);
+        }
+        Some(report)
+    }
+
+    fn add_note(&mut self, note: &str) {
+        self.note_count = self.note_count.saturating_add(1);
+        if self.notes.len() < MAX_NOTES {
+            let mut text: String = note.chars().take(MAX_NOTE_CHARS).collect();
+            if note.chars().nth(MAX_NOTE_CHARS).is_some() {
+                text.push('…');
+            }
+            self.shown.push(note_text(&text));
+            self.notes.push(text);
+        }
+    }
+
+    pub fn inspect(&self) -> Value {
+        json!({"name": self.name, "pages": self.pages, "layers": self.layers, "images": self.images,
+            "appended": self.appended, "placed": self.placed, "warnings": self.notes, "warningCount": self.note_count})
+    }
+}
+
+/// `note` in the UI language when the catalog has it (the importers' fixed notes: `.fig` imports
+/// name "the file" where REST imports name the JSON they read); a repeat count (` (×N)`) is kept.
+/// The stored notes are lower-case fragments; a known note is shown as a sentence, so its first
+/// letter is capitalised here. Other notes (SVG's, say) are shown as they are.
+pub(crate) fn note_text(note: &str) -> String {
+    let translated = |base: &str| {
+        let Some(text) = try_tr(base) else { return base.to_owned() };
+        let mut chars = text.chars();
+        chars.next().map_or_else(String::new, |first| first.to_uppercase().chain(chars).collect())
+    };
+    match note.rsplit_once(" (×") {
+        Some((base, count)) if count.strip_suffix(')').is_some_and(|n| !n.is_empty() && n.bytes().all(|b| b.is_ascii_digit())) => {
+            format!("{} (×{count}", translated(base))
+        }
+        _ => translated(note),
+    }
+}
+
+/// Show the report for a file the user opened or imported (menus, drops, pastes, recents, the
+/// system's open event); commands from the control channel, MCP or scripts never call this.
+pub fn capture(app: &mut FigApp, command: &str, params: &Value, result: &Value) {
+    if let Some(mut report) = Report::from_result(command, params, result) {
+        report.uid = app.session.ds().map_or(0, |d| d.uid);
+        app.ui.import_report = Some(report);
+    }
+}
+
+pub fn show(app: &mut FigApp, ctx: &egui::Context) {
+    // The report goes with its document.
+    if app.ui.import_report.as_ref().is_some_and(|r| !app.session.docs.iter().any(|d| d.uid == r.uid)) {
+        app.ui.import_report = None;
+    }
+    let Some(report) = &app.ui.import_report else { return };
+    let t = Tokens::get(ctx);
+    let mut open = true;
+    let mut close_clicked = false;
+    crate::dialogs::window(tr("Import report"), ctx).open(&mut open).show(ctx, |ui| {
+        ui.set_width(420.0);
+        ui.label(RichText::new(&report.name).strong());
+        ui.label(if report.appended {
+            tr("Pages added to the document")
+        } else if report.placed {
+            tr("Placed on the current page")
+        } else {
+            tr("Opened as a new document")
+        });
+        let counts: Vec<String> = [(tr("Pages"), report.pages), (tr("Layers"), report.layers), (tr("Images"), report.images)]
+            .into_iter()
+            .filter_map(|(label, count)| count.map(|n| format!("{label}: {n}")))
+            .collect();
+        if !counts.is_empty() {
+            ui.label(counts.join(" · "));
+        }
+        ui.add_space(8.0);
+        if report.notes.is_empty() {
+            ui.label(tr("No compatibility warnings reported"));
+        } else {
+            ui.label(RichText::new(tr("Compatibility notes")).strong());
+            ui.label(
+                RichText::new(tr(
+                    "FigCraft doesn't support every feature of these files yet. The notes list what was left out or changed in the imported copy; the original file is unchanged.",
+                ))
+                .color(t.text_secondary)
+                .font(regular(11.0)),
+            );
+            ui.add_space(4.0);
+            egui::ScrollArea::vertical().id_salt("import_report_notes").max_height(260.0).show(ui, |ui| {
+                for note in &report.shown {
+                    ui.label(note);
+                    ui.add_space(4.0);
+                }
+            });
+        }
+        let omitted = report.note_count.saturating_sub(report.notes.len());
+        if omitted > 0 {
+            ui.label(trn("{n} more notes omitted from this report", omitted, &[]));
+        }
+        ui.add_space(12.0);
+        close_clicked = crate::widgets::button(ui, tr("Close"), true, true).clicked();
+    });
+    if !open || close_clicked {
+        app.ui.import_report = None;
+    }
+}
diff --git a/crates/ui-egui/src/import_report_tests.rs b/crates/ui-egui/src/import_report_tests.rs
new file mode 100644
index 000000000..8c10c7f3e
--- /dev/null
+++ b/crates/ui-egui/src/import_report_tests.rs
@@ -0,0 +1,204 @@
+use figcraft_engine::Session;
+use serde_json::json;
+
+use crate::import_report::{MAX_NOTE_CHARS, MAX_NOTES, Report, note_text};
+use crate::{FigApp, NoServices};
+
+#[test]
+fn import_results_with_warnings_become_reports_with_counts() {
+    let result =
+        json!({"warnings": ["layers without a type were skipped"], "summary": {"name": "Synthetic design", "pages": 2, "layers": 12, "images": 3}});
+    let report = Report::from_result("file.import", &json!({}), &result).unwrap();
+    assert_eq!(report.name, "Synthetic design");
+    assert_eq!((report.pages, report.layers, report.images), (Some(2), Some(12), Some(3)));
+    assert_eq!(report.notes, ["layers without a type were skipped"]);
+    assert_eq!(report.note_count, 1);
+}
+
+#[test]
+fn only_import_commands_with_warnings_create_reports() {
+    // A warning-free `.fig` or REST open still has a summary to show.
+    let report = Report::from_result("file.open", &json!({}), &json!({"warnings": [], "summary": {"name": "Local", "pages": 1}})).unwrap();
+    assert!(!report.appended && report.notes.is_empty());
+    // A native file's repairs have their own message; an SVG without notes has no `warnings`.
+    assert!(Report::from_result("file.open", &json!({}), &json!({"repairs": ["Repaired parent"]})).is_none());
+    assert!(Report::from_result("file.open", &json!({}), &json!({"index": 0})).is_none());
+    assert!(Report::from_result("file.export", &json!({}), &json!({"warnings": ["Export warning"]})).is_none());
+    assert!(Report::from_result("shape.rectangle", &json!({}), &json!({})).is_none());
+    // File ▸ Open recent opens by path and reports like File ▸ Open.
+    let recent = json!({"warnings": ["layers without a type were skipped"], "summary": {"name": "Recent", "pages": 1}});
+    assert!(Report::from_result("file.openRecent", &json!({"path": "Recent.json"}), &recent).is_some());
+    assert!(Report::from_result("file.openRecent", &json!({"path": "Clean.svg"}), &json!({"warnings": []})).is_none());
+}
+
+#[test]
+fn svg_placements_are_not_reported_as_appended_pages() {
+    assert!(Report::from_result("file.import", &json!({}), &json!({"id": 7})).is_none());
+    let report = Report::from_result("file.import", &json!({}), &json!({"id": 7, "warnings": ["Filter skipped"]})).unwrap();
+    assert!(!report.appended);
+    assert!(Report::from_result("file.import", &json!({}), &json!({"pages": [1], "summary": {"pages": 1}, "warnings": []})).unwrap().appended);
+}
+
+#[test]
+fn report_retention_is_bounded_and_truncates_only_at_character_boundaries() {
+    let long_note = "🦎".repeat(MAX_NOTE_CHARS + 20);
+    let notes: Vec<_> = std::iter::repeat_n(long_note, MAX_NOTES + 37).collect();
+    let report = Report::from_result("file.open", &json!({}), &json!({"warnings": notes})).unwrap();
+    assert_eq!(report.note_count, MAX_NOTES + 37);
+    assert_eq!(report.notes.len(), MAX_NOTES);
+    assert!(report.notes.iter().all(|note| note.chars().count() == MAX_NOTE_CHARS + 1 && note.ends_with('…')));
+}
+
+#[test]
+fn note_text_keeps_the_repeat_suffix_and_unknown_notes() {
+    let base = "instances of components that aren't in the file were imported as frames";
+    let repeated = note_text(&format!("{base} (×122)"));
+    assert_eq!(repeated, "Instances of components that aren't in the file were imported as frames (×122)");
+    assert_eq!(note_text("some unknown note"), "some unknown note");
+    assert_eq!(note_text("weird (×x)"), "weird (×x)");
+    assert_eq!(note_text("weird (×12) tail"), "weird (×12) tail");
+}
+
+#[test]
+fn vector_style_notes_are_known_import_notes() {
+    for note in [
+        "some vector points refer to point settings missing from the file; they use the layer's joins and plain corners",
+        "vector points with unknown stroke joins use the layer join",
+        "point stroke joins were preserved; dashed or variable-width strokes render with the layer join",
+    ] {
+        let shown = note_text(note);
+        assert!(shown.chars().next().is_some_and(char::is_uppercase), "{shown}");
+        assert_eq!(shown[shown.chars().next().unwrap().len_utf8()..], note[note.chars().next().unwrap().len_utf8()..]);
+    }
+}
+
+#[test]
+fn opening_a_rest_json_file_reports_what_was_skipped() {
+    let path = std::env::temp_dir().join(format!("figcraft-import-report-{}.json", std::process::id()));
+    let file = json!({"document": {"id": "0:0", "name": "Synthetic", "type": "DOCUMENT", "children": [
+        {"id": "0:1", "name": "Page 1", "type": "CANVAS", "children": [
+            {"id": "1:1", "name": "Card", "type": "FRAME", "size": {"x": 200, "y": 100}, "relativeTransform": [[1, 0, 10], [0, 1, 20]],
+                "children": [{"id": "1:2", "name": "No type"}]}]}]}});
+    std::fs::write(&path, file.to_string()).unwrap();
+    let mut app = FigApp::new(Session::new(), Box::new(NoServices));
+    // A programmatic open (control channel, MCP) never opens the window.
+    assert!(app.run("file.open", json!({"path": path.to_string_lossy()})).is_some());
+    assert!(app.ui.import_report.is_none());
+    let opened = app.run_user("file.open", json!({"path": path.to_string_lossy()}));
+    std::fs::remove_file(&path).unwrap();
+    assert!(opened.is_some());
+    let report = app.ui.import_report.as_ref().expect("a report for the REST import");
+    assert!(!report.appended);
+    assert_eq!(report.pages, Some(1));
+    assert!(report.layers.is_some_and(|n| n >= 1));
+    assert!(report.notes.iter().any(|n| n == "layers without a type were skipped"), "{:?}", report.notes);
+    assert_eq!(app.inspect()["importReport"]["warningCount"], report.note_count);
+}
+
+#[test]
+fn escape_closes_the_import_report_like_other_simple_dialogs() {
+    let mut u = crate::layers_drag_tests::Ui::new(Session::new());
+    let mut report = Report::from_result("file.open", &json!({}), &json!({"warnings": ["Synthetic note"], "summary": {"name": "Synthetic design"}}));
+    report.as_mut().unwrap().uid = u.app.session.ds().unwrap().uid;
+    u.app.ui.import_report = report;
+    u.frame(vec![]);
+    let escape =
+        vec![egui::Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: egui::Modifiers::NONE }];
+    u.frame(escape);
+    assert!(u.app.ui.import_report.is_none(), "Escape closes the report");
+}
+
+pub(crate) fn shown_texts(shapes: Vec<egui::epaint::ClippedShape>) -> Vec<String> {
+    fn walk(shape: &egui::Shape, out: &mut Vec<String>) {
+        match shape {
+            egui::Shape::Text(t) => out.push(t.galley.text().to_string()),
+            egui::Shape::Vec(v) => v.iter().for_each(|s| walk(s, out)),
+            _ => {}
+        }
+    }
+    let mut out = Vec::new();
+    shapes.iter().for_each(|c| walk(&c.shape, &mut out));
+    out
+}
+
+#[test]
+fn a_clean_svg_open_has_no_report_and_a_placed_svg_says_where_it_went() {
+    let svg_open = Report::from_result("file.open", &json!({"path": "icons/Logo.SVG"}), &json!({"warnings": []}));
+    assert!(svg_open.is_none(), "a clean SVG opened with file.open has nothing to report");
+    let noted = Report::from_result("file.open", &json!({"path": "Logo.svg"}), &json!({"warnings": ["Filter skipped"]})).unwrap();
+    assert_eq!(noted.name, "Logo.svg");
+
+    let placed = Report::from_result("file.import", &json!({"path": "dir/Logo.svg"}), &json!({"id": 7, "warnings": ["Filter skipped"]})).unwrap();
+    assert!(placed.placed && !placed.appended);
+    assert_eq!(placed.name, "Logo.svg");
+    let mut u = crate::layers_drag_tests::Ui::new(Session::new());
+    let mut placed = placed;
+    placed.uid = u.app.session.ds().unwrap().uid;
+    u.app.ui.import_report = Some(placed);
+    let texts = shown_texts({
+        u.frame(vec![]);
+        u.frame_output(vec![]).shapes
+    });
+    assert!(texts.iter().any(|t| t == "Placed on the current page"), "{texts:?}");
+    assert!(!texts.iter().any(|t| t == "Opened as a new document"), "{texts:?}");
+    assert!(texts.iter().any(|t| t == "Logo.svg"), "{texts:?}");
+}
+
+#[test]
+fn the_report_goes_when_its_document_closes_and_counts_omitted_notes_in_the_singular() {
+    let mut u = crate::layers_drag_tests::Ui::new(Session::new());
+    let mut report = Report::from_result("file.open", &json!({}), &json!({"warnings": ["One note"], "summary": {"name": "Synthetic"}})).unwrap();
+    report.uid = u.app.session.ds().unwrap().uid;
+    report.note_count = 2;
+    u.app.ui.import_report = Some(report);
+    let texts = shown_texts({
+        u.frame(vec![]);
+        u.frame_output(vec![]).shapes
+    });
+    assert!(texts.iter().any(|t| t == "1 more note omitted from this report"), "{texts:?}");
+
+    u.app.session.execute("file.new", &json!({"name": "Other"})).unwrap();
+    u.frame(vec![]);
+    assert!(u.app.ui.import_report.is_some(), "another tab was added; the report's document is still open");
+    u.app.session.execute("file.close", &json!({"index": 0, "force": true})).unwrap();
+    u.frame(vec![]);
+    assert!(u.app.ui.import_report.is_none(), "the report left with its document");
+}
+
+#[test]
+fn a_dropped_file_shows_its_report_once_it_opens() {
+    let path = std::env::temp_dir().join(format!("figcraft-import-report-drop-{}.json", std::process::id()));
+    let file = json!({"document": {"id": "0:0", "name": "Dropped", "type": "DOCUMENT", "children": [
+        {"id": "0:1", "name": "Page 1", "type": "CANVAS", "children": [{"id": "1:1", "name": "No type"}]}]}});
+    std::fs::write(&path, file.to_string()).unwrap();
+    let mut u = crate::layers_drag_tests::Ui::new(Session::new());
+    u.app.ui.pending_opens.push(crate::pending_open::PendingOpen {
+        label: "Dropped.json".into(),
+        params: json!({"path": path.to_string_lossy()}),
+        command: "file.open",
+        target: None,
+        read: None,
+    });
+    for _ in 0..6 {
+        u.frame(vec![]);
+    }
+    std::fs::remove_file(&path).unwrap();
+    let report = u.app.ui.import_report.as_ref().expect("the dropped file's report");
+    assert_eq!(report.uid, u.app.session.ds().unwrap().uid);
+}
+
+#[test]
+fn a_file_opened_from_base64_data_has_a_summary_too() {
+    use base64::Engine as _;
+    let file = json!({"document": {"id": "0:0", "name": "From data", "type": "DOCUMENT", "children": [
+        {"id": "0:1", "name": "Page 1", "type": "CANVAS", "children": [{"id": "1:1", "name": "No type"}]}]}});
+    let data = base64::engine::general_purpose::STANDARD.encode(file.to_string());
+    let mut app = FigApp::new(Session::new(), Box::new(NoServices));
+    let opened = app.run_user("file.open", json!({"data": data, "name": "Dropped.json"})).unwrap();
+    assert_eq!(opened["summary"]["pages"], 1);
+    let report = app.ui.import_report.as_ref().expect("a report for the REST import");
+    assert_eq!(report.pages, Some(1));
+    assert!(report.notes.iter().any(|n| n == "layers without a type were skipped"), "{:?}", report.notes);
+    // Shown as a sentence, worked out once when the report opens.
+    assert!(report.shown.iter().any(|n| n == "Layers without a type were skipped"), "{:?}", report.shown);
+}
diff --git a/crates/ui-egui/src/layers.rs b/crates/ui-egui/src/layers.rs
index 8b6147628..f172b309e 100644
--- a/crates/ui-egui/src/layers.rs
+++ b/crates/ui-egui/src/layers.rs
@@ -148,7 +148,8 @@ pub fn left_panel(app: &mut FigApp, ui: &mut Ui) {
     } else {
         let name = app.session.doc().map(|d| d.name.clone()).unwrap_or_default();
         let nr = Rect::from_min_max(pos2(head.min.x + 14.0, head.min.y + 14.0), pos2(head.max.x - 48.0, head.min.y + 34.0));
-        if let Some(new) = crate::widgets::text_field_inline(ui, Id::new("filename"), &name, nr, semibold(13.0)) {
+        let start = std::mem::take(&mut app.ui.rename_file);
+        if let (Some(new), _) = crate::widgets::rename_field(ui, Id::new("filename"), &name, nr, semibold(13.0), start) {
             app.run("file.rename", json!({"name": new}));
         }
         ui.painter().text(pos2(head.min.x + 16.0, head.min.y + 46.0), Align2::LEFT_CENTER, tr("Drafts"), regular(11.0), t.text_secondary);
@@ -183,13 +184,18 @@ fn pages(app: &mut FigApp, ui: &mut Ui) {
         app.ui.pages_open = !app.ui.pages_open;
     }
     let sr = Rect::from_center_size(pos2(hr.max.x - 50.0, hr.center().y), vec2(24.0, 24.0));
-    let sresp = ui.interact(sr, ui.id().with("lsearch"), Sense::click()).tip(crate::shortcuts::tip(tr("Find"), "edit.findReplace"));
-    if sresp.hovered() {
+    let sresp = ui.interact(sr, ui.id().with("lsearch"), Sense::click()).tip(tr("Search pages"));
+    if sresp.hovered() || app.ui.page_search {
         ui.painter().rect_filled(sr, CornerRadius::same(5), t.hover);
     }
     icons::paint(ui.painter(), sr.shrink(5.0), Icon::Search, t.icon);
+    let search_id = Id::new("page_search_field");
     if sresp.clicked() {
-        app.ui.find = Some((String::new(), String::new()));
+        app.ui.page_search = !app.ui.page_search;
+        app.ui.page_filter.clear();
+        if app.ui.page_search {
+            app.ui.pages_open = true;
+        }
     }
     let ar = Rect::from_center_size(pos2(hr.max.x - 22.0, hr.center().y), vec2(24.0, 24.0));
     let aresp = ui.interact(ar, ui.id().with("addpage"), Sense::click()).tip(tr("Add new page"));
@@ -198,15 +204,22 @@ fn pages(app: &mut FigApp, ui: &mut Ui) {
     }
     icons::paint(ui.painter(), ar.shrink(5.0), Icon::Plus, t.icon);
     if aresp.clicked() {
+        app.ui.pages_focus = app.session.ds().ok().map(|d| d.uid);
         app.run("page.add", json!({}));
     }
     if !app.ui.pages_open {
         return;
     }
+    if app.ui.page_search {
+        search_field(ui, &t, w, search_id, tr("Search pages"), &mut app.ui.page_filter, &mut app.ui.page_search, sresp.clicked());
+    }
     let Ok(ds) = app.session.ds() else { return };
     let pages: Vec<(NodeId, String, bool)> =
         ds.doc.pages.iter().filter_map(|p| ds.doc.node(*p).map(|n| (*p, n.name.clone(), ds.doc.is_divider(*p)))).collect();
+    let filter = app.ui.page_filter.trim().to_lowercase();
+    let filtering = !filter.is_empty();
     let cur = ds.page;
+    let uid = ds.uid;
     let sel = ds.selection.clone();
     let mut select = None;
     let mut rename_done: Option<(NodeId, String)> = None;
@@ -216,12 +229,27 @@ fn pages(app: &mut FigApp, ui: &mut Ui) {
     let mut move_to: Option<(NodeId, String)> = None;
     // Pages are dragged up and down the list to reorder them.
     let mut reorder = crate::list_drag::ListDrag::in_order(ui, "pages");
+    let page_key = (uid, cur);
+    let scroll_to_cur = app.ui.pages_seen_page != Some(page_key);
+    let mut current_row_rendered = false;
     // A long list scrolls in its own area, so the layers keep their room below it.
-    let max_h = (ui.available_height() * 0.4).max(3.0 * ROW);
+    let max_h = pages_list_height(app.ui.pages_height, ui.available_height());
     let mut moved = egui::ScrollArea::vertical().id_salt("pages_list").max_height(max_h).show(ui, |ui| {
         for (k, (id, name, divider)) in pages.iter().cloned().enumerate() {
-            let (r, resp) = ui.allocate_exact_size(vec2(w, 32.0), Sense::click_and_drag());
-            reorder.row_by(&resp, k, r, || if divider { tr("Divider").to_string() } else { name.clone() });
+            if filtering && (divider || !name.to_lowercase().contains(&filter)) {
+                continue;
+            }
+            let sense = if filtering { Sense::click() } else { Sense::click_and_drag() };
+            let (r, resp) = ui.allocate_exact_size(vec2(w, 32.0), sense);
+            if id == cur {
+                current_row_rendered = true;
+                if scroll_to_cur {
+                    ui.scroll_to_rect(r, None);
+                }
+            }
+            if !filtering {
+                reorder.row_by(&resp, k, r, || if divider { tr("Divider").to_string() } else { name.clone() });
+            }
             a11y::list_item(&resp, if divider { tr("Divider") } else { &name }, id == cur);
             let r = r.shrink2(vec2(8.0, 0.0));
             a11y::ring_around(ui, r, &resp);
@@ -256,6 +284,8 @@ fn pages(app: &mut FigApp, ui: &mut Ui) {
             }
             if resp.clicked() && !divider {
                 select = Some(id);
+                app.ui.pages_focus = Some(uid);
+                app.ui.layers_focus = false;
             }
             if resp.double_clicked() {
                 app.ui.rename_page = Some((id, name.clone()));
@@ -273,13 +303,16 @@ fn pages(app: &mut FigApp, ui: &mut Ui) {
                     ui.close();
                 }
                 if ui.button(tr("Delete page")).clicked() {
-                    app.run("page.delete", json!({"id": id}));
+                    delete_page(app, id);
                     ui.close();
                 }
             });
         }
         reorder.finish(ui)
     });
+    if current_row_rendered {
+        app.ui.pages_seen_page = Some(page_key);
+    }
     // A drop outside the list's visible area (and the row gap at its edges) isn't on a page row,
     // even one scrolled out of view.
     if !ui.input(|i| i.pointer.latest_pos()).is_some_and(|p| moved.inner_rect.expand2(vec2(0.0, 3.0)).contains(p)) {
@@ -306,7 +339,69 @@ fn pages(app: &mut FigApp, ui: &mut Ui) {
     {
         app.run("page.select", json!({"id": p}));
     }
-    crate::widgets::separator(ui);
+    // `inner_rect` is the room the list was given; a short list shrinks to its rows.
+    pages_edge(app, ui, moved.inner_rect.height().min(moved.content_size.y));
+}
+
+/// The Pages list has the keyboard: a page row (or the add-page button) of the open file was
+/// clicked last, and the list is still on screen.
+pub(crate) fn pages_have_keyboard(app: &FigApp) -> bool {
+    let Ok(ds) = app.session.ds() else { return false };
+    app.ui.pages_focus == Some(ds.uid) && app.ui.pages_open && !app.ui.left_collapsed && !ds.view.ui_hidden && app.ui.left_tab == LeftTab::File
+}
+
+/// Delete `page` (no confirmation: Undo brings it back) and say so.
+pub(crate) fn delete_page(app: &mut FigApp, page: NodeId) {
+    if app.run("page.delete", json!({"id": page})).is_some() {
+        app.toast(tr("Page deleted"));
+    }
+}
+
+/// The pages list's height in a panel with `avail` below the Pages header: the height asked for
+/// (by default 40% of it), at least three rows, and leaving the layers their header and three rows.
+pub(crate) fn pages_list_height(asked: Option<f32>, avail: f32) -> f32 {
+    let least = 3.0 * ROW;
+    let most = (avail - 40.0 - 3.0 * ROW).max(least);
+    asked.filter(|h| h.is_finite()).unwrap_or(avail * 0.4).clamp(least, most)
+}
+
+/// The line between the pages and the layers: dragging it sizes the pages list (`shown`: its
+/// height now), a double-click puts back the default. The main window keeps it in the preferences.
+fn pages_edge(app: &mut FigApp, ui: &mut Ui, shown: f32) {
+    let t = Tokens::get(ui.ctx());
+    let w = ui.available_width();
+    let (line, _) = ui.allocate_exact_size(vec2(w, 1.0), Sense::hover());
+    let grab = ui.style().interaction.resize_grab_radius_side;
+    let id = Id::new("pages_edge");
+    let resp = ui.interact(line.expand2(vec2(0.0, grab)), id, Sense::click_and_drag());
+    let active = resp.hovered() || resp.dragged();
+    if active {
+        ui.ctx().set_cursor_icon(egui::CursorIcon::ResizeVertical);
+    }
+    let (width, colour) = if active { (2.0, ACCENT) } else { (1.0, t.border) };
+    ui.painter().line_segment([line.left_center(), line.right_center()], Stroke::new(width, colour));
+    let asked = if resp.double_clicked() {
+        Some(None)
+    } else if resp.dragged() {
+        // The edge stays under the pointer where it was grabbed.
+        if resp.drag_started() {
+            ui.data_mut(|d| d.insert_temp(id, shown));
+        }
+        let from: f32 = ui.data(|d| d.get_temp(id)).unwrap_or(shown);
+        let moved = ui.input(|i| Some(i.pointer.latest_pos()?.y - i.pointer.press_origin()?.y)).unwrap_or(0.0);
+        Some(Some(from + moved))
+    } else {
+        None
+    };
+    if let Some(h) = asked
+        && h != app.ui.pages_height
+    {
+        app.ui.pages_height = h;
+        if app.windows.current == 0 {
+            app.session.prefs.pages_height = h;
+            app.panels_unsaved = true;
+        }
+    }
 }
 
 /// A page rename just asked for by a double click: its field takes the focus when drawn (temp data).
@@ -574,8 +669,10 @@ fn set_expanded_deep(doc: &Document, id: NodeId, open: bool, expanded: &mut BTre
     }
 }
 
-/// The search row under the Layers header (live filter; Escape closes it).
-fn search_field(app: &mut FigApp, ui: &mut Ui, t: &Tokens, w: f32, id: Id) {
+/// The search row under the Pages or Layers header: a live filter `text`, taking the keyboard when
+/// `focus` (just opened). Escape in it clears it and closes the row (`open`), and goes no further
+/// (the canvas keeps its selection).
+fn search_field(ui: &mut Ui, t: &Tokens, w: f32, id: Id, hint: &str, text: &mut String, open: &mut bool, focus: bool) {
     let (fr, _) = ui.allocate_exact_size(vec2(w, 32.0), Sense::hover());
     let field = Rect::from_min_max(pos2(fr.min.x + 12.0, fr.min.y + 2.0), pos2(fr.max.x - 12.0, fr.max.y - 6.0));
     ui.painter().rect_filled(field, CornerRadius::same(5), t.field);
@@ -583,21 +680,25 @@ fn search_field(app: &mut FigApp, ui: &mut Ui, t: &Tokens, w: f32, id: Id) {
     let te_rect = Rect::from_min_max(pos2(field.min.x + 24.0, field.center().y - 7.0), pos2(field.max.x - 6.0, field.center().y + 7.0));
     let mut child = ui.new_child(egui::UiBuilder::new().max_rect(te_rect));
     let r = child.add(
-        egui::TextEdit::singleline(&mut app.ui.layer_filter)
+        egui::TextEdit::singleline(text)
             .id(id)
             .frame(egui::Frame::NONE)
             .font(regular(11.0))
-            .hint_text(tr("Find layers"))
+            .hint_text(hint)
             .vertical_align(egui::Align::Center)
             .desired_width(te_rect.width()),
     );
-    crate::widgets::select_all_on_focus(ui, &r, &app.ui.layer_filter);
-    if r.has_focus() {
-        ui.painter().rect_stroke(field, CornerRadius::same(5), Stroke::new(1.0, t.accent), egui::StrokeKind::Inside);
+    // After the field: the click that opened it ends elsewhere, which would take the focus back.
+    if focus {
+        r.request_focus();
     }
-    if (r.has_focus() || r.lost_focus()) && ui.input(|i| i.key_pressed(egui::Key::Escape)) {
-        app.ui.layer_search = false;
-        app.ui.layer_filter.clear();
+    crate::widgets::select_all_on_focus(ui, &r, text);
+    if r.has_focus() {
+        ui.painter().rect_stroke(field, CornerRadius::same(5), Stroke::new(1.0, ACCENT), egui::StrokeKind::Inside);
+    }
+    if (r.has_focus() || r.lost_focus()) && ui.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::Escape)) {
+        *open = false;
+        text.clear();
     }
 }
 
@@ -616,12 +717,9 @@ fn layers(app: &mut FigApp, ui: &mut Ui) {
     if sresp.clicked() {
         app.ui.layer_search = !app.ui.layer_search;
         app.ui.layer_filter.clear();
-        if app.ui.layer_search {
-            ui.memory_mut(|m| m.request_focus(search_id));
-        }
     }
     if app.ui.layer_search {
-        search_field(app, ui, &t, w, search_id);
+        search_field(ui, &t, w, search_id, tr("Find layers"), &mut app.ui.layer_filter, &mut app.ui.layer_search, sresp.clicked());
     }
     let Ok(ds) = app.session.ds() else { return };
     let doc = ds.doc.clone();
@@ -1015,6 +1113,7 @@ fn layers(app: &mut FigApp, ui: &mut Ui) {
     }
     if let Some((id, m)) = clicked {
         app.ui.layers_focus = true;
+        app.ui.pages_focus = None;
         let order: Vec<NodeId> = rows.iter().map(|r| r.id).collect();
         let pos = |x: NodeId| order.iter().position(|o| *o == x);
         let anchor = app.ui.layer_anchor.filter(|a| sel.contains(a)).and_then(pos);
diff --git a/crates/ui-egui/src/layers_behaviour_tests.rs b/crates/ui-egui/src/layers_behaviour_tests.rs
index 43a8b76ea..4d987e66d 100644
--- a/crates/ui-egui/src/layers_behaviour_tests.rs
+++ b/crates/ui-egui/src/layers_behaviour_tests.rs
@@ -199,6 +199,81 @@ fn page_row(u: &mut Ui, page: NodeId, back: NodeId) -> Pos2 {
     panic!("no row for page {page:?}");
 }
 
+#[test]
+fn pages_search_button_opens_the_filter_and_escape_clears_it() {
+    let s = Session::new();
+    let _ = s.page().unwrap();
+    let mut u = Ui::new(s);
+
+    // The search icon in the Pages header opens the page-name field, not Find and Replace.
+    click(&mut u, Pos2::new(246.0, 124.0), Modifiers::NONE);
+    assert!(u.app.ui.page_search, "the Pages search is open");
+    assert!(u.app.ui.find.is_none(), "page search does not open Find and Replace");
+    u.frame(vec![Event::Text("COMPON".into())]);
+    assert_eq!(u.app.ui.page_filter, "COMPON", "typing can start immediately");
+    u.frame(vec![Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE }]);
+    assert!(!u.app.ui.page_search, "Escape closes page search");
+    assert!(u.app.ui.page_filter.is_empty(), "Escape clears the filter");
+}
+
+#[test]
+fn pages_search_leaves_escape_to_the_canvas_when_the_field_is_unfocused() {
+    let mut s = Session::new();
+    let r = rect(&mut s, "r", 0.0, None);
+    s.execute("select.set", &json!({"ids": [r]})).unwrap();
+    let mut u = Ui::new(s);
+    u.app.ui.page_search = true;
+    u.app.ui.page_filter = "COMPON".into();
+    u.frame(vec![]);
+
+    u.frame(vec![Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE }]);
+
+    assert!(u.app.session.selection().is_empty(), "Escape deselects on the canvas");
+    assert!(u.app.ui.page_search, "the page search stays open");
+    assert_eq!(u.app.ui.page_filter, "COMPON", "and keeps its filter");
+}
+
+#[test]
+fn escape_in_the_pages_search_does_not_reach_the_canvas() {
+    let mut s = Session::new();
+    let r = rect(&mut s, "r", 0.0, None);
+    s.execute("select.set", &json!({"ids": [r]})).unwrap();
+    let mut u = Ui::new(s);
+    click(&mut u, Pos2::new(246.0, 124.0), Modifiers::NONE);
+    assert!(u.app.ui.page_search);
+    u.frame(vec![Event::Text("x".into())]);
+    u.frame(vec![Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE }]);
+    assert!(!u.app.ui.page_search, "Escape closes the page search");
+    assert_eq!(u.app.session.selection(), vec![r], "and leaves the selection alone");
+}
+
+#[test]
+fn pages_search_filters_page_names_case_insensitively() {
+    let mut s = Session::new();
+    let _overview = s.page().unwrap();
+    let components = id(s.execute("page.add", &json!({"name": "Components"})).unwrap());
+    let library = id(s.execute("page.add", &json!({"name": "Library"})).unwrap());
+    s.execute("page.select", &json!({"id": library})).unwrap();
+    let mut u = Ui::new(s);
+    u.app.ui.page_search = true;
+    u.app.ui.page_filter = "COMPON".into();
+    let shapes = u.frame_output(vec![]).shapes;
+    let text = crate::live_tests::texts(&crate::live_tests::flat(&shapes));
+    assert!(text.iter().any(|(label, _, _)| label == "Components"), "the matching page remains visible");
+    assert!(!text.iter().any(|(label, _, _)| label == "Library"), "nonmatching pages are filtered out");
+
+    // Search leaves only Components; the active page starts as Library.
+    for y in (150..400).step_by(4) {
+        let p = Pos2::new(150.0, y as f32);
+        u.button(p, true);
+        u.button(p, false);
+        if u.app.session.page().unwrap() == components {
+            break;
+        }
+    }
+    assert_eq!(u.app.session.page().unwrap(), components, "matching is case-insensitive and opens the named page");
+}
+
 #[test]
 fn pages_drag_to_reorder_and_dividers_open_nothing() {
     let mut s = Session::new();
@@ -331,3 +406,160 @@ fn double_clicking_a_page_renames_it_with_the_focus_in_the_screen_reader_tree()
     assert_eq!(u.app.ui.rename_page.as_ref().map(|r| r.0), Some(p1));
     assert!(u.app.ui.last_error.is_none(), "{:?}", u.app.ui.last_error);
 }
+
+/// The y of the line between the pages and the layers, above the layers' row at `layer` (found by
+/// the resize cursor it shows when hovered).
+fn pages_edge_at(u: &mut Ui, layer: f32) -> f32 {
+    let hits: Vec<f32> = ((layer - 120.0) as i32..layer as i32)
+        .map(|y| y as f32)
+        .filter(|y| u.frame_output(vec![Event::PointerMoved(Pos2::new(150.0, *y))]).platform_output.cursor_icon == egui::CursorIcon::ResizeVertical)
+        .collect();
+    assert!(!hits.is_empty(), "no edge above {layer}");
+    (hits[0] + hits[hits.len() - 1]) / 2.0
+}
+
+#[test]
+fn the_line_between_pages_and_layers_drags_to_size_the_pages_list() {
+    let mut s = Session::new();
+    let rect = id(s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 10, "height": 10})).unwrap());
+    for _ in 0..59 {
+        s.execute("page.add", &json!({})).unwrap();
+    }
+    let first = s.doc().unwrap().pages[0];
+    s.execute("page.select", &json!({"id": first})).unwrap();
+    s.execute("select.none", &json!({})).unwrap();
+    let mut u = Ui::new(s);
+    let before = u.row_at(rect).y;
+    let edge = pages_edge_at(&mut u, before);
+    // A drag down by 150 px makes the pages list taller and moves the layers down with it.
+    let at = |dy: f32| Pos2::new(150.0, edge + dy);
+    let button = |p, pressed| Event::PointerButton { pos: p, button: egui::PointerButton::Primary, pressed, modifiers: Modifiers::NONE };
+    u.frame(vec![Event::PointerMoved(at(0.0))]);
+    u.frame(vec![button(at(0.0), true)]);
+    for k in 1..=15 {
+        u.frame(vec![Event::PointerMoved(at(10.0 * k as f32))]);
+    }
+    u.frame(vec![button(at(150.0), false)]);
+    for _ in 0..30 {
+        u.frame(vec![]);
+    }
+    let after = u.row_at(rect).y;
+    assert!((after - before - 150.0).abs() < 3.0, "the layers moved from {before} to {after}");
+    // The height is kept for the next start.
+    let kept = u.app.session.prefs.pages_height.expect("kept in the preferences");
+    let mut next = Session::new();
+    next.prefs = u.app.session.prefs.clone();
+    assert_eq!(crate::FigApp::new(next, Box::new(crate::NoServices)).ui.pages_height, Some(kept));
+    // A double-click puts back the default.
+    let edge = pages_edge_at(&mut u, after);
+    let p = Pos2::new(150.0, edge);
+    u.frame(vec![Event::PointerMoved(p)]);
+    for _ in 0..2 {
+        u.frame(vec![button(p, true)]);
+        u.frame(vec![button(p, false)]);
+    }
+    for _ in 0..30 {
+        u.frame(vec![]);
+    }
+    assert_eq!(u.app.session.prefs.pages_height, None);
+    assert!((u.row_at(rect).y - before).abs() < 3.0);
+}
+
+#[test]
+fn dragging_up_the_line_under_a_short_pages_list_shrinks_it_at_once() {
+    // Five pages fit in the room the list is given: the drag starts from the rows shown, not
+    // from that room, so the line follows the pointer.
+    let mut s = Session::new();
+    let rect = id(s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 10, "height": 10})).unwrap());
+    for _ in 0..4 {
+        s.execute("page.add", &json!({})).unwrap();
+    }
+    let first = s.doc().unwrap().pages[0];
+    s.execute("page.select", &json!({"id": first})).unwrap();
+    s.execute("select.none", &json!({})).unwrap();
+    let mut u = Ui::new(s);
+    let before = u.row_at(rect).y;
+    let edge = pages_edge_at(&mut u, before);
+    let at = |dy: f32| Pos2::new(150.0, edge + dy);
+    let button = |p, pressed| Event::PointerButton { pos: p, button: egui::PointerButton::Primary, pressed, modifiers: Modifiers::NONE };
+    u.frame(vec![Event::PointerMoved(at(0.0))]);
+    u.frame(vec![button(at(0.0), true)]);
+    for k in 1..=4 {
+        u.frame(vec![Event::PointerMoved(at(-10.0 * k as f32))]);
+    }
+    u.frame(vec![button(at(-40.0), false)]);
+    for _ in 0..30 {
+        u.frame(vec![]);
+    }
+    let after = u.row_at(rect).y;
+    assert!((before - after - 40.0).abs() < 3.0, "the layers moved from {before} to {after}");
+}
+
+#[test]
+fn the_pages_list_keeps_three_rows_and_leaves_the_layers_room() {
+    use crate::layers::{ROW, pages_list_height};
+    // The default: 40% of the panel.
+    assert_eq!(pages_list_height(None, 800.0), 320.0);
+    // Dragged short or tall, it stays within three rows and the room the layers need.
+    assert_eq!(pages_list_height(Some(0.0), 800.0), 3.0 * ROW);
+    assert_eq!(pages_list_height(Some(5000.0), 800.0), 800.0 - 40.0 - 3.0 * ROW);
+    assert_eq!(pages_list_height(Some(f32::NAN), 800.0), 320.0);
+    // A panel too short for both keeps the three rows.
+    assert_eq!(pages_list_height(Some(500.0), 100.0), 3.0 * ROW);
+}
+
+/// Selecting a page that is far down the list automatically scrolls it into view.
+#[test]
+fn selecting_a_distant_page_scrolls_it_into_view() {
+    let mut s = Session::new();
+    let rect = id(s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 10, "height": 10})).unwrap());
+    for _ in 0..40 {
+        s.execute("page.add", &json!({})).unwrap();
+    }
+    let pages = s.doc().unwrap().pages.clone();
+    let first = pages[0];
+    let last = *pages.last().unwrap();
+    s.execute("page.select", &json!({"id": first})).unwrap();
+    s.execute("select.none", &json!({})).unwrap();
+    let mut u = Ui::new(s);
+    let layer = u.row_at(rect);
+    u.frame(vec![]);
+    // Select the last page.
+    u.app.run("page.select", json!({"id": last}));
+    for _ in 0..15 {
+        u.frame(vec![]);
+    }
+    assert_eq!(u.app.ui.pages_seen_page, Some((u.app.session.ds().unwrap().uid, last)));
+    let opened = pages_down_to(&mut u, layer.y - 60.0);
+    let top = pages.iter().position(|p| Some(p) == opened.first()).unwrap();
+    assert!(top > 20, "the list scrolled past its first pages to reveal the selection (top row: page {top})");
+}
+
+/// If the active page is filtered out by search, it is not marked as seen
+/// until the filter is cleared and its row actually renders.
+#[test]
+fn filtered_out_active_page_is_seen_only_after_rendering() {
+    let mut s = Session::new();
+    let p1 = s.doc().unwrap().pages[0];
+    let p2 = id(s.execute("page.add", &json!({})).unwrap());
+    s.execute("page.rename", &json!({"id": p1, "name": "Alpha"})).unwrap();
+    s.execute("page.rename", &json!({"id": p2, "name": "Beta"})).unwrap();
+    s.execute("page.select", &json!({"id": p1})).unwrap();
+    let uid = s.ds().unwrap().uid;
+    let mut u = Ui::new(s);
+    assert_eq!(u.app.ui.pages_seen_page, Some((uid, p1)));
+
+    // Filter to only "Alpha", then select "Beta" (p2).
+    u.app.ui.page_search = true;
+    u.app.ui.page_filter = "Alpha".into();
+    u.app.run("page.select", json!({"id": p2}));
+    u.frame(vec![]);
+
+    // Beta was filtered out and not rendered, so pages_seen_page has not recorded it.
+    assert_ne!(u.app.ui.pages_seen_page, Some((uid, p2)));
+
+    // Clear filter: Beta renders now and is recorded.
+    u.app.ui.page_filter.clear();
+    u.frame(vec![]);
+    assert_eq!(u.app.ui.pages_seen_page, Some((uid, p2)));
+}
diff --git a/crates/ui-egui/src/layers_keys_tests.rs b/crates/ui-egui/src/layers_keys_tests.rs
index b78890a89..63f8ce74c 100644
--- a/crates/ui-egui/src/layers_keys_tests.rs
+++ b/crates/ui-egui/src/layers_keys_tests.rs
@@ -1,8 +1,8 @@
 //! Arrow keys in the layers panel once a row has been clicked: up/down through the rows (Shift
 //! extends), left/right to collapse, expand, and go to the parent or first child; a press on the
-//! canvas gives arrows back to nudging.
+//! canvas gives arrows back to nudging. Delete after a click in the Pages list deletes the page.
 
-use egui::{Event, Key, Modifiers, pos2};
+use egui::{Event, Key, Modifiers, Pos2, pos2, vec2};
 use figcraft_doc::NodeId;
 use figcraft_engine::Session;
 use serde_json::json;
@@ -107,3 +107,125 @@ fn a_canvas_press_gives_arrows_back_to_nudging() {
     let doc = u.app.session.doc().unwrap();
     assert_eq!(doc.node(c).unwrap().transform.translation().x, 201.0);
 }
+
+/// The middle of `page`'s row in the Pages list, found by clicking down the list until it opens;
+/// then back to `back`.
+fn page_row(u: &mut Ui, page: NodeId, back: NodeId) -> Pos2 {
+    for y in (90..400).step_by(4) {
+        let p = pos2(150.0, y as f32);
+        u.button(p, true);
+        u.button(p, false);
+        if u.app.session.page().unwrap() == page {
+            u.app.session.execute("page.select", &json!({"id": back})).unwrap();
+            u.frame(vec![]);
+            // Rows are 32 high: aim at the middle, past the hit tolerance at its edge.
+            return p + vec2(0.0, 12.0);
+        }
+    }
+    panic!("no row for page {page:?}");
+}
+
+fn pages(u: &Ui) -> usize {
+    u.app.session.doc().unwrap().pages.len()
+}
+
+#[test]
+fn delete_after_clicking_a_page_deletes_it_without_asking() {
+    // #859: Delete on a page picked in the Pages list said "nothing is selected".
+    let (mut u, ..) = setup();
+    let first = u.app.session.page().unwrap();
+    let second = id(u.app.session.execute("page.add", &json!({})).unwrap());
+    u.app.session.execute("page.select", &json!({"id": first})).unwrap();
+    u.frame(vec![]);
+    let row = page_row(&mut u, second, first);
+    u.button(row, true);
+    u.button(row, false);
+    assert_eq!(u.app.session.page().unwrap(), second);
+    key(&mut u, Key::Delete, false);
+    // Gone at once, no confirmation: a toast says so and Undo brings it back.
+    assert_eq!(pages(&u), 1);
+    assert!(!u.app.session.doc().unwrap().pages.contains(&second));
+    assert_eq!(u.app.ui.toast.as_ref().map(|t| t.0.as_str()), Some("Page deleted"));
+    u.app.run("edit.undo", json!({}));
+    assert_eq!(pages(&u), 2);
+    // Backspace (the Mac's delete key) does the same.
+    let row = page_row(&mut u, second, first);
+    u.button(row, true);
+    u.button(row, false);
+    key(&mut u, Key::Backspace, false);
+    assert_eq!(pages(&u), 1);
+    // The last page stays.
+    key(&mut u, Key::Delete, false);
+    assert_eq!(pages(&u), 1);
+}
+
+#[test]
+fn selected_layers_or_a_canvas_press_take_delete_back_from_the_pages_list() {
+    let (mut u, a, ..) = setup();
+    let first = u.app.session.page().unwrap();
+    let second = id(u.app.session.execute("page.add", &json!({})).unwrap());
+    u.frame(vec![]);
+    let row = page_row(&mut u, first, second);
+    u.button(row, true);
+    u.button(row, false);
+    assert_eq!(u.app.session.page().unwrap(), first);
+    assert!(u.app.ui.pages_focus.is_some());
+    // Layers selected after the click (Select all, say): Delete deletes them, not the page.
+    u.app.run("select.set", json!({"ids": [a]}));
+    key(&mut u, Key::Delete, false);
+    assert_eq!(pages(&u), 2);
+    assert!(u.app.session.doc().unwrap().node(a).is_none());
+    // Nothing is selected now, but the list gave up the keyboard: a second Delete keeps the page.
+    assert!(u.app.ui.pages_focus.is_none());
+    key(&mut u, Key::Delete, false);
+    assert_eq!(pages(&u), 2, "a second Delete keeps the page");
+    // A press on the canvas gives Delete back to it.
+    u.button(row, true);
+    u.button(row, false);
+    assert!(u.app.ui.pages_focus.is_some());
+    let p = pos2(900.0, 700.0);
+    u.button(p, true);
+    u.button(p, false);
+    assert!(u.app.ui.pages_focus.is_none());
+    u.app.run("select.none", json!({}));
+    key(&mut u, Key::Delete, false);
+    assert_eq!(pages(&u), 2, "Delete with nothing selected on the canvas deletes no page");
+}
+
+#[test]
+fn delete_deletes_no_page_once_the_pages_list_is_off_screen_or_another_file_is_open() {
+    let (mut u, ..) = setup();
+    let first = u.app.session.page().unwrap();
+    let second = id(u.app.session.execute("page.add", &json!({})).unwrap());
+    u.app.session.execute("page.select", &json!({"id": first})).unwrap();
+    u.frame(vec![]);
+    let row = page_row(&mut u, second, first);
+    let click = |u: &mut Ui| {
+        u.button(row, true);
+        u.button(row, false);
+        assert!(u.app.ui.pages_focus.is_some());
+    };
+    // The Assets tab, a collapsed Pages list, a collapsed left panel.
+    let hide: [fn(&mut Ui, bool); 3] = [
+        |u, on| u.app.ui.left_tab = if on { crate::LeftTab::Assets } else { crate::LeftTab::File },
+        |u, on| u.app.ui.pages_open = !on,
+        |u, on| u.app.ui.left_collapsed = on,
+    ];
+    for (k, hide) in hide.iter().enumerate() {
+        click(&mut u);
+        hide(&mut u, true);
+        u.frame(vec![]);
+        key(&mut u, Key::Delete, false);
+        assert_eq!(pages(&u), 2, "case {k}: the list is off screen");
+        hide(&mut u, false);
+        u.frame(vec![]);
+    }
+    // Another file open: its pages are safe.
+    click(&mut u);
+    u.app.run("file.new", json!({}));
+    u.app.run("page.add", json!({}));
+    u.frame(vec![]);
+    assert_eq!(pages(&u), 2);
+    key(&mut u, Key::Delete, false);
+    assert_eq!(pages(&u), 2, "the other file keeps its pages");
+}
diff --git a/crates/ui-egui/src/layers_rename_tests.rs b/crates/ui-egui/src/layers_rename_tests.rs
index 4f5c6af80..c4b9211c8 100644
--- a/crates/ui-egui/src/layers_rename_tests.rs
+++ b/crates/ui-egui/src/layers_rename_tests.rs
@@ -170,3 +170,28 @@ fn a_rename_scrolled_out_of_view_goes_on() {
     press(&mut u, Key::Enter, Modifiers::NONE);
     assert_eq!(name(&u, top), "Far");
 }
+
+#[test]
+fn a_key_typed_in_the_frame_a_rename_starts_replaces_the_name() {
+    // The app draws no frame between the double-click's last release (or F2, or File ▸ Rename) and
+    // the first key, so the name field first shows in the frame that types into it.
+    let (mut u, a, _, _, c) = setup();
+    let p = u.row_at(c);
+    for _ in 0..2 {
+        u.button(p, true);
+        u.button(p, false);
+    }
+    type_text(&mut u, "Hero");
+    press(&mut u, Key::Enter, Modifiers::NONE);
+    assert_eq!(name(&u, c), "Hero", "a double-click rename");
+    u.app.session.execute("select.set", &json!({"ids": [a]})).unwrap();
+    u.frame(vec![]);
+    press(&mut u, Key::F2, Modifiers::NONE);
+    type_text(&mut u, "Base");
+    press(&mut u, Key::Enter, Modifiers::NONE);
+    assert_eq!(name(&u, a), "Base", "an F2 rename");
+    crate::menus::invoke(&mut u.app, "file.rename");
+    type_text(&mut u, "Brand kit");
+    press(&mut u, Key::Enter, Modifiers::NONE);
+    assert_eq!(u.app.session.doc().unwrap().name, "Brand kit", "File ▸ Rename");
+}
diff --git a/crates/ui-egui/src/layout_panel.rs b/crates/ui-egui/src/layout_panel.rs
index bb60ebeba..b5ff1d45f 100644
--- a/crates/ui-egui/src/layout_panel.rs
+++ b/crates/ui-egui/src/layout_panel.rs
@@ -29,8 +29,8 @@ pub fn layout_section(app: &mut FigApp, ui: &mut Ui, doc: &Document, sel: &[Node
     let al = common(doc, sel, |n| n.layout.clone());
     let has_al = matches!(al, Some(Some(_)));
     let title = if has_al { tr("Auto layout") } else { tr("Layout") };
-    // An instance's auto layout is its main's (only padding, gap and alignment are its own), and
-    // the layers inside it keep their main's size.
+    // An instance's auto layout is its main's (only padding, gap and alignment are its own); the
+    // layers inside it override their size and resizing, not their place in the layout.
     let in_instance = sel.iter().any(|i| figcraft_engine::components::owning_instance(doc, *i).is_some());
     let nested = sel.iter().any(|i| figcraft_engine::components::inside_instance(doc, *i));
     let btns: Vec<(Icon, &str)> = if in_instance {
@@ -49,7 +49,7 @@ pub fn layout_section(app: &mut FigApp, ui: &mut Ui, doc: &Document, sel: &[Node
     if let Some(Some(l)) = &al {
         ui.add_enabled_ui(!in_instance, |ui| direction(app, ui, &ids, l)).response.on_disabled_hover_text(from_main);
     }
-    ui.add_enabled_ui(!nested, |ui| dimensions(app, ui, doc, sel, has_al)).response.on_disabled_hover_text(from_main);
+    dimensions(app, ui, doc, sel, has_al, nested, from_main);
     if let Some(Some(l)) = &al {
         alignment(app, ui, &ids, l);
         spacing(app, ui, &ids, l);
@@ -62,6 +62,7 @@ pub fn layout_section(app: &mut FigApp, ui: &mut Ui, doc: &Document, sel: &[Node
         .response
         .on_disabled_hover_text(from_main);
     }
+    crate::selection_spacing::panel(app, ui, sel);
     let grid_parent = sel.iter().all(|i| parent_of(doc, *i).and_then(|p| p.layout.as_ref()).is_some_and(|l| l.mode == LayoutMode::Grid));
     if grid_parent && common(doc, sel, |n| n.child_layout.absolute) == Some(false) {
         ui.add_enabled_ui(!nested, |ui| grid_cell(app, ui, doc, sel)).response.on_disabled_hover_text(from_main);
@@ -146,7 +147,8 @@ fn limit(n: &Node, horizontal: bool, is_min: bool) -> Option<f64> {
     }
 }
 
-fn dimensions(app: &mut FigApp, ui: &mut Ui, doc: &Document, sel: &[NodeId], has_al: bool) {
+/// `nested`: layers inside an instance, whose proportion lock is their main's (`from_main` says so).
+fn dimensions(app: &mut FigApp, ui: &mut Ui, doc: &Document, sel: &[NodeId], has_al: bool, nested: bool, from_main: &str) {
     let ids = sel.to_vec();
     let w_of = |n: &Node| (n.width * 100.0).round() / 100.0;
     let h_of = |n: &Node| (n.height * 100.0).round() / 100.0;
@@ -159,7 +161,13 @@ fn dimensions(app: &mut FigApp, ui: &mut Ui, doc: &Document, sel: &[NodeId], has
         let e = crate::variable_ui::number_field_mixed(app, ui, &ids, "height", Id::new("lay_h"), Lead::Text("H"), h, "", col);
         app.field_of(&ids, "height", e, h_of, |v| json!(v.max(0.0)));
         let locked = common(doc, sel, |n| n.constrain_proportions).unwrap_or(false);
-        if icons::button(ui, if locked { Icon::LinkOn } else { Icon::LinkOff }, 24.0, locked, tr("Constrain proportions")).clicked() {
+        let link = ui
+            .add_enabled_ui(!nested, |ui| {
+                icons::button(ui, if locked { Icon::LinkOn } else { Icon::LinkOff }, 24.0, locked, tr("Constrain proportions"))
+            })
+            .inner
+            .on_disabled_hover_text(from_main);
+        if link.clicked() {
             app.set_props(&ids, json!({"constrainProportions": !locked}));
         }
     });
@@ -393,35 +401,66 @@ fn alignment(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId], l: &AutoLayout) {
     }
 }
 
+/// The Spacing row: the H/V padding pair, or, with Individual padding on, two rows of one field
+/// per side (like Individual corners).
 fn spacing(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId], l: &AutoLayout) {
     let col = widgets::col_width(ui.available_width());
     let [pt, pr, pb, pl] = l.padding;
-    row(ui, 32.0, |ui| {
-        let e = crate::variable_ui::number_field(
-            app,
-            ui,
-            ids,
-            "paddingHorizontal",
-            Id::new("al_padh"),
-            Lead::Icon(Icon::PaddingH, tr("Horizontal padding")),
-            (pl == pr).then_some(pl),
-            "",
-            col,
-        );
-        app.field(ids, "paddingHorizontal", e, |v| json!(v.max(0.0)));
-        let e = crate::variable_ui::number_field(
-            app,
-            ui,
-            ids,
-            "paddingVertical",
-            Id::new("al_padv"),
-            Lead::Icon(Icon::PaddingV, tr("Vertical padding")),
-            (pt == pb).then_some(pt),
-            "",
-            col,
-        );
-        app.field(ids, "paddingVertical", e, |v| json!(v.max(0.0)));
-    });
+    let open = ui.data(|d| d.get_temp::<bool>(Id::new("indep_padding"))).unwrap_or(false);
+    let toggle = |ui: &mut Ui| {
+        if icons::button(ui, Icon::IndependentPadding, 24.0, open, tr("Individual padding")).clicked() {
+            ui.data_mut(|d| d.insert_temp(Id::new("indep_padding"), !open));
+        }
+    };
+    if open {
+        // `l` is the selection's common layout, so its sides are common too. `k` indexes
+        // [top, right, bottom, left].
+        let sides = [
+            ("paddingLeft", tr("Left padding"), Icon::PaddingLeft, pl, 3),
+            ("paddingTop", tr("Top padding"), Icon::PaddingTop, pt, 0),
+            ("paddingRight", tr("Right padding"), Icon::PaddingRight, pr, 1),
+            ("paddingBottom", tr("Bottom padding"), Icon::PaddingBottom, pb, 2),
+        ];
+        for (r, pair) in sides.chunks(2).enumerate() {
+            row(ui, 32.0, |ui| {
+                for (key, name, icon, v, k) in pair {
+                    let e = crate::variable_ui::number_field(app, ui, ids, key, Id::new(("padding", *k)), Lead::Icon(*icon, name), Some(*v), "", col);
+                    app.field(ids, key, e, |v| json!(v.max(0.0)));
+                }
+                if r == 0 {
+                    toggle(ui);
+                }
+            });
+        }
+    } else {
+        row(ui, 32.0, |ui| {
+            let e = crate::variable_ui::number_field(
+                app,
+                ui,
+                ids,
+                "paddingHorizontal",
+                Id::new("al_padh"),
+                Lead::Icon(Icon::PaddingH, tr("Horizontal padding")),
+                (pl == pr).then_some(pl),
+                "",
+                col,
+            );
+            app.field(ids, "paddingHorizontal", e, |v| json!(v.max(0.0)));
+            let e = crate::variable_ui::number_field(
+                app,
+                ui,
+                ids,
+                "paddingVertical",
+                Id::new("al_padv"),
+                Lead::Icon(Icon::PaddingV, tr("Vertical padding")),
+                (pt == pb).then_some(pt),
+                "",
+                col,
+            );
+            app.field(ids, "paddingVertical", e, |v| json!(v.max(0.0)));
+            toggle(ui);
+        });
+    }
     if l.mode != LayoutMode::Grid && l.wrap {
         // Wrapped rows (horizontal) or columns (vertical): the gap between them.
         let vertical = l.mode == LayoutMode::Vertical;
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index e0749a97f..231c7b909 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -8,6 +8,7 @@
 pub mod a11y;
 pub mod assets_panel;
 pub mod bidi;
+pub mod board_bar;
 pub mod branch_ui;
 pub mod canvas;
 pub mod cjk;
@@ -32,6 +33,7 @@ pub mod home;
 pub mod home_recents;
 pub mod i18n;
 pub mod icons;
+pub mod import_report;
 pub mod layers;
 pub mod layout_panel;
 pub mod list_drag;
@@ -39,6 +41,7 @@ pub mod live;
 pub mod live_text;
 pub mod measure_overlay;
 pub mod menus;
+pub mod missing_fonts;
 pub mod online;
 pub mod pending_open;
 pub mod plugins_ui;
@@ -50,6 +53,8 @@ pub mod render_worker;
 pub mod right;
 pub mod scale_panel;
 pub mod section_panel;
+pub mod selection_colors;
+mod selection_spacing;
 pub mod shortcuts;
 pub mod shortcuts_panel;
 pub mod style_picker;
@@ -57,6 +62,7 @@ pub mod tabs;
 pub mod theme;
 pub mod toolbar;
 pub mod typography;
+pub mod ui_scale;
 pub mod variable_ui;
 pub mod variables_panel;
 pub mod vector_panel;
@@ -64,6 +70,8 @@ pub mod versions;
 pub mod widgets;
 pub mod windows;
 
+#[cfg(test)]
+mod board_ui_tests;
 #[cfg(test)]
 mod theme_startup_tests;
 
@@ -80,14 +88,26 @@ mod canvas_drag_tests;
 #[cfg(test)]
 mod canvas_fixes_tests;
 #[cfg(test)]
+mod canvas_image_rect_tests;
+#[cfg(test)]
+mod colorpicker_eyedropper_tests;
+#[cfg(test)]
 mod colorpicker_selection_tests;
 #[cfg(test)]
 mod comments_tests;
 #[cfg(test)]
+mod component_props_reorder_tests;
+#[cfg(test)]
+mod corner_individual_tests;
+#[cfg(test)]
 mod cursors_tests;
 #[cfg(test)]
+mod design_paste_tests;
+#[cfg(test)]
 mod dev_mode_tests;
 #[cfg(test)]
+mod devmode_tail_tests;
+#[cfg(test)]
 mod duplicate_paint_tests;
 #[cfg(test)]
 mod export_preview_tests;
@@ -108,6 +128,10 @@ mod home_tests;
 #[cfg(test)]
 mod idle_tests;
 #[cfg(test)]
+mod ime_tests;
+#[cfg(test)]
+mod import_report_tests;
+#[cfg(test)]
 mod layers_behaviour_tests;
 #[cfg(test)]
 mod layers_drag_tests;
@@ -132,16 +156,32 @@ mod live_tests;
 #[cfg(test)]
 mod live_text_tests;
 #[cfg(test)]
+mod measure_nudge_tests;
+#[cfg(test)]
+mod menu_aim_tests;
+#[cfg(test)]
+mod menu_contrast_tests;
+#[cfg(test)]
+mod menu_input_tests;
+#[cfg(test)]
+mod missing_fonts_tests;
+#[cfg(test)]
 mod online_tests;
 #[cfg(test)]
 mod open_issues_tests;
 #[cfg(test)]
+mod padding_individual_tests;
+#[cfg(test)]
+mod palette_tests;
+#[cfg(test)]
 mod panel_remove_tests;
 #[cfg(test)]
 mod panel_reorder_tests;
 #[cfg(test)]
 mod panel_width_tests;
 #[cfg(test)]
+mod paste_image_tests;
+#[cfg(test)]
 mod pen_mode_tests;
 #[cfg(test)]
 mod perf_tests;
@@ -152,6 +192,10 @@ mod plugins_browse_tests;
 #[cfg(test)]
 mod popup_width_tests;
 #[cfg(test)]
+mod present_links_tests;
+#[cfg(test)]
+mod present_tab_tests;
+#[cfg(test)]
 mod present_tests;
 #[cfg(test)]
 mod present_view_tests;
@@ -162,6 +206,10 @@ mod proto_reorder_tests;
 #[cfg(test)]
 mod proto_responsive_tests;
 #[cfg(test)]
+mod resources_tests;
+#[cfg(test)]
+mod save_as_tests;
+#[cfg(test)]
 mod select_all_tests;
 #[cfg(test)]
 mod shortcut_keys_tests;
@@ -174,10 +222,14 @@ mod text_enter_tests;
 #[cfg(test)]
 mod titlebar_tests;
 #[cfg(test)]
+mod ui_scale_tests;
+#[cfg(test)]
 mod variables_export_ui_tests;
 #[cfg(test)]
 mod variables_rename_tests;
 #[cfg(test)]
+mod variants_discovery_tests;
+#[cfg(test)]
 mod vector_panel_tests;
 #[cfg(test)]
 mod vector_tail_ui_tests;
@@ -206,6 +258,11 @@ pub trait Services {
     fn pick_open(&mut self, _title: &str, _exts: &[&str]) -> DialogFuture {
         Box::pin(std::future::ready(None))
     }
+    /// Pick a file and read it, where the platform hands over a file's name and contents rather
+    /// than a path to it (the browser). `None`: the platform picks paths ([`Services::pick_open`]).
+    fn pick_open_contents(&mut self, _title: &str, _exts: &[&str]) -> Option<ContentsFuture> {
+        None
+    }
     fn pick_save(&mut self, _title: &str, _name: &str, _exts: &[&str]) -> DialogFuture {
         Box::pin(std::future::ready(None))
     }
@@ -226,6 +283,9 @@ pub trait Services {
     fn clipboard_get_text(&mut self) -> Option<String> {
         None
     }
+    fn clipboard_get_html(&mut self) -> Option<String> {
+        None
+    }
     fn clipboard_set_png(&mut self, _w: u32, _h: u32, _rgba: &[u8]) {}
     /// An image on the system clipboard as (width, height, straight RGBA).
     fn clipboard_get_image(&mut self) -> Option<(u32, u32, Vec<u8>)> {
@@ -262,14 +322,61 @@ pub trait Services {
 }
 
 pub type DialogFuture = Pin<Box<dyn Future<Output = Option<PathBuf>>>>;
-type DialogDone = Box<dyn FnOnce(&mut FigApp, PathBuf)>;
+/// A picked file's name and contents ([`Services::pick_open_contents`]); `None` when the picker
+/// was cancelled, `Err` with what to tell the user when the file couldn't be read.
+pub type ContentsFuture = Pin<Box<dyn Future<Output = Option<Result<(String, Vec<u8>), String>>>>>;
+/// A dropped file's contents, read once they arrive (`Err`: what to tell the user when they
+/// couldn't be read).
+pub type ReadFuture = Pin<Box<dyn Future<Output = Result<Vec<u8>, String>>>>;
+type PickFuture = Pin<Box<dyn Future<Output = Option<Picked>>>>;
+type DialogDone = Box<dyn FnOnce(&mut FigApp, Picked)>;
+
+/// What a dialog picked: a path, or a file's name and contents where there are no paths, or why
+/// the picked file couldn't be read.
+enum Picked {
+    Path(PathBuf),
+    Contents(String, Vec<u8>),
+    Unreadable(String),
+}
+
+impl Picked {
+    /// The file as `file.open` and `file.import` take it (`Err`: what to tell the user instead).
+    fn file_params(self) -> Result<Value, String> {
+        match self {
+            Picked::Path(p) => Ok(json!({"path": p.to_string_lossy()})),
+            Picked::Contents(name, bytes) => {
+                use base64::Engine as _;
+                Ok(json!({"data": base64::engine::general_purpose::STANDARD.encode(&bytes), "name": name}))
+            }
+            Picked::Unreadable(why) => Err(why),
+        }
+    }
+}
+
+/// What the user is told about a file whose contents couldn't be read.
+pub fn unreadable(name: &str) -> String {
+    i18n::trf("Couldn't read {name}.", &[("name", &name)])
+}
+
+/// The largest file read in the browser: wasm has at most 4 GiB of memory, and a file's contents
+/// are held about three times on their way to `file.open` (the bytes, base64, decoded again).
+/// As large as one member of a `.figcraft` file may be.
+const MAX_BROWSER_FILE: f64 = (512u64 << 20) as f64;
+
+/// Checks a file of `size` bytes before the browser reads it (`Err`: what to tell the user).
+pub fn browser_can_read(name: &str, size: f64) -> Result<(), String> {
+    if size.is_nan() || size > MAX_BROWSER_FILE {
+        return Err(i18n::trf("{name} is too large to open in the browser (over 512 MB).", &[("name", &name)]));
+    }
+    Ok(())
+}
 
 /// A native dialog in flight. The app keeps working while it is open, so its result goes to the
 /// file and window it was opened for, not to whichever is in front when it closes.
 struct PendingDialog {
-    future: DialogFuture,
-    /// The path picked, kept until the window that holds `doc` draws.
-    path: Option<PathBuf>,
+    future: PickFuture,
+    /// What was picked, kept until the window that holds `doc` draws.
+    picked: Option<Picked>,
     done: DialogDone,
     /// The file it acts on (`None`: none, such as Open).
     doc: Option<u64>,
@@ -380,15 +487,16 @@ pub const PANEL_DEFAULT: f32 = 240.0;
 pub const CANVAS_MIN: f32 = 160.0;
 
 /// The widths the side panels are drawn at in `avail` points (the window less the icon rail), from
-/// the widths asked for (`left`: none while it is closed): each within its limits, and narrower
-/// in a small window so the canvas keeps [`CANVAS_MIN`] (the right panel gives way last).
-pub fn fit_panels(avail: f32, left: Option<f32>, right: f32) -> (f32, f32) {
+/// the widths asked for (none while a panel is closed, which takes no room): each within its
+/// limits, and narrower in a small window so the canvas keeps [`CANVAS_MIN`] (the right panel
+/// gives way last).
+pub fn fit_panels(avail: f32, left: Option<f32>, right: Option<f32>) -> (f32, f32) {
     let fit = |w: f32, range: &std::ops::RangeInclusive<f32>, room: f32| {
         let w = if w.is_finite() { w } else { PANEL_DEFAULT };
         w.clamp(*range.start(), room.clamp(*range.start(), *range.end()))
     };
     let left_min = left.map_or(0.0, |_| *LEFT_PANEL.start());
-    let right = fit(right, &RIGHT_PANEL, avail - left_min - CANVAS_MIN);
+    let right = right.map_or(0.0, |r| fit(r, &RIGHT_PANEL, avail - left_min - CANVAS_MIN));
     (left.map_or(0.0, |l| fit(l, &LEFT_PANEL, avail - right - CANVAS_MIN)), right)
 }
 
@@ -403,18 +511,42 @@ pub struct UiState {
     pub last_right_tab: RightTab,
     pub left_tab: LeftTab,
     pub pages_open: bool,
+    /// Pages panel search: open, and the case-insensitive name filter.
+    pub page_search: bool,
+    pub page_filter: String,
+    /// The height asked for the pages list (`None`: a share of the panel).
+    pub pages_height: Option<f32>,
+    /// The document and active page last drawn in the pages list.
+    pub pages_seen_page: Option<(u64, NodeId)>,
     pub expanded: BTreeSet<NodeId>,
     /// The layer being renamed in the layers panel.
     pub rename: Option<layers::Rename>,
     pub rename_page: Option<(NodeId, String)>,
+    /// The frame or section whose name label on the canvas is being renamed (a double-click on it).
+    pub rename_label: Option<layers::Rename>,
     pub main_menu: bool,
     pub palette: Option<String>,
+    /// The Actions palette's tab.
+    pub palette_tab: menus::PaletteTab,
+    /// The palette row Up and Down are on (Enter runs it).
+    pub palette_hi: usize,
+    /// The palette ignores one outside click after opening (the click that opened it).
+    pub palette_armed: bool,
+    /// This frame's Actions toolbar button rect: presses on it toggle, never dismiss.
+    pub actions_rect: Option<egui::Rect>,
     /// The Variables editor, when open.
     pub variables: Option<variables_panel::Editor>,
     pub about: bool,
     /// The tab the About window shows.
     pub about_tab: dialogs::AboutTab,
     pub preferences: bool,
+    /// A menu command that needs a value before the engine can run it.
+    pub menu_input: Option<dialogs::MenuInput>,
+    /// File ▸ Rename: the file name in the left panel starts its inline rename on the next frame.
+    pub rename_file: bool,
+    /// What the interface size drew last frame and whether the window held it back. Set by
+    /// [`FigApp::logic`] for the main window.
+    pub ui_scale: ui_scale::Plan,
     pub shortcuts_panel: bool,
     /// The Keyboard shortcuts panel's tab and search text.
     pub shortcuts_tab: figcraft_engine::keymap::Group,
@@ -431,6 +563,10 @@ pub struct UiState {
     /// A message at the bottom of the window and how long it has been showing.
     pub toast: Option<(String, ToastClock)>,
     pub present: Option<present::Presenter>,
+    pub presents: Vec<present::PresentTab>,
+    /// The tab shown last. It is on screen while `present` has a value.
+    pub present_active: Option<u64>,
+    pub present_next: u64,
     /// The full-window presenter's options (how it sizes the prototype), kept between
     /// presentations.
     pub present_view: present::PresentView,
@@ -452,15 +588,26 @@ pub struct UiState {
     /// The layers panel has the keyboard: arrow keys move through its rows instead of nudging
     /// (set by a click on a row, cleared by a press on the canvas).
     pub layers_focus: bool,
+    /// The file (its `uid`) whose pages list has the keyboard: Delete with no layers selected deletes
+    /// its current page (set by a click on a page row or the add-page button, cleared by a click on a
+    /// layer row or a press on the canvas).
+    pub pages_focus: Option<u64>,
     pub layers_seen_sel: Vec<NodeId>,
     pub dark: bool,
     pub follow_system: bool,
     pub tool_flyout: Option<&'static str>,
+    /// On a board: the Design panel is shown (boards hide it until asked for).
+    pub board_panel: bool,
     pub last_error: Option<String>,
     /// Files dropped on the home screen or the canvas, opened once their card has been on screen
     /// ([`pending_open::pending_opens`]), and the frames it has been drawn.
     pub pending_opens: Vec<pending_open::PendingOpen>,
     pub pending_open_frames: u8,
+    /// The latest successful file import's summary and compatibility notes.
+    pub import_report: Option<import_report::Report>,
+    /// Files the user opened whose fonts are yet to be checked (by document uid).
+    pub font_checks: Vec<u64>,
+    pub missing_fonts: Option<missing_fonts::Shown>,
     pub screenshot_requests: Vec<(u64, String)>,
     pub frame_ms: f64,
     pub render_ms: f64,
@@ -499,6 +646,18 @@ pub struct UiState {
     /// What FigCraft last put on the system clipboard: when the clipboard still holds it, a paste
     /// uses our copied layers; anything else there (an image, SVG, text) came from another app.
     pub last_copy: Option<String>,
+    /// Since the last V key release: whether its press arrived, and whether a paste event did
+    /// (`shortcuts::swallowed_paste`).
+    pub v_pressed: bool,
+    pub paste_event: bool,
+    /// The window got the focus back since the last V release.
+    pub refocused: bool,
+    /// A save shortcut pressed while a panel field had the keyboard: the field lets go (which
+    /// commits what was typed) and the command runs the next frame (`shortcuts::handle`).
+    pub after_field: Option<&'static str>,
+    /// The modifiers held, as of the last modifier change in the raw events: a paste event doesn't
+    /// carry them.
+    pub held: egui::Modifiers,
     /// When (UI clock, seconds) open documents next get an autosave checkpoint.
     pub next_autosave: f64,
     /// With auto-save on: when (UI clock, seconds) files with unsaved changes are next saved, and
@@ -522,6 +681,9 @@ pub struct UiState {
     pub online: online::OnlineUi,
     /// The window was asked to close with unsaved changes: the question shows.
     pub confirm_close: bool,
+    /// The file a Save as started from the unsaved-changes question is saving: the window closes
+    /// once it is saved, and stays open if the dialog is cancelled or the save fails.
+    pub close_after_save_as: Option<u64>,
 }
 
 impl Default for UiState {
@@ -533,15 +695,27 @@ impl Default for UiState {
             last_right_tab: RightTab::Design,
             left_tab: LeftTab::File,
             pages_open: true,
+            page_search: false,
+            page_filter: String::new(),
+            pages_height: None,
+            pages_seen_page: None,
             expanded: BTreeSet::new(),
             rename: None,
             rename_page: None,
+            rename_label: None,
             main_menu: false,
             palette: None,
+            palette_tab: menus::PaletteTab::All,
+            palette_hi: 0,
+            palette_armed: false,
+            actions_rect: None,
             variables: None,
             about: false,
             about_tab: dialogs::AboutTab::About,
             preferences: false,
+            menu_input: None,
+            rename_file: false,
+            ui_scale: ui_scale::plan(1.0, None, None),
             shortcuts_panel: false,
             shortcuts_tab: figcraft_engine::keymap::Group::Essential,
             shortcuts_query: String::new(),
@@ -552,6 +726,9 @@ impl Default for UiState {
             icon_gallery: false,
             toast: None,
             present: None,
+            presents: Vec::new(),
+            present_active: None,
+            present_next: 1,
             present_view: present::PresentView::default(),
             preview: None,
             picker: None,
@@ -562,13 +739,18 @@ impl Default for UiState {
             layer_filter: String::new(),
             layer_anchor: None,
             layers_focus: false,
+            pages_focus: None,
             layers_seen_sel: Vec::new(),
             dark: false,
             follow_system: false,
             tool_flyout: None,
+            board_panel: false,
             last_error: None,
             pending_opens: Vec::new(),
             pending_open_frames: 0,
+            import_report: None,
+            font_checks: Vec::new(),
+            missing_fonts: None,
             screenshot_requests: Vec::new(),
             frame_ms: 0.0,
             render_ms: 0.0,
@@ -592,6 +774,11 @@ impl Default for UiState {
             dev: dev_mode::DevUi::default(),
 
             last_copy: None,
+            v_pressed: false,
+            paste_event: false,
+            refocused: false,
+            after_field: None,
+            held: egui::Modifiers::NONE,
             next_autosave: 0.0,
             auto_save_at: None,
             auto_saving: Vec::new(),
@@ -603,6 +790,7 @@ impl Default for UiState {
             live: live::LiveUi::default(),
             online: online::OnlineUi::default(),
             confirm_close: false,
+            close_after_save_as: None,
         }
     }
 }
@@ -642,6 +830,9 @@ pub struct FigApp {
     pending_dialog: Option<PendingDialog>,
     /// The latest UI context schedules the first poll and wakes the app when a dialog completes.
     ui_context: Option<egui::Context>,
+    /// The automation roots the app was started with: every frame and control request runs
+    /// confined to them ([`windows::guard`]).
+    pub automation_roots: Option<Arc<figcraft_engine::file_access::Roots>>,
 }
 
 /// What to do with the result of a command run in the background.
@@ -651,8 +842,9 @@ impl FigApp {
     pub fn new(session: Session, services: Box<dyn Services>) -> Self {
         // The main window's panels open as wide as they were left.
         let (left_width, right_width) = session.prefs.panel_widths;
+        let pages_height = session.prefs.pages_height;
         Self {
-            ui: UiState { left_width, right_width, ..UiState::default() },
+            ui: UiState { left_width, right_width, pages_height, ..UiState::default() },
             session,
             canvas: canvas::CanvasState::default(),
             services,
@@ -671,20 +863,45 @@ impl FigApp {
             waiting: Vec::new(),
             pending_dialog: None,
             ui_context: None,
+            automation_roots: None,
+        }
+    }
+
+    /// Dismiss the composer after a successful switch away from the Comment tool.
+    pub(crate) fn clear_comment_draft_after_tool_set(&mut self, id: &str, succeeded: bool) {
+        if id == "tool.set" && succeeded && self.session.tool.tool != figcraft_engine::tools::ToolId::Comment {
+            self.ui.comments.draft = None;
         }
     }
 
     /// Run a command, surfacing errors as a toast. Returns the result.
     pub fn run(&mut self, id: &str, params: Value) -> Option<Value> {
         let r = self.session.execute(id, &params);
+        self.clear_comment_draft_after_tool_set(id, r.is_ok());
         self.handle_ui_requests();
         r.map_err(|e| self.failed(id, &e)).ok()
     }
 
+    /// [`run`](Self::run) for something the user did (a dialog, a drop, a paste, a recent file):
+    /// a file it imports shows its import report. Programmatic calls use `run` and never open one.
+    pub fn run_user(&mut self, id: &str, params: Value) -> Option<Value> {
+        let result = self.run(id, params.clone());
+        if let Some(result) = &result {
+            import_report::capture(self, id, &params, result);
+        }
+        missing_fonts::check_later(self, id, result.as_ref());
+        result
+    }
+
     /// Show command `id`'s error.
     fn failed(&mut self, id: &str, e: &figcraft_engine::EngineError) {
         let msg = e.to_string();
         log::warn!("{id}: {msg}");
+        self.show_error(msg);
+    }
+
+    /// Show an error as a toast, kept as the last error.
+    pub(crate) fn show_error(&mut self, msg: String) {
         self.toast(msg.clone());
         self.ui.last_error = Some(msg);
     }
@@ -724,7 +941,7 @@ impl FigApp {
     }
 
     /// Show what `command params` would do on the canvas as a live preview (`text.preview`) while
-    /// a text style, a named instance or an axis slider is hovered or dragged. Call it every frame
+    /// a font family, font style, text style, named instance or axis slider is hovered or dragged. Call it every frame
     /// the preview should stay: it ends on the first frame nothing asks for it.
     pub fn preview_text(&mut self, ctx: &egui::Context, command: &str, params: Value) {
         self.ui.text_preview_wanted = true;
@@ -751,6 +968,22 @@ impl FigApp {
         }
     }
 
+    /// Dev Mode (the Inspect tab): the canvas measures on hover without Alt and edits nothing;
+    /// entering it ends editing text or vectors.
+    fn sync_dev_mode(&mut self) {
+        let dev = self.ui.right_tab == RightTab::Inspect;
+        if dev && !self.session.tool.dev_mode {
+            let _ = self.session.drop_gesture();
+            let editing = self.session.ds().map(|d| (d.text_edit.is_some(), d.vector_edit.is_some())).unwrap_or_default();
+            for (on, cmd) in [(editing.0, "text.edit.end"), (editing.1, "vector.edit.end")] {
+                if on {
+                    self.run(cmd, json!({}));
+                }
+            }
+        }
+        self.session.tool.dev_mode = dev;
+    }
+
     /// Leaving Design ends a pen path as Escape does and goes back to Move: Prototype and Inspect
     /// don't draw (#307). Checked as the frame starts (the control channel) and after the panels
     /// and shortcuts (the mode switcher, the tabs, Shift+E/Shift+D), before the canvas sees more.
@@ -792,9 +1025,18 @@ impl FigApp {
                     self.ui.about_tab = dialogs::AboutTab::About;
                 }
                 "dialog.preferences" => self.ui.preferences = true,
+                "dialog.missingFonts" => missing_fonts::request(self),
                 "panel.shortcuts" => self.ui.shortcuts_panel = !self.ui.shortcuts_panel,
-                "palette.actions" => self.ui.palette = Some(String::new()),
+                "palette.actions" => menus::toggle_palette(&mut self.ui),
+                "panel.design" if self.session.doc().is_ok_and(figcraft_engine::board::is_board) => self.ui.board_panel = !self.ui.board_panel,
                 "panel.design" => self.ui.right_tab = RightTab::Design,
+                "board.editText" => {
+                    if let Some(id) = r.data.get("id").and_then(figcraft_engine::params::id_of)
+                        && let Err(e) = figcraft_engine::board::edit_text(&mut self.session, id)
+                    {
+                        self.toast(e.to_string());
+                    }
+                }
                 "panel.prototype" => self.ui.right_tab = RightTab::Prototype,
                 "panel.designPrototype" => {
                     self.ui.right_tab = if self.ui.right_tab == RightTab::Prototype { RightTab::Design } else { RightTab::Prototype };
@@ -815,10 +1057,14 @@ impl FigApp {
                 }
                 "focus.region" => self.ui.nav.step(r.data.get("step").and_then(Value::as_i64).unwrap_or(1).clamp(-4, 4) as i32),
                 "panel.layers" => self.ui.left_tab = LeftTab::File,
-                "panel.assets" => self.ui.left_tab = LeftTab::Assets,
+                "panel.assets" => {
+                    self.ui.left_tab = LeftTab::Assets;
+                    self.ui.left_collapsed = false;
+                    self.ui.versions = Default::default();
+                }
                 "panel.versionHistory" => versions::open(self),
                 "view.devCompare" => {
-                    self.ui.dev.compare = r.data.get("id").and_then(figcraft_engine::params::id_of).map(dev_compare::CompareView::new);
+                    self.ui.dev.compare = dev_compare::CompareView::requested(&r.data);
                 }
                 "panel.libraries" => {
                     self.ui.left_tab = LeftTab::Assets;
@@ -839,9 +1085,7 @@ impl FigApp {
                 "dialog.colorProfile" => self.ui.color_profile = self.session.doc().ok().map(|d| d.color_profile),
                 "present" => {
                     if let Some(start) = r.data.get("start").and_then(figcraft_engine::params::id_of) {
-                        let mut p = present::Presenter::new(start);
-                        p.view = self.ui.present_view;
-                        self.ui.present = Some(p);
+                        tabs::open_present(self, start);
                     }
                 }
                 "present.options" => {
@@ -875,6 +1119,9 @@ impl FigApp {
                 "layers.collapseAll" => layers::collapse_all(self),
                 "contextMenu" => self.ui.key_menu = true,
                 "selectArea" => self.start_key_box(),
+                "canvas.renameLabel" => {
+                    self.ui.rename_label = r.data.get("id").and_then(figcraft_engine::params::id_of).map(|id| layers::Rename { id, start: true });
+                }
                 "layers.rename" => {
                     let ids: Vec<NodeId> =
                         r.data.get("ids").and_then(Value::as_array).into_iter().flatten().filter_map(figcraft_engine::params::id_of).collect();
@@ -926,7 +1173,7 @@ impl FigApp {
         let resp = ui.interact(rect, id, egui::Sense::click_and_drag());
         if resp.hovered() || resp.dragged() {
             ui.ctx().set_cursor_icon(egui::CursorIcon::ResizeHorizontal);
-            ui.painter().vline(x, rows, egui::Stroke::new(2.0, theme::Tokens::get(ui.ctx()).accent));
+            ui.painter().vline(x, rows, egui::Stroke::new(2.0, theme::ACCENT));
         }
         if resp.double_clicked() {
             return Some(PANEL_DEFAULT);
@@ -943,11 +1190,31 @@ impl FigApp {
     }
 
     pub fn save_as_dialog(&mut self) {
-        let name = self.session.doc().map(|d| d.name.clone()).unwrap_or_else(|_| "Untitled".into());
-        self.pick_save(i18n::tr("Save as"), &format!("{name}.figcraft"), &["figcraft"], |app, p| {
-            let ps = p.to_string_lossy().to_string();
-            if app.run("file.saveAs", json!({"path": ps})).is_some() {
-                app.toast(i18n::trf("Saved {name}", &[("name", &p.file_name().map(|f| f.to_string_lossy().to_string()).unwrap_or_default())]));
+        let Ok(name) = self.session.doc().map(|d| d.name.clone()) else { return };
+        self.pick_save(i18n::tr("Save as"), &format!("{name}.figcraft"), &["figcraft", "fig"], |app, mut p| {
+            if p.extension().is_none_or(|e| e.is_empty()) {
+                if !p.set_extension("figcraft") {
+                    app.toast(i18n::tr("Use the .figcraft or .fig extension."));
+                    return;
+                }
+                // This name wasn't confirmed by the system dialog: don't replace an existing file.
+                match p.try_exists() {
+                    Ok(false) => {}
+                    Ok(true) => {
+                        app.toast(i18n::tr("A .figcraft file with this name already exists. Choose its full name to confirm replacement."));
+                        return;
+                    }
+                    Err(e) => {
+                        app.toast(e.to_string());
+                        return;
+                    }
+                }
+            } else if !p.extension().and_then(|e| e.to_str()).is_some_and(|e| e.eq_ignore_ascii_case("figcraft") || e.eq_ignore_ascii_case("fig")) {
+                app.toast(i18n::tr("Use the .figcraft or .fig extension."));
+                return;
+            }
+            if let Some(r) = app.run("file.saveAs", json!({"path": p.to_string_lossy()})) {
+                dialogs::file_saved(app, &r);
             }
         });
     }
@@ -955,7 +1222,14 @@ impl FigApp {
     pub fn save(&mut self) {
         // A branch tab saves its main file.
         let tab = figcraft_engine::branches::file_tab(&self.session);
-        if self.session.docs.get(tab).is_some_and(|d| d.path.is_some()) {
+        // A path ending in .fig is never saved over silently: a .fig destination is an export copy.
+        let native_path = self
+            .session
+            .docs
+            .get(tab)
+            .and_then(|d| d.path.as_deref())
+            .is_some_and(|path| !Path::new(path).extension().and_then(|e| e.to_str()).is_some_and(|e| e.eq_ignore_ascii_case("fig")));
+        if native_path {
             if self.run("file.save", json!({})).is_some() {
                 self.toast(i18n::tr("Saved"));
             }
@@ -966,16 +1240,11 @@ impl FigApp {
 
     pub fn open_dialog(&mut self) {
         // Opening needs no file in front: it goes ahead even if that file closed meanwhile.
-        self.start_dialog(
-            |services| services.pick_open(i18n::tr("Open"), OPEN_EXTENSIONS),
-            false,
-            |app, p| {
-                let ps = p.to_string_lossy().to_string();
-                if app.run("file.open", json!({"path": ps})).is_some() {
-                    app.ui.home = false;
-                }
-            },
-        );
+        self.pick_file(i18n::tr("Open"), OPEN_EXTENSIONS, false, |app, file| {
+            if app.run_user("file.open", file).is_some() {
+                app.ui.home = false;
+            }
+        });
     }
 
     pub fn import_dialog(&mut self, place: bool) {
@@ -985,12 +1254,35 @@ impl FigApp {
             &["svg", "png", "jpg", "jpeg", "webp", "gif", "tif", "tiff", "figcraft", "fig"]
         };
         let title = if place { i18n::tr("Place image") } else { i18n::tr("Import") };
-        self.pick_open(title, exts, move |app, p| {
-            let ps = p.to_string_lossy().to_string();
-            app.run("file.import", json!({"path": ps}));
+        self.pick_file(title, exts, true, |app, file| {
+            app.run_user("file.import", file);
         });
     }
 
+    /// Pick a file to open or import; `done` gets it as `file.open` and `file.import` take it (a
+    /// path, or the name and contents where the platform has no paths). `pin`: as
+    /// [`FigApp::pick_open`]'s file in front.
+    fn pick_file(&mut self, title: &str, exts: &[&str], pin: bool, done: impl FnOnce(&mut FigApp, Value) + 'static) {
+        self.start_pick(
+            |services| -> PickFuture {
+                match services.pick_open_contents(title, exts) {
+                    Some(read) => {
+                        Box::pin(async move { read.await.map(|r| r.map_or_else(Picked::Unreadable, |(name, bytes)| Picked::Contents(name, bytes))) })
+                    }
+                    None => {
+                        let pick = services.pick_open(title, exts);
+                        Box::pin(async move { pick.await.map(Picked::Path) })
+                    }
+                }
+            },
+            pin,
+            move |app, picked| match picked.file_params() {
+                Ok(file) => done(app, file),
+                Err(why) => app.show_error(why),
+            },
+        );
+    }
+
     /// Pick a file to open. `done` runs with the file in front now back in front (and not at all
     /// if that file closed meanwhile).
     pub fn pick_open(&mut self, title: &str, exts: &[&str], done: impl FnOnce(&mut FigApp, PathBuf) + 'static) {
@@ -1009,12 +1301,28 @@ impl FigApp {
 
     /// Open a native dialog from the window drawing now, for the file in front (`pin`).
     fn start_dialog(&mut self, start: impl FnOnce(&mut dyn Services) -> DialogFuture, pin: bool, done: impl FnOnce(&mut FigApp, PathBuf) + 'static) {
+        self.start_pick(
+            |services| -> PickFuture {
+                let pick = start(services);
+                Box::pin(async move { pick.await.map(Picked::Path) })
+            },
+            pin,
+            move |app, picked| {
+                if let Picked::Path(p) = picked {
+                    done(app, p);
+                }
+            },
+        );
+    }
+
+    /// [`FigApp::start_dialog`] for any kind of pick.
+    fn start_pick(&mut self, start: impl FnOnce(&mut dyn Services) -> PickFuture, pin: bool, done: impl FnOnce(&mut FigApp, Picked) + 'static) {
         if self.pending_dialog.is_some() {
             return;
         }
         let doc = if pin { self.session.ds().ok().filter(|d| self.shows(d.uid)).map(|d| d.uid) } else { None };
         let future = start(self.services.as_mut());
-        self.pending_dialog = Some(PendingDialog { future, path: None, done: Box::new(done), doc, window: self.windows.current });
+        self.pending_dialog = Some(PendingDialog { future, picked: None, done: Box::new(done), doc, window: self.windows.current });
         if let Some(ctx) = &self.ui_context {
             ctx.request_repaint();
         }
@@ -1024,12 +1332,12 @@ impl FigApp {
     /// that file in front; then the tab in front before comes back (unless the dialog opened a file).
     fn poll_dialog(&mut self, ctx: &egui::Context) {
         let Some(d) = &mut self.pending_dialog else { return };
-        if d.path.is_none() {
+        if d.picked.is_none() {
             let waker = Waker::from(Arc::new(RepaintWaker(ctx.clone())));
-            let Poll::Ready(path) = d.future.as_mut().poll(&mut TaskContext::from_waker(&waker)) else { return };
-            d.path = path;
+            let Poll::Ready(picked) = d.future.as_mut().poll(&mut TaskContext::from_waker(&waker)) else { return };
+            d.picked = picked;
         }
-        let (doc, origin, picked) = (d.doc, d.window, d.path.is_some());
+        let (doc, origin, picked) = (d.doc, d.window, d.picked.is_some());
         let index = doc.map(|u| self.session.docs.iter().position(|ds| ds.uid == u));
         // Cancelled, or its file closed meanwhile.
         if !picked || index == Some(None) {
@@ -1045,12 +1353,12 @@ impl FigApp {
             ctx.request_repaint_of(windows::viewport(window));
             return;
         }
-        let Some(PendingDialog { path: Some(path), done, .. }) = self.pending_dialog.take() else { return };
+        let Some(PendingDialog { picked: Some(picked), done, .. }) = self.pending_dialog.take() else { return };
         let before = self.session.ds().ok().map(|d| d.uid);
         if let Some(Some(i)) = index {
             self.session.active = i;
         }
-        done(self, path);
+        done(self, picked);
         if doc.is_some()
             && self.session.ds().ok().map(|d| d.uid) == doc
             && let Some(i) = before.and_then(|u| self.session.docs.iter().position(|d| d.uid == u))
@@ -1064,11 +1372,11 @@ impl FigApp {
         self.session.prefs.reduce_motion || self.services.reduce_motion()
     }
 
-    /// The CJK scripts the UI shows: the language's, the language picker's (Preferences open),
+    /// The CJK and Bengali scripts the UI shows: the language's, the language picker's (Preferences open),
     /// typed text's, and those in the open file's names and comments (read when it changes, not
     /// mid-drag). Nothing is checked once every script has a face.
     fn cjk_needed(&mut self, ctx: &egui::Context, installed: u8) -> u8 {
-        if installed == cjk::KANA | cjk::HANGUL | cjk::HAN {
+        if installed == cjk::ALL {
             return installed;
         }
         let mut need = i18n::current().map_or(0, |l| cjk::language(l.code));
@@ -1128,6 +1436,16 @@ impl FigApp {
                 theme::install_fonts(ctx, true, cjk);
             }
         }
+        // egui's zoom is for the whole app and multiplies each window's own system scale, so the
+        // size is the same relative to every screen; the main window, whose size can hold a size
+        // back, sets it. The browser keeps its own zoom.
+        if ctx.viewport_id() == egui::ViewportId::ROOT {
+            let window_px = ctx.content_rect().size() * ctx.pixels_per_point();
+            let size = if cfg!(target_arch = "wasm32") { 1.0 } else { self.session.prefs.ui_scale };
+            let plan = ui_scale::plan(size, ctx.native_pixels_per_point(), Some((window_px.x, window_px.y)));
+            ctx.set_zoom_factor(plan.zoom);
+            self.ui.ui_scale = plan;
+        }
         let dark = match self.session.prefs.theme.as_str() {
             "dark" => true,
             // The active visuals were set by us last frame (possibly for a manual theme). Read the
@@ -1258,10 +1576,12 @@ impl FigApp {
         // What happened in a live session (the network woke us for it).
         if self.session.live_poll() {
             if let Some(m) = self.session.message.take() {
-                self.toast(m);
+                self.toast(live::failure_text(&m));
             }
             self.background_done(&ctx);
         }
+        // Files that arrived without a command (joined, recovered) take the kept View toggles too.
+        self.session.apply_view_prefs();
         windows::begin(self, &ctx);
         let (files, prefs) = (self.session.docs.len(), self.session.prefs.clone());
         self.frame(ui);
@@ -1281,6 +1601,16 @@ impl FigApp {
         }
     }
 
+    /// Whether the right panel shows: never with the UI `hidden`; always on a design file; on a
+    /// board, which has no prototypes or Dev Mode (its tab stays Design), only when asked for.
+    fn right_panel_shown(&mut self, hidden: bool) -> bool {
+        let board = self.session.doc().is_ok_and(figcraft_engine::board::is_board);
+        if board {
+            self.ui.right_tab = RightTab::Design;
+        }
+        !hidden && (!board || self.ui.board_panel)
+    }
+
     /// One frame of the window drawing now.
     pub(crate) fn frame(&mut self, ui: &mut egui::Ui) {
         let ctx = ui.ctx().clone();
@@ -1289,11 +1619,13 @@ impl FigApp {
         // even if it lets go during the frame (Enter commits it), or as it began (egui drops the
         // focus on Escape before the frame, which cancels the field's edit and nothing else).
         let typing = std::mem::take(&mut self.field_focus) || a11y::field_focused(&ctx);
+        let swallowed = shortcuts::swallowed_paste(self, &ctx);
         // A dialog that closed acts first, in the window it was opened from.
         self.poll_dialog(&ctx);
         // Control requests run first so their results reflect this frame.
         control::drain(self, &ctx);
         windows::requests(self, &ctx);
+        selection_spacing::sync(self, &ctx);
         // Before any widget: the navigation keys (F6, Tab, arrows, Escape) move the keyboard.
         a11y::begin(self, &ctx);
         if self.ui.title_bar == TitleBar::Custom {
@@ -1304,18 +1636,26 @@ impl FigApp {
         }
         theme::set_doc_profile(&ctx, self.session.doc().map_or(figcraft_color::ColorProfile::Srgb, |d| d.color_profile));
         widgets::set_nudge(&ctx, self.session.prefs.nudge_small, self.session.prefs.nudge_big);
-        // The Inspect tab measures on hover without Alt.
-        self.session.tool.redlines = self.ui.right_tab == RightTab::Inspect;
+        self.sync_dev_mode();
         self.end_pen_outside_design();
+        tabs::relink_presents(self);
+        tabs::tab_bar(self, ui);
         if self.ui.present.is_some() {
+            // A close request can arrive while the presenter fills the window. Let its unsaved
+            // changes dialog take Escape and draw above the player just as it does in the editor.
+            dialogs::keys(self, &ctx);
             present::show(self, ui);
+            dialogs::show(self, &ctx);
             // What went wrong while presenting (a widget's plugin failing) shows over it.
             self.toast_ui(&ctx);
+            windows::requests(self, &ctx);
             return;
         }
         if !self.has_files() || self.ui.home {
-            tabs::tab_bar(self, ui);
             home::show(self, ui);
+            // The shortcuts panel belongs to the canvas; it doesn't hang over the home screen
+            // (cleared after the home widgets, which may have just asked for it).
+            self.ui.shortcuts_panel = false;
             dialogs::keys(self, &ctx);
             dialogs::show(self, &ctx);
             self.toast_ui(&ctx);
@@ -1323,7 +1663,7 @@ impl FigApp {
             return;
         }
         let hidden = self.session.ds().map(|d| d.view.ui_hidden).unwrap_or(false);
-        tabs::tab_bar(self, ui);
+        let right_open = self.right_panel_shown(hidden);
         if !hidden {
             egui::Panel::left("left_rail")
                 .exact_size(56.0)
@@ -1336,7 +1676,7 @@ impl FigApp {
         }
         // The panels are as wide as asked, less in a window too small for them and the canvas.
         let left_open = !hidden && !self.ui.left_collapsed;
-        let (left_w, right_w) = fit_panels(ui.available_width(), left_open.then_some(self.ui.left_width), self.ui.right_width);
+        let (left_w, right_w) = fit_panels(ui.available_width(), left_open.then_some(self.ui.left_width), right_open.then_some(self.ui.right_width));
         let rows = ui.available_rect_before_wrap().y_range();
         let mut edges: Vec<(&str, f32, f32, f32)> = Vec::new();
         if left_open {
@@ -1355,7 +1695,7 @@ impl FigApp {
                     layers::left_panel(self, ui)
                 });
         }
-        if !hidden {
+        if right_open {
             edges.push(("right", ui.available_rect_before_wrap().max.x - right_w, right_w, -1.0));
             egui::Panel::right("right_panel")
                 .resizable(false)
@@ -1404,7 +1744,7 @@ impl FigApp {
         branch_ui::keys(self, &ctx);
         live::dialog_keys(self, &ctx);
         dialogs::keys(self, &ctx);
-        shortcuts::handle(self, &ctx, typing);
+        shortcuts::handle(self, &ctx, typing, swallowed);
         menus::popups(self, &ctx);
         variable_ui::picker(self, &ctx);
         style_picker::show(self, &ctx);
@@ -1486,7 +1826,7 @@ impl FigApp {
             "focus": {"region": self.ui.nav.region.id(), "keyboard": self.ui.nav.keyboard},
             "reduceMotion": self.reduce_motion(),
             "presenting": self.ui.present.is_some(),
-            "presenter": self.ui.present.as_ref().map(present::Presenter::inspect),
+            "presenter": tabs::shown_or_paused(self).map(present::Presenter::inspect),
             "presentOptions": {"scale": self.ui.present_view.scale.id(), "deviceFrame": self.ui.present_view.device_frame, "comments": self.ui.present_view.comments, "hotspotHints": self.ui.present_view.hotspot_hints, "inspect": self.ui.present_view.inspect},
             "preview": self.ui.preview.as_ref().map(|p| p.player.inspect()),
             "mainMenu": self.ui.main_menu,
@@ -1494,7 +1834,7 @@ impl FigApp {
             "variables": self.ui.variables.is_some(),
             "versionHistory": self.ui.versions.open,
             "branchReview": self.ui.branch_review.as_ref().map(|r| json!({"id": r.id, "picks": r.picks, "mode": if r.mode == dev_compare::Mode::Overlay { "overlay" } else { "sideBySide" }})),
-            "devCompare": self.ui.dev.compare.as_ref().map(|c| json!({"id": c.id, "mode": if c.mode == dev_compare::Mode::Overlay { "overlay" } else { "sideBySide" }, "split": c.split})),
+            "devCompare": self.ui.dev.compare.as_ref().map(|c| json!({"id": c.id, "mode": if c.mode == dev_compare::Mode::Overlay { "overlay" } else { "sideBySide" }, "split": c.split, "version": c.version})),
             "devFocus": self.session.ds().ok().and_then(figcraft_engine::DocState::focused),
             "annotationFilter": self.ui.dev.categories.id(),
             "colorProfileDialog": self.ui.color_profile.map(|p| p.id()),
@@ -1533,8 +1873,14 @@ impl FigApp {
             "panels": {"left": self.ui.left_width, "right": self.ui.right_width, "leftCollapsed": self.ui.left_collapsed},
             "status": self.session.status(),
             "lastError": self.ui.last_error,
+            "importReport": self.ui.import_report.as_ref().map(import_report::Report::inspect),
         });
+        state["homeSearch"] = json!(self.ui.home_view.file_query);
+        // Set apart from the literal above, which is at the macro recursion limit.
+        state["uiScale"] = json!({"choice": self.session.prefs.ui_scale, "zoom": self.ui.ui_scale.zoom, "drawn": self.ui.ui_scale.drawn, "limited": self.ui.ui_scale.limited});
         state["pendingOpens"] = json!(self.ui.pending_opens.len());
+        state["missingFonts"] = json!(self.ui.missing_fonts.as_ref().map(missing_fonts::Shown::inspect));
+        state["presentTabs"] = tabs::present_tabs_inspect(self);
         state
     }
 }
@@ -1547,17 +1893,28 @@ pub(crate) fn opens(path: &Path) -> bool {
     path.extension().and_then(|e| e.to_str()).is_some_and(|e| OPEN_EXTENSIONS.iter().any(|x| x.eq_ignore_ascii_case(e)))
 }
 
-/// The contents of a dropped file that has no file on disk to read by path.
-#[cfg(not(target_arch = "wasm32"))]
-pub(crate) fn dropped_bytes(f: &egui::DroppedFileHandle) -> Option<Vec<u8>> {
-    f.bytes().ok()
+/// Whether `path` is a whole document (`.figcraft`, `.fig`, file JSON) rather than an image or SVG:
+/// dropped on the canvas it opens as a file of its own instead of adding its pages to the open one.
+pub(crate) fn is_document(path: &Path) -> bool {
+    path.extension().and_then(|e| e.to_str()).is_some_and(|e| ["figcraft", "fig", "json"].iter().any(|x| x.eq_ignore_ascii_case(e)))
 }
 
-/// The contents of a dropped file that has no file on disk to read by path.
+/// Reads the contents of dropped file `name` that has no file on disk to read by path.
+#[cfg(not(target_arch = "wasm32"))]
+pub(crate) fn dropped_bytes(f: &egui::DroppedFileHandle, name: &str) -> ReadFuture {
+    Box::pin(std::future::ready(f.bytes().map_err(|_| unreadable(name))))
+}
+
+/// Reads the contents of dropped file `name`; the browser hands them over asynchronously.
 #[cfg(target_arch = "wasm32")]
-pub(crate) fn dropped_bytes(_f: &egui::DroppedFileHandle) -> Option<Vec<u8>> {
-    // Browser drops arrive asynchronously; not supported yet.
-    None
+pub(crate) fn dropped_bytes(f: &egui::DroppedFileHandle, name: &str) -> ReadFuture {
+    let (f, name) = (f.clone(), name.to_string());
+    Box::pin(async move {
+        if let Some(file) = f.web_file() {
+            browser_can_read(&name, file.size())?;
+        }
+        f.bytes_async().await.map_err(|_| unreadable(&name))
+    })
 }
 
 /// While files are dragged over the window: a tinted, outlined `rect` with `label` in its middle,
@@ -1570,15 +1927,21 @@ pub(crate) fn drop_overlay(ctx: &egui::Context, rect: egui::Rect, label: &str) {
     let painter = ctx.layer_painter(egui::LayerId::new(egui::Order::Foreground, egui::Id::new("drop_overlay")));
     let area = rect.shrink(4.0);
     painter.rect_filled(area, egui::CornerRadius::same(8), t.accent.gamma_multiply(0.12));
-    painter.rect_stroke(area, egui::CornerRadius::same(8), egui::Stroke::new(2.0, t.accent), egui::StrokeKind::Inside);
+    painter.rect_stroke(area, egui::CornerRadius::same(8), egui::Stroke::new(2.0, theme::ACCENT), egui::StrokeKind::Inside);
     let galley = painter.layout_no_wrap(label.to_owned(), theme::semibold(14.0), t.text);
     let pill = egui::Rect::from_center_size(area.center(), galley.size() + egui::vec2(32.0, 16.0));
     painter.rect_filled(pill, egui::CornerRadius::same(8), t.panel);
-    painter.rect_stroke(pill, egui::CornerRadius::same(8), egui::Stroke::new(1.0, t.accent), egui::StrokeKind::Inside);
+    painter.rect_stroke(pill, egui::CornerRadius::same(8), egui::Stroke::new(1.0, theme::ACCENT), egui::StrokeKind::Inside);
     painter.galley(pill.center() - galley.size() / 2.0, galley, t.text);
     // Hovering sends no pointer events on every platform: keep the overlay current.
     ctx.request_repaint();
 }
 
+#[cfg(test)]
+mod selection_spacing_tests;
+
+#[cfg(test)]
+mod type_settings_tests;
+
 #[cfg(test)]
 mod typography_scrub_tests;
diff --git a/crates/ui-egui/src/live.rs b/crates/ui-egui/src/live.rs
index 35af5d14a..a4baa3034 100644
--- a/crates/ui-egui/src/live.rs
+++ b/crates/ui-egui/src/live.rs
@@ -13,10 +13,11 @@
 //! and it fades a few seconds after the last change (frames are asked for only until then).
 //! Spotlight: your avatar's menu asks everyone to follow you; a banner says so and stops it.
 
+use std::borrow::Cow;
 use std::collections::BTreeMap;
 
 use egui::{Align2, Color32, CornerRadius, Pos2, Rect, Sense, Shape, Stroke, Ui, pos2, vec2};
-use figcraft_engine::live::{Access, PEOPLE, Role, SessionId, Share, Signal, Status, Via, initials, parse_color, presence_page};
+use figcraft_engine::live::{Access, PEOPLE, Role, SessionId, Share, Signal, Status, TOO_LARGE_TO_JOIN, Via, initials, parse_color, presence_page};
 use serde_json::{Value, json};
 
 use crate::FigApp;
@@ -595,7 +596,7 @@ pub fn share_popover(app: &mut FigApp, anchor: &egui::Response) {
                 (Status::Reconnecting { attempt }, _) => {
                     (trf("Connection lost, reconnecting (attempt {attempt})…", &[("attempt", attempt)]), t.text_secondary)
                 }
-                (Status::Failed { .. }, _) => (status.label(), t.danger),
+                (Status::Failed { reason }, _) => (failure_text(reason).into_owned(), t.danger),
                 _ => (tr(&status.label()).to_string(), t.text_secondary),
             };
             if !line.is_empty() {
@@ -695,11 +696,18 @@ pub fn join_field(app: &mut FigApp, ui: &mut Ui, typed: &mut String, id: egui::I
 pub fn join_status(app: &FigApp, ui: &mut Ui, t: &Tokens, session: SessionId) {
     match app.session.live.get(session).map(|l| &l.status) {
         Some(Status::Connecting) => widgets::label(ui, tr("Joining…"), t.text_secondary),
-        Some(Status::Failed { reason }) => widgets::label(ui, reason, t.danger),
+        Some(Status::Failed { reason }) => widgets::label(ui, &failure_text(reason), t.danger),
         _ => {}
     }
 }
 
+/// Why a live session failed, in the UI language when it is a reason the UI knows (the transport's
+/// English otherwise).
+pub(crate) fn failure_text(reason: &str) -> Cow<'_, str> {
+    let mb = TOO_LARGE_TO_JOIN.split_once("{mb}").and_then(|(before, after)| reason.strip_prefix(before)?.strip_suffix(after));
+    mb.map_or(Cow::Borrowed(reason), |mb| Cow::Owned(trf(TOO_LARGE_TO_JOIN, &[("mb", &mb)])))
+}
+
 /// Not in a session: your name, how to share (online or on the local network), start; or join
 /// one with a code. Everything else is under Advanced.
 fn start_ui(app: &mut FigApp, ui: &mut Ui, t: &Tokens) {
@@ -1047,12 +1055,14 @@ pub fn open_join(app: &mut FigApp, link: &str) {
     app.ui.live.focus_join = true;
 }
 
-/// An invite link the app was opened with (`figcraft figcraft://join?…`): join at once; a link
-/// that can't be used shows in the Join dialog with the reason.
+/// An invite link the app was opened with (`figcraft figcraft://join?…`): the Join dialog opens
+/// with the link filled in, so joining is the person's own choice.
+///
+/// The system hands the app any `figcraft://` link that is followed, which may be a page, a
+/// message or a document rather than something the person meant to act on, so the link is shown
+/// and confirmed rather than acted on.
 pub fn open_invite(app: &mut FigApp, link: &str) {
-    if app.run("collab.join", json!({"link": link.trim()})).is_none() {
-        open_join(app, link.trim());
-    }
+    open_join(app, link.trim());
 }
 
 /// Escape closes the Join or Publish dialog (before the canvas's shortcuts see it: it doesn't
diff --git a/crates/ui-egui/src/live_join_tests.rs b/crates/ui-egui/src/live_join_tests.rs
index d74521638..61567ce0d 100644
--- a/crates/ui-egui/src/live_join_tests.rs
+++ b/crates/ui-egui/src/live_join_tests.rs
@@ -47,12 +47,14 @@ fn escape_closes_the_join_dialog_and_keeps_the_selection() {
 }
 
 #[test]
-fn opening_the_app_with_an_invite_link_joins() {
+fn opening_the_app_with_an_invite_link_asks_before_joining() {
     let (mut h, _) = Harness::new();
     let link = "figcraft://join?host=127.0.0.1:47900&file=abc&token=AbCdEfGhIjKlMnOpQrStUv";
     crate::live::open_invite(&mut h.app, &format!(" {link} "));
-    assert_eq!(h.app.session.live().status, Status::Connecting);
-    assert!(h.app.ui.live.join.is_none(), "no dialog: it joins at once");
+    // The system hands the app whatever `figcraft://` link was followed, which may come from a
+    // page or a message, so the link is shown and confirmed rather than acted on.
+    assert_eq!(h.app.ui.live.join.as_deref(), Some(link), "the dialog opens with the link filled in");
+    assert_eq!(h.app.session.live().status, Status::Off, "nothing is joined until the person confirms");
 }
 
 /// The browser's link: joins, can't host; joining fails here to show the dialog path.
@@ -82,7 +84,8 @@ fn a_link_that_cant_be_used_opens_the_dialog_with_it() {
     h.app.session.live.install(Box::new(Browser));
     crate::live::open_invite(&mut h.app, "figcraft://nope");
     assert_eq!(h.app.ui.live.join.as_deref(), Some("figcraft://nope"), "the link stays in the field to fix");
-    assert!(h.app.ui.last_error.as_deref().is_some_and(|e| e.contains("not a live session invite")));
+    // The link is not tried until the person presses Join, so its reason shows then, not now.
+    assert!(h.app.ui.last_error.is_none());
     assert_eq!(h.app.session.live().status, Status::Off);
 }
 
diff --git a/crates/ui-egui/src/live_server_tests.rs b/crates/ui-egui/src/live_server_tests.rs
index 9c2cb22ce..4a92edf0a 100644
--- a/crates/ui-egui/src/live_server_tests.rs
+++ b/crates/ui-egui/src/live_server_tests.rs
@@ -25,7 +25,7 @@ fn focused(h: &Harness, id: &str) -> bool {
 }
 
 /// Joined through a server's link with `access`: the welcome and the document (a new tab).
-fn joined(h: &mut Harness, access: Access) {
+pub(crate) fn joined(h: &mut Harness, access: Access) {
     h.app.session.execute("collab.join", &json!({"link": "figcraft://join?host=127.0.0.1:47900&file=f&token=AbCdEfGhIjKlMnOpQrStUv"})).unwrap();
     let mut server = Server::new(h.app.session.doc().unwrap().clone(), "", Limits::default());
     let ClientMsg::Hello(me) = Client::hello("f", "", "Ada", "") else { panic!("no hello") };
diff --git a/crates/ui-egui/src/measure_nudge_tests.rs b/crates/ui-egui/src/measure_nudge_tests.rs
new file mode 100644
index 000000000..b4a5a2475
--- /dev/null
+++ b/crates/ui-egui/src/measure_nudge_tests.rs
@@ -0,0 +1,64 @@
+//! Nudging while measuring (#894), driven through egui headless: with Alt held over another layer
+//! the arrows still nudge the selection (Shift: the big step), the distance follows every nudge,
+//! and the selection's handles and size label hide while measuring (its outline stays).
+
+use egui::{Event, Key, Modifiers, Pos2, Shape};
+use figcraft_doc::NodeId;
+use figcraft_engine::Session;
+use serde_json::json;
+
+use crate::layers_drag_tests::Ui;
+use crate::live_tests::flat;
+use crate::present_tests::id;
+
+fn labels(u: &Ui) -> Vec<String> {
+    u.app.session.tool.overlay.guides.iter().filter_map(|g| g.label.clone()).collect()
+}
+
+fn top(u: &Ui, i: NodeId) -> f64 {
+    u.app.session.doc().unwrap().world_bounds(i).unwrap().y0
+}
+
+/// Press and release `key` with `m` held, then a settled frame (the pointer still over the canvas).
+fn press(u: &mut Ui, key: Key, m: Modifiers, at: Pos2) {
+    let ev = |pressed| Event::Key { key, physical_key: None, pressed, repeat: false, modifiers: m };
+    u.frame_with(vec![ev(true), ev(false)], m);
+    u.frame_with(vec![Event::PointerMoved(at)], m);
+}
+
+/// Whether the frame drew corner handles or a text `label`.
+fn drew(shapes: &[Shape], label: &str) -> (bool, bool) {
+    let handle = shapes.iter().any(|s| matches!(s, Shape::Rect(r) if (r.rect.width() - 8.0).abs() < 0.1 && (r.rect.height() - 8.0).abs() < 0.1));
+    let text = shapes.iter().any(|s| matches!(s, Shape::Text(t) if t.galley.text() == label));
+    (handle, text)
+}
+
+#[test]
+fn arrows_nudge_while_measuring_and_the_distance_follows() {
+    let mut s = Session::new();
+    let upper = id(&s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 100, "height": 40})).unwrap());
+    let lower = id(&s.execute("shape.rectangle", &json!({"x": 0, "y": 140, "width": 100, "height": 40})).unwrap());
+    s.execute("select.set", &json!({"ids": [lower]})).unwrap();
+    let mut u = Ui::new(s);
+    let over = u.app.to_screen(50.0, 20.0);
+    let (alt, shift_alt) = (Modifiers { alt: true, ..Modifiers::NONE }, Modifiers { alt: true, shift: true, ..Modifiers::NONE });
+
+    // Not measuring: the selection shows its handles and size.
+    let shapes = flat(&u.frame_with(vec![Event::PointerMoved(over)], Modifiers::NONE).shapes);
+    assert_eq!(drew(&shapes, "100 × 40"), (true, true), "handles and size label show");
+
+    u.frame_with(vec![Event::PointerMoved(over)], alt);
+    let shapes = flat(&u.frame_with(vec![Event::PointerMoved(over)], alt).shapes);
+    assert!(u.app.session.tool.overlay.measure_box.is_some(), "Alt over the other layer measures to it");
+    assert!(labels(&u).contains(&"100".to_string()), "the gap: {:?}", labels(&u));
+    assert_eq!(drew(&shapes, "100 × 40"), (false, false), "measuring hides the handles and size label");
+
+    press(&mut u, Key::ArrowUp, alt, over);
+    assert_eq!(top(&u, lower), 139.0, "Alt+Up nudges by the small step");
+    assert!(labels(&u).contains(&"99".to_string()), "the gap follows the nudge: {:?}", labels(&u));
+
+    press(&mut u, Key::ArrowUp, shift_alt, over);
+    assert_eq!(top(&u, lower), 129.0, "Shift+Alt+Up nudges by the big step");
+    assert!(labels(&u).contains(&"89".to_string()), "the gap follows the big nudge: {:?}", labels(&u));
+    assert_eq!(top(&u, upper), 0.0, "the measured layer stays put");
+}
diff --git a/crates/ui-egui/src/menu_aim_tests.rs b/crates/ui-egui/src/menu_aim_tests.rs
new file mode 100644
index 000000000..5e2fe0762
--- /dev/null
+++ b/crates/ui-egui/src/menu_aim_tests.rs
@@ -0,0 +1,281 @@
+//! Which submenu the main and context menus show, driven through egui headless: a closed menu
+//! reopens with no submenu open (also one level down), hovering another row closes the open
+//! submenu at once while a submenu opens only once the pointer stays on its row a moment
+//! (sweeping across rows doesn't flash each one), and on the way from a
+//! submenu's row to its submenu the rows the pointer crosses don't take over (the safe triangle),
+//! unless it rests on one or turns away.
+
+use egui::{Event, Id, LayerId, Order, Pos2, RawInput, Rect, pos2, vec2};
+use figcraft_engine::Session;
+
+use crate::menus::{AIM_REST, HOVER_DELAY, heading_for, in_triangle, main_menu_id};
+use crate::{FigApp, NoServices};
+
+const SIZE: egui::Vec2 = vec2(1440.0, 900.0);
+const ROW: f32 = 28.0;
+
+struct Ui {
+    ctx: egui::Context,
+    app: FigApp,
+    time: f64,
+}
+
+impl Ui {
+    fn new() -> Self {
+        let app = FigApp::new(Session::new(), Box::new(NoServices));
+        let mut u = Self { ctx: egui::Context::default(), app, time: 0.0 };
+        for _ in 0..3 {
+            u.frame(vec![]);
+        }
+        u
+    }
+
+    fn frame(&mut self, events: Vec<Event>) {
+        self.time += 1.0 / 60.0;
+        let input = RawInput { screen_rect: Some(Rect::from_min_size(Pos2::ZERO, SIZE)), time: Some(self.time), events, ..Default::default() };
+        let app = &mut self.app;
+        let mut out = self.ctx.run_ui(input, |ui| app.ui(ui));
+        out.textures_delta.clear();
+    }
+
+    fn hover(&mut self, p: Pos2) {
+        self.frame(vec![Event::PointerMoved(p)]);
+    }
+
+    /// Hover `p` and stay there until a submenu could open.
+    fn settle(&mut self, p: Pos2) {
+        self.hover(p);
+        self.wait(HOVER_DELAY + 0.05);
+    }
+
+    /// Frames without input for `secs`.
+    fn wait(&mut self, secs: f64) {
+        let until = self.time + secs;
+        while self.time < until {
+            self.frame(vec![]);
+        }
+    }
+
+    fn open_main_menu(&mut self) {
+        self.app.ui.main_menu = true;
+        // Somewhere off the menu: nothing hovered.
+        self.hover(pos2(900.0, 700.0));
+        self.frame(vec![]);
+    }
+
+    fn shown(&self, area: Id) -> bool {
+        self.ctx.memory(|m| m.areas().visible_layer_ids().contains(&LayerId::new(Order::Foreground, area)))
+    }
+
+    fn rect(&self, area: Id) -> Rect {
+        self.ctx.memory(|m| m.area_rect(area)).expect("area drawn")
+    }
+
+    /// The main menu's row for top-level menu `i` (File 0, Edit 1, View 2, …).
+    fn top_row(&self, i: usize) -> Rect {
+        let m = self.rect(main_menu_id());
+        // Frame margin, the Actions row and the space under it.
+        let y = m.min.y + 8.0 + 30.0 + 6.0 + ROW * i as f32;
+        Rect::from_min_max(pos2(m.min.x + 8.0, y), pos2(m.max.x - 8.0, y + ROW))
+    }
+
+    /// Which top-level menus' panels show.
+    fn tops_shown(&self) -> Vec<&'static str> {
+        TOPS.iter().copied().filter(|t| self.shown(top(t))).collect()
+    }
+}
+
+const TOPS: [&str; 6] = ["File", "Edit", "View", "Object", "Text", "Arrange"];
+
+fn top(name: &str) -> Id {
+    Id::new(("menu", name))
+}
+
+/// The submenus of top-level menu `menu` (their keys), from the menu catalog.
+fn submenu_keys(menu: &str) -> Vec<String> {
+    let mut keys: Vec<String> = figcraft_engine::catalog::MENU
+        .iter()
+        .filter_map(|m| m.menu.strip_prefix(menu).and_then(|r| r.strip_prefix('/')).map(|r| format!("{menu}/{}", r.split('/').next().unwrap_or(r))))
+        .collect();
+    keys.extend(figcraft_engine::catalog::MENU.iter().filter(|m| m.menu == menu && m.id == "file.openRecent").map(|m| format!("{menu}/{}", m.label)));
+    keys.dedup();
+    keys
+}
+
+#[test]
+fn the_triangle_takes_the_pointer_from_the_row_toward_the_panel() {
+    let panel = Rect::from_min_max(pos2(300.0, 50.0), pos2(500.0, 650.0));
+    let from = pos2(250.0, 100.0);
+    assert!(in_triangle(pos2(1.0, 1.0), pos2(0.0, 0.0), pos2(4.0, 0.0), pos2(0.0, 4.0)));
+    assert!(!in_triangle(pos2(3.0, 3.0), pos2(0.0, 0.0), pos2(4.0, 0.0), pos2(0.0, 4.0)));
+    // Diagonally down toward the panel: heading for it.
+    assert!(heading_for(from, pos2(260.0, 130.0), panel));
+    // Straight down, straight up, back left, or far below the panel's reach: not.
+    assert!(!heading_for(from, pos2(250.0, 130.0), panel));
+    assert!(!heading_for(from, pos2(250.0, 80.0), panel));
+    assert!(!heading_for(from, pos2(240.0, 105.0), panel));
+    assert!(!heading_for(from, pos2(260.0, 400.0), Rect::from_min_max(pos2(300.0, 50.0), pos2(500.0, 120.0))));
+    // A panel on the left works the same way, mirrored.
+    let left = Rect::from_min_max(pos2(0.0, 50.0), pos2(200.0, 650.0));
+    assert!(heading_for(from, pos2(240.0, 130.0), left));
+    assert!(!heading_for(from, pos2(260.0, 130.0), left));
+    // Junk positions never count.
+    assert!(!heading_for(pos2(f32::NAN, 0.0), from, panel));
+}
+
+#[test]
+fn a_reopened_main_menu_shows_no_stale_submenu() {
+    let mut u = Ui::new();
+    u.open_main_menu();
+    assert!(u.tops_shown().is_empty(), "nothing open before hovering");
+    u.settle(u.top_row(0).center());
+    assert_eq!(u.tops_shown(), ["File"]);
+    // Escape closes it; it reopens without File open.
+    u.frame(vec![Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() }]);
+    u.frame(vec![]);
+    assert!(!u.app.ui.main_menu);
+    u.open_main_menu();
+    assert!(u.tops_shown().is_empty(), "reopened with {:?} open", u.tops_shown());
+    // Closed from outside (the menu button toggling it) it forgets too.
+    u.settle(u.top_row(1).center());
+    assert_eq!(u.tops_shown(), ["Edit"]);
+    u.app.ui.main_menu = false;
+    u.frame(vec![]);
+    u.open_main_menu();
+    assert!(u.tops_shown().is_empty(), "reopened with {:?} open", u.tops_shown());
+}
+
+#[test]
+fn a_submenu_one_level_down_reopens_closed() {
+    let mut u = Ui::new();
+    u.open_main_menu();
+    u.settle(u.top_row(0).center());
+    let keys = submenu_keys("File");
+    assert!(!keys.is_empty(), "File has submenus");
+    let sub_shown = |u: &Ui| keys.iter().find(|k| u.shown(Id::new(("submenu", k.as_str())))).cloned();
+    // Down the middle of File's panel until one of its submenus opens.
+    let panel = u.rect(top("File"));
+    let mut y = panel.min.y + 10.0;
+    while sub_shown(&u).is_none() && y < panel.max.y {
+        u.settle(pos2(panel.center().x, y));
+        y += 7.0;
+    }
+    let Some(open) = sub_shown(&u) else { panic!("no File submenu opened (looked for {keys:?})") };
+    // Over to Edit and back to File: File shows, without its submenu.
+    u.hover(u.top_row(1).center());
+    u.wait(AIM_REST + 0.1);
+    assert_eq!(u.tops_shown(), ["Edit"]);
+    u.hover(u.top_row(0).center());
+    u.wait(AIM_REST + 0.1);
+    assert_eq!(u.tops_shown(), ["File"]);
+    assert_eq!(sub_shown(&u), None, "{open} came back open");
+}
+
+#[test]
+fn crossing_rows_toward_the_open_submenu_keeps_it_open() {
+    let mut u = Ui::new();
+    u.open_main_menu();
+    let file = u.top_row(0);
+    let start = pos2(file.max.x - 30.0, file.center().y);
+    u.settle(start);
+    assert_eq!(u.tops_shown(), ["File"]);
+    // Diagonally across Edit and View into File's panel, a few rows down.
+    let panel = u.rect(top("File"));
+    let end = pos2(panel.min.x + 20.0, u.top_row(3).center().y);
+    for k in 1..=8 {
+        let p = start + (end - start) * (k as f32 / 8.0);
+        u.hover(p);
+        assert_eq!(u.tops_shown(), ["File"], "at {p:?}");
+    }
+    assert!(panel.contains(end));
+    u.wait(AIM_REST + 0.2);
+    assert_eq!(u.tops_shown(), ["File"]);
+}
+
+#[test]
+fn resting_on_a_crossed_row_hands_over_to_it() {
+    let mut u = Ui::new();
+    u.open_main_menu();
+    let file = u.top_row(0);
+    let start = pos2(file.max.x - 30.0, file.center().y);
+    u.settle(start);
+    // Toward the panel, stopping on View.
+    let view = u.top_row(2);
+    let stop = pos2(view.max.x - 4.0, view.center().y);
+    for k in 1..=4 {
+        u.hover(start + (stop - start) * (k as f32 / 4.0));
+    }
+    assert_eq!(u.tops_shown(), ["File"], "still on the way");
+    u.wait(AIM_REST + 0.1);
+    assert_eq!(u.tops_shown(), ["View"]);
+}
+
+#[test]
+fn moving_straight_down_switches_after_a_short_hover() {
+    let mut u = Ui::new();
+    u.open_main_menu();
+    let file = u.top_row(0);
+    u.settle(file.center());
+    assert_eq!(u.tops_shown(), ["File"]);
+    // Down to Edit in small steps: no progress toward File's panel, so no triangle.
+    let edit = u.top_row(1).center();
+    let mut p = file.center();
+    while p.y < edit.y {
+        p.y = (p.y + 4.0).min(edit.y);
+        u.hover(p);
+    }
+    assert!(u.tops_shown().is_empty(), "File closes at once, Edit waits: {:?}", u.tops_shown());
+    u.wait(HOVER_DELAY + 0.05);
+    assert_eq!(u.tops_shown(), ["Edit"]);
+}
+
+#[test]
+fn the_first_submenu_opens_after_a_short_hover() {
+    let mut u = Ui::new();
+    u.open_main_menu();
+    u.hover(u.top_row(0).center());
+    u.frame(vec![]);
+    assert!(u.tops_shown().is_empty(), "opened at once");
+    u.wait(HOVER_DELAY + 0.05);
+    assert_eq!(u.tops_shown(), ["File"]);
+}
+
+#[test]
+fn sweeping_across_rows_opens_only_where_the_pointer_stops() {
+    let mut u = Ui::new();
+    u.open_main_menu();
+    u.settle(u.top_row(0).center());
+    // Quickly down the left of the rows, a row a frame, to Arrange.
+    for i in 1..=5 {
+        let r = u.top_row(i);
+        u.hover(pos2(r.min.x + 20.0, r.center().y));
+        // (A panel drawn above the row the pointer is on goes the next frame.)
+        u.frame(vec![]);
+        assert!(u.tops_shown().is_empty(), "{:?} open on row {i}", u.tops_shown());
+    }
+    u.wait(HOVER_DELAY + 0.05);
+    assert_eq!(u.tops_shown(), ["Arrange"]);
+}
+
+#[test]
+fn hovering_a_plain_row_closes_the_open_submenu_at_once() {
+    let mut u = Ui::new();
+    u.open_main_menu();
+    u.settle(u.top_row(0).center());
+    assert_eq!(u.tops_shown(), ["File"]);
+    // Up onto the Actions row.
+    let m = u.rect(main_menu_id());
+    u.hover(pos2(u.top_row(0).center().x, m.min.y + 8.0 + 15.0));
+    assert!(u.tops_shown().is_empty(), "{:?} still open", u.tops_shown());
+}
+
+#[test]
+fn leaving_the_menu_keeps_the_last_submenu() {
+    let mut u = Ui::new();
+    u.open_main_menu();
+    u.settle(u.top_row(1).center());
+    // Off the menus onto the canvas.
+    u.hover(pos2(900.0, 700.0));
+    u.wait(AIM_REST + 0.1);
+    assert_eq!(u.tops_shown(), ["Edit"]);
+}
diff --git a/crates/ui-egui/src/menu_contrast_tests.rs b/crates/ui-egui/src/menu_contrast_tests.rs
new file mode 100644
index 000000000..f3a9b1bda
--- /dev/null
+++ b/crates/ui-egui/src/menu_contrast_tests.rs
@@ -0,0 +1,84 @@
+//! Panel dropdowns (the prototype device picker, Preferences, blend modes…) draw on the theme's
+//! popup fill, so their rows' text must read on it in both themes (#972): drawn headless.
+
+use egui::{Color32, Event, Order, PointerButton, Pos2, RawInput, Rect, Shape, pos2, vec2};
+
+use crate::right::{menu_check, menu_item, menu_popup};
+use crate::theme::{self, Tokens};
+
+fn input(t: &mut f64, events: Vec<Event>) -> RawInput {
+    *t += 1.0 / 60.0;
+    RawInput { screen_rect: Some(Rect::from_min_size(Pos2::ZERO, vec2(800.0, 600.0))), time: Some(*t), events, ..Default::default() }
+}
+
+fn press(p: Pos2, pressed: bool) -> Vec<Event> {
+    vec![Event::PointerMoved(p), Event::PointerButton { pos: p, button: PointerButton::Primary, pressed, modifiers: Default::default() }]
+}
+
+fn color(x: Color32) -> figcraft_color::Color {
+    figcraft_color::Color::new(f32::from(x.r()) / 255.0, f32::from(x.g()) / 255.0, f32::from(x.b()) / 255.0, 1.0)
+}
+
+/// The text painted on the foreground (menu) layers: (text, colour).
+fn menu_texts(out: &egui::FullOutput) -> Vec<(String, Color32)> {
+    fn walk(s: &Shape, out: &mut Vec<(String, Color32)>) {
+        match s {
+            Shape::Vec(v) => v.iter().for_each(|s| walk(s, out)),
+            Shape::Text(t) => out.push((t.galley.text().to_string(), t.fallback_color)),
+            _ => {}
+        }
+    }
+    let mut texts = Vec::new();
+    for c in &out.shapes {
+        walk(&c.shape, &mut texts);
+    }
+    texts
+}
+
+/// Open a dropdown with `tokens` and return its rows' text colours, with the pointer away from them.
+fn rows(tokens: Tokens) -> Vec<(String, Color32)> {
+    let ctx = egui::Context::default();
+    theme::apply(&ctx, tokens);
+    let mut t = 0.0;
+    let mut frame = |events: Vec<Event>| {
+        let mut out = ctx.run_ui(input(&mut t, events), |ui| {
+            let (_, resp) = ui.allocate_exact_size(vec2(200.0, 24.0), egui::Sense::click());
+            menu_popup(&resp).show(|ui| {
+                menu_check(ui, true, "iPhone 17 Pro Max", "");
+                menu_check(ui, false, "Pixel 9", "");
+                menu_item(ui, "Copy", "Cmd+C");
+            });
+        });
+        out.textures_delta.clear();
+        out
+    };
+    let at = pos2(12.0, 12.0);
+    frame(vec![]);
+    frame(press(at, true));
+    frame(press(at, false));
+    // Past the popup's fade-in, so the colours are the ones it settles on.
+    for _ in 0..30 {
+        frame(vec![Event::PointerMoved(pos2(790.0, 590.0))]);
+    }
+    let out = frame(vec![]);
+    assert!(ctx.memory(|m| m.areas().visible_layer_ids().iter().any(|l| l.order == Order::Foreground)), "the menu opened");
+    menu_texts(&out)
+}
+
+#[test]
+fn dropdown_rows_read_on_the_popup_in_both_themes() {
+    for tokens in [Tokens::light(), Tokens::dark()] {
+        // The popup's own fill (`window_fill`), what the rows are drawn on.
+        let fill = color(tokens.panel);
+        let texts = rows(tokens);
+        let keys = crate::toolbar::pretty_shortcut("Cmd+C");
+        // Labels at WCAG AA for text; the dimmer shortcut at least 3:1.
+        for (label, min) in [("iPhone 17 Pro Max", 4.5), ("Pixel 9", 4.5), ("Copy", 4.5), (keys.as_str(), 3.0)] {
+            let Some((_, col)) = texts.iter().find(|(s, _)| s.trim() == label || s.ends_with(label)) else {
+                panic!("{label} painted (dark {}): {texts:?}", tokens.dark)
+            };
+            let ratio = color(*col).contrast(fill);
+            assert!(ratio >= min, "{label} at {ratio:.2}:1 on the popup (dark {}): {texts:?}", tokens.dark);
+        }
+    }
+}
diff --git a/crates/ui-egui/src/menu_input_tests.rs b/crates/ui-egui/src/menu_input_tests.rs
new file mode 100644
index 000000000..f317b65bc
--- /dev/null
+++ b/crates/ui-egui/src/menu_input_tests.rs
@@ -0,0 +1,87 @@
+//! Menu and Actions entries that need an input must collect it in the UI, not send `{}` to the
+//! engine (which would show a parameter error or silently use a default).
+
+use figcraft_engine::Session;
+use serde_json::json;
+
+use crate::dialogs::MenuInput;
+use crate::layers_drag_tests::Ui;
+use crate::menus;
+
+#[test]
+fn preference_actions_open_preferences_without_changing_values() {
+    let mut ui = Ui::new(Session::new());
+    ui.app.session.prefs.language = "en".into();
+    ui.app.session.prefs.publish_server = "wss://example.test/".into();
+    let before = ui.app.session.prefs.clone();
+    for id in ["pref.language", "pref.userName", "pref.publishServer", "pref.nudge"] {
+        ui.app.ui.preferences = false;
+        menus::invoke(&mut ui.app, id);
+        assert!(ui.app.ui.preferences, "{id} did not open Preferences");
+        assert!(ui.app.ui.last_error.is_none(), "{id} showed an error");
+        assert_eq!(ui.app.session.prefs.language, before.language);
+        assert_eq!(ui.app.session.prefs.publish_server, before.publish_server);
+        assert_eq!(ui.app.session.prefs.nudge_small, before.nudge_small);
+        assert_eq!(ui.app.session.prefs.nudge_big, before.nudge_big);
+    }
+    // Programmatic callers still need the actual argument.
+    assert!(ui.app.session.execute("pref.language", &json!({})).is_err());
+}
+
+#[test]
+fn menu_entries_collect_required_arguments_before_running() {
+    let mut ui = Ui::new(Session::new());
+    for (id, expected) in
+        [("text.link", MenuInput::Link(String::new())), ("vector.offset", MenuInput::Offset(0.0)), ("object.moveToPage", MenuInput::MoveToPage)]
+    {
+        ui.app.ui.menu_input = None;
+        menus::invoke(&mut ui.app, id);
+        assert_eq!(ui.app.ui.menu_input, Some(expected), "{id}");
+        assert!(ui.app.ui.last_error.is_none(), "{id} showed an error");
+    }
+    ui.frame(vec![]);
+    assert!(ui.app.ui.last_error.is_none());
+}
+
+#[test]
+fn palette_entries_with_existing_pickers_show_them() {
+    let mut ui = Ui::new(Session::new());
+    menus::invoke(&mut ui.app, "tool.set");
+    assert_eq!(ui.app.ui.tool_flyout, Some("move"));
+    ui.app.ui.left_collapsed = true;
+    menus::invoke(&mut ui.app, "page.select");
+    assert!(!ui.app.ui.left_collapsed);
+    assert!(ui.app.ui.pages_open);
+    menus::invoke(&mut ui.app, "file.openRecent");
+    assert!(ui.app.ui.home);
+    assert_eq!(ui.app.ui.home_view.section, crate::home::Section::Recents);
+    assert!(ui.app.ui.last_error.is_none());
+}
+
+#[test]
+fn batch_rename_opens_its_existing_dialog() {
+    let mut session = Session::new();
+    let id = session.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 20, "height": 20})).unwrap()["id"].clone();
+    session.execute("select.set", &json!({"ids": [id]})).unwrap();
+    let mut ui = Ui::new(session);
+    menus::invoke(&mut ui.app, "object.batchRename");
+    assert_eq!(ui.app.ui.batch_rename.as_ref().map(|d| d.ids.len()), Some(1));
+    assert!(ui.app.ui.last_error.is_none());
+}
+
+#[test]
+fn rename_file_edits_the_file_name_in_place() {
+    let mut ui = Ui::new(Session::new());
+    ui.app.ui.left_collapsed = true;
+    menus::invoke(&mut ui.app, "file.rename");
+    assert!(!ui.app.ui.left_collapsed, "the left panel shows the file name");
+    assert!(ui.app.ui.menu_input.is_none(), "no dialog");
+    ui.frame(vec![]);
+    ui.frame(vec![]);
+    assert!(!ui.app.ui.rename_file, "the rename started");
+    assert!(ui.ctx.memory(|m| m.has_focus(egui::Id::new("filename").with("te"))), "the file name's editor has the keyboard");
+    ui.frame(vec![egui::Event::Text("Brand kit".into())]);
+    ui.frame(vec![egui::Event::Key { key: egui::Key::Enter, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() }]);
+    assert_eq!(ui.app.session.doc().unwrap().name, "Brand kit");
+    assert!(ui.app.ui.last_error.is_none());
+}
diff --git a/crates/ui-egui/src/menus.rs b/crates/ui-egui/src/menus.rs
index b9d3299a6..c48fa4018 100644
--- a/crates/ui-egui/src/menus.rs
+++ b/crates/ui-egui/src/menus.rs
@@ -7,9 +7,9 @@ use serde_json::json;
 
 use crate::FigApp;
 use crate::a11y;
-use crate::i18n::{self, tr, tr_noop, trf};
+use crate::i18n::{self, tr, tr_noop, trf, trn};
 use crate::icons::{self, Icon};
-use crate::theme::{ACCENT, Tokens, regular};
+use crate::theme::{Tokens, regular};
 use crate::toolbar::pretty_shortcut;
 
 /// Commands the UI layer implements itself (dialogs and platform actions).
@@ -30,38 +30,72 @@ pub const UI_COMMANDS: &[&str] = &[
 ];
 
 /// Run a menu item: some open dialogs or use platform services, the rest go to the engine.
-/// Paste: the system clipboard wins when it holds something newer than our own copy (an image, SVG
-/// or text from another app); otherwise our copied layers. `event_text` is the text the platform
-/// handed over with the paste event (the browser has no other way to read it).
-pub fn paste(app: &mut FigApp, event_text: Option<&str>) {
+/// Paste: the system clipboard wins when it holds something newer than our own copy (layers copied
+/// from another design app, an image, SVG or text from another app); otherwise our copied layers.
+/// `event_text` is the text the platform handed over with the paste event (the browser has no
+/// other way to read it). `at`: the page point to paste at (Paste here); `None` pastes in the
+/// middle of the view.
+/// In Dev Mode only a comment's link pastes (it opens the thread); everything else would edit.
+pub fn paste(app: &mut FigApp, event_text: Option<&str>, at: Option<(f64, f64)>) {
+    // Only HTML that holds readable design data takes this path; other HTML pastes as before.
+    if let Some(html) = app.services.clipboard_get_html().filter(|h| figcraft_engine::cmd::edit::design_clipboard_buffer(h).is_some()) {
+        if dev_mode_refuses(app, "edit.paste") {
+            return;
+        }
+        let mut params = json!({"html": html});
+        if let Some((x, y)) = at {
+            params["x"] = json!(x);
+            params["y"] = json!(y);
+        }
+        if let Some(r) = app.run("edit.pasteDesignLayers", params) {
+            // The pasted layers are now our copy: text another app puts on the clipboard later is newer.
+            app.ui.last_copy = Some(app.services.clipboard_get_text().unwrap_or_default());
+            let left_out = r["warnings"].as_array().map_or(0, Vec::len);
+            if left_out > 0 {
+                app.toast(trn("Pasted design layers; {n} kinds of content were left out", left_out, &[]));
+            }
+        }
+        return;
+    }
     let sys_text = app.services.clipboard_get_text().or_else(|| event_text.map(str::to_string)).filter(|t| !t.is_empty());
     let ours = sys_text.is_some() && sys_text == app.ui.last_copy;
-    let (cx, cy) = app.session.ds().map(|d| (d.view.cx, d.view.cy)).unwrap_or((0.0, 0.0));
+    let (cx, cy) = at.or_else(|| app.session.ds().ok().map(|d| (d.view.cx, d.view.cy))).unwrap_or((0.0, 0.0));
     if !ours {
         if let Some((png, w, h)) = clipboard_png(app) {
+            if dev_mode_refuses(app, "edit.paste") {
+                return;
+            }
             use base64::Engine as _;
             let b64 = base64::engine::general_purpose::STANDARD.encode(png);
-            // Centred in the view.
-            let (x, y) = ((cx - f64::from(w) / 2.0).round(), (cy - f64::from(h) / 2.0).round());
+            // Centred in the view; Paste here puts its top-left at the point, as it does layers.
+            let (x, y) = if at.is_some() { (cx, cy) } else { ((cx - f64::from(w) / 2.0).round(), (cy - f64::from(h) / 2.0).round()) };
             app.run("file.import", json!({"data": b64, "name": "Pasted image.png", "x": x, "y": y}));
             return;
         }
         // Text from elsewhere when it's newer than our copy, or when we have nothing to paste.
         if let Some(text) = sys_text.filter(|_| app.ui.last_copy.is_some() || app.session.clipboard.nodes.is_empty()) {
-            // A comment's link opens its thread.
-            if text.trim().starts_with("figcraft://comment/") {
-                app.run("comment.open", json!({"link": text.trim()}));
-            } else if figcraft_engine::looks_like_svg(&text) {
-                use base64::Engine as _;
-                let b64 = base64::engine::general_purpose::STANDARD.encode(text.as_bytes());
-                app.run("file.import", json!({"data": b64, "name": "Pasted SVG.svg", "x": cx, "y": cy, "center": true}));
-            } else {
-                app.run("text.create", json!({"text": text, "x": cx, "y": cy}));
-            }
-            return;
+            return paste_text(app, &text, (cx, cy), at.is_none());
         }
     }
-    app.run("edit.paste", json!({}));
+    if !dev_mode_refuses(app, "edit.paste") {
+        app.run("edit.paste", at.map_or(json!({}), |(x, y)| json!({"x": x, "y": y})));
+    }
+}
+
+/// Paste text from another app at `(cx, cy)` (`center`: centred there): a comment's link opens its
+/// thread, SVG imports, anything else becomes a text layer.
+fn paste_text(app: &mut FigApp, text: &str, (cx, cy): (f64, f64), center: bool) {
+    if text.trim().starts_with("figcraft://comment/") {
+        app.run("comment.open", json!({"link": text.trim()}));
+    } else if dev_mode_refuses(app, "edit.paste") {
+        // Dev Mode: the note says why nothing was pasted.
+    } else if figcraft_engine::looks_like_svg(text) {
+        use base64::Engine as _;
+        let b64 = base64::engine::general_purpose::STANDARD.encode(text.as_bytes());
+        app.run_user("file.import", json!({"data": b64, "name": "Pasted SVG.svg", "x": cx, "y": cy, "center": center}));
+    } else {
+        app.run("text.create", json!({"text": text, "x": cx, "y": cy}));
+    }
 }
 
 /// The system clipboard's image as PNG bytes, with its size.
@@ -73,14 +107,75 @@ fn clipboard_png(app: &mut FigApp) -> Option<(Vec<u8>, u32, u32)> {
     Some((out.into_inner(), w, h))
 }
 
+/// Dev Mode (the Inspect tab) refuses command `id` from the menus, shortcuts and clipboard: it
+/// edits the design ([`figcraft_engine::devinspect::dev_mode_allows`]). Says so when it does.
+/// shortcut: the layers panel (rename, reorder, hide, lock) and files dropped on the canvas still
+/// edit in Dev Mode; route them through here if people trip over it.
+pub fn dev_mode_refuses(app: &mut FigApp, id: &str) -> bool {
+    let refused = app.ui.right_tab == crate::RightTab::Inspect && !figcraft_engine::devinspect::dev_mode_allows(id);
+    if refused {
+        app.toast(tr("Dev Mode only inspects: switch to Design (Shift+D) to edit"));
+    }
+    refused
+}
+
+/// The Actions palette's tab.
+#[derive(Clone, Copy, PartialEq, Eq, Default)]
+pub enum PaletteTab {
+    #[default]
+    All,
+    Assets,
+    Plugins,
+}
+
+/// Remember an action run from the palette for its Recents (newest first, capped).
+pub fn record_recent(app: &mut FigApp, key: &str) {
+    let r = &mut app.session.prefs.recent_actions;
+    if r.first().is_some_and(|f| f == key) {
+        return;
+    }
+    r.retain(|k| k != key);
+    r.insert(0, key.to_string());
+    r.truncate(figcraft_engine::MAX_RECENT_ACTIONS);
+}
+
+/// Run a menu, shortcut or palette action by id: actions that need the UI (dialogs, panels, the
+/// clipboard) are handled here, the rest go to the engine.
 pub fn invoke(app: &mut FigApp, id: &str) {
+    if dev_mode_refuses(app, id) {
+        return;
+    }
     match id {
+        // Edit ▸ Delete (and the Delete binding) with an interaction open in the Prototype tab
+        // removes that interaction, not the layer (#767).
+        "edit.delete" if app.ui_context.clone().is_some_and(|ctx| crate::proto_panel::delete_selected_interaction(app, &ctx)) => {}
+        // After a click in the Pages list, while the list is on screen and its file open, with no
+        // layers selected, it deletes the current page (#859).
+        "edit.delete" if crate::layers::pages_have_keyboard(app) && app.session.selection().is_empty() => {
+            if let Ok(page) = app.session.page() {
+                crate::layers::delete_page(app, page);
+            }
+        }
+        // Otherwise the list gives up the keyboard: once Delete has taken layers selected since the
+        // click (Select all, say), a second Delete must not take the page.
+        "edit.delete" if app.ui.pages_focus.is_some() => {
+            app.ui.pages_focus = None;
+            app.run(id, json!({}));
+        }
         "file.open" => app.open_dialog(),
+        // From the keyboard or a menu, typing goes on in the new sticky.
+        "board.nextSticky" => {
+            app.run(id, json!({"edit": true}));
+        }
         "plugin.import" => crate::plugins_ui::import_dialog(app),
         "file.import" => app.import_dialog(false),
         "file.placeImage" => app.import_dialog(true),
         "file.save" => app.save(),
         "file.saveAs" => app.save_as_dialog(),
+        "file.openRecent" => {
+            app.ui.home = true;
+            app.ui.home_view.section = crate::home::Section::Recents;
+        }
         "file.saveVersion" => crate::versions::start_save(app),
         "branch.create" => crate::versions::start_branch(app),
         "file.export" | "file.exportSvg" => app.ui.export_preview = true,
@@ -128,22 +223,49 @@ pub fn invoke(app: &mut FigApp, id: &str) {
             app.services.clipboard_set_text(&format!("figcraft://node/{}", ids.first().map(|i| i.0).unwrap_or(0)));
         }
         "edit.findReplace" => app.ui.find = Some((String::new(), String::new())),
+        // The Actions palette invokes commands without parameters. These values are edited in
+        // Preferences; sending an empty object would either fail or silently reset a preference.
+        "pref.language" | "pref.userName" | "pref.publishServer" | "pref.nudge" => {
+            app.run("app.preferences", json!({}));
+        }
+        // The file name in the left panel's header turns into its editor, the name selected.
+        "file.rename" => {
+            app.ui.left_tab = crate::LeftTab::File;
+            app.ui.left_collapsed = false;
+            app.ui.rename_file = true;
+        }
+        "text.link" => app.ui.menu_input = Some(crate::dialogs::MenuInput::Link(String::new())),
+        "vector.offset" => app.ui.menu_input = Some(crate::dialogs::MenuInput::Offset(0.0)),
+        "object.moveToPage" => app.ui.menu_input = Some(crate::dialogs::MenuInput::MoveToPage),
+        "object.batchRename" => {
+            let ids = app.session.selection();
+            if !ids.is_empty() {
+                crate::dialogs::open_batch_rename(app, &ids);
+            }
+        }
+        "tool.set" => app.ui.tool_flyout = Some("move"),
+        "page.select" => {
+            app.ui.left_tab = crate::LeftTab::File;
+            app.ui.left_collapsed = false;
+            app.ui.pages_open = true;
+        }
         // From a menu the link is pasted into the Join dialog (`collab.join {link}` joins directly).
         "collab.join" => crate::live::open_join(app, ""),
         // So is the server address for publishing (it carries the server key).
         "collab.publish" => crate::live::open_publish(app),
         "edit.copy" | "edit.cut" => {
             let ids = app.session.selection();
-            // SVG for other apps, taken before a cut removes the layers.
-            let svg = app.session.doc().ok().and_then(|d| figcraft_svg_export(d, &ids));
+            // For other apps: text layers' text, other layers as SVG; taken before a cut removes them.
+            let doc = app.session.doc().ok();
+            let mirror = doc.and_then(|d| text_layers_text(d, &ids).or_else(|| figcraft_svg_export(d, &ids)));
             app.run(id, json!({}));
-            // Mirror to the system clipboard (SVG text, else a marker) and remember it, so a later
-            // paste knows whether the clipboard still holds our layers.
-            let text = svg.unwrap_or_else(|| format!("figcraft://clipboard/{}", ids.len()));
+            // Mirror to the system clipboard (text or SVG, else a marker) and remember it, so a
+            // later paste knows whether the clipboard still holds our layers.
+            let text = mirror.unwrap_or_else(|| format!("figcraft://clipboard/{}", ids.len()));
             app.services.clipboard_set_text(&text);
             app.ui.last_copy = Some(text);
         }
-        "edit.paste" => paste(app, None),
+        "edit.paste" => paste(app, None, None),
         "file.close" if app.session.ds().is_ok_and(|d| d.is_dirty() && d.branch_of.is_none()) => {
             let save = pretty_shortcut(crate::shortcuts::shortcut("file.save").unwrap_or(""));
             app.toast(trf(
@@ -167,6 +289,14 @@ fn export_frames_pdf(app: &mut FigApp) {
     });
 }
 
+/// The text of a selection made only of text layers, one layer per line (None for any other
+/// selection, or when there is no text).
+fn text_layers_text(doc: &figcraft_doc::Document, ids: &[figcraft_doc::NodeId]) -> Option<String> {
+    let texts: Option<Vec<&str>> = ids.iter().map(|i| doc.node(*i).and_then(|n| n.kind.text()).map(|t| t.characters.as_str())).collect();
+    texts.map(|t| t.join("\n")).filter(|t| !t.is_empty())
+}
+
+/// The layers as SVG text for other apps (None when the export fails).
 fn figcraft_svg_export(doc: &figcraft_doc::Document, ids: &[figcraft_doc::NodeId]) -> Option<String> {
     let bytes = figcraft_engine::cmd::file::export_bytes(doc, ids, figcraft_doc::ExportFormat::Svg, 1.0).ok()?;
     String::from_utf8(bytes).ok()
@@ -215,7 +345,7 @@ fn menu_level(app: &mut FigApp, ui: &mut Ui, prefix: &str) -> bool {
                 subs.push(sub.clone());
                 last_sep = false;
                 let full = format!("{prefix}/{sub}");
-                if submenu(ui, prefix, &full, tr(&sub), &t, |ui| menu_level(app, ui, &full).then_some(())).is_some() {
+                if submenu(ui, &full, tr(&sub), &t, |ui| menu_level(app, ui, &full).then_some(())).is_some() {
                     return true;
                 }
             }
@@ -231,15 +361,15 @@ fn menu_level(app: &mut FigApp, ui: &mut Ui, prefix: &str) -> bool {
 /// File ▸ Open recent: the recent files (greyed when the file is gone) and Clear recent. `key` is
 /// the menu's English label, `label` the one shown. Returns whether an item ran.
 fn recent_menu(app: &mut FigApp, ui: &mut Ui, prefix: &str, key: &str, label: &str, t: &Tokens) -> bool {
-    let picked = submenu(ui, prefix, &format!("{prefix}/{key}"), label, t, |ui| {
-        let recents = &app.session.prefs.recent_files;
+    let picked = submenu(ui, &format!("{prefix}/{key}"), label, t, |ui| {
+        let recents: Vec<&String> = crate::home_recents::listed(&app.session.prefs.recent_files).collect();
         let mut picked = None;
-        for (i, p) in recents.iter().enumerate() {
+        for p in recents.iter().copied() {
             let path = std::path::Path::new(p);
             let name = path.file_name().map_or_else(|| p.clone(), |f| f.to_string_lossy().into_owned());
             let exists = path.exists();
             if item(ui, &name, "", exists, false, t) && exists {
-                picked = Some(json!({"index": i}));
+                picked = Some(json!({"path": p}));
             }
         }
         if !recents.is_empty() {
@@ -251,26 +381,292 @@ fn recent_menu(app: &mut FigApp, ui: &mut Ui, prefix: &str, key: &str, label: &s
         picked
     });
     let Some(params) = picked else { return false };
-    if app.run("file.openRecent", params).is_some_and(|r| r.get("index").is_some()) {
+    // Through the user path, so an import report shows; `file.openRecent` also drops a file that is gone.
+    if app.run_user("file.openRecent", params).is_some_and(|r| r.get("index").is_some()) {
         app.ui.home = false;
     }
     true
 }
 
-/// A submenu row `label` in the menu at `prefix`; while it's open (hovered last), `add` draws its
-/// items beside it. `key` is unique among the menu's submenus. Returns what `add` returned.
-pub(crate) fn submenu<R>(ui: &mut Ui, prefix: &str, key: &str, label: &str, t: &Tokens, add: impl FnOnce(&mut Ui) -> Option<R>) -> Option<R> {
-    let resp = submenu_item(ui, label, t);
-    let slot = Id::new(("submenu_open", prefix));
-    if resp.hovered() || resp.has_focus() {
-        ui.data_mut(|d| d.insert_temp(slot, key.to_string()));
+/// A submenu row `label` in the menu being drawn; while it's open, `add` draws its items beside
+/// it. `key` names the submenu (its menu path, unique in its menu tree). Returns what `add`
+/// returned.
+pub(crate) fn submenu<R>(ui: &mut Ui, key: &str, label: &str, t: &Tokens, add: impl FnOnce(&mut Ui) -> Option<R>) -> Option<R> {
+    submenu_at(ui, Id::new(("submenu", key)), key, label, 4.0, false, t, add)
+}
+
+// ---------------------------------------------------------------------------------------------
+// Which submenu is open: hover intent with a safe triangle.
+//
+// Every menu tree (the main menu, the context menu) keeps, per level, which of its submenus is
+// open. Hovering another row closes the open submenu at once; resting on a submenu row for
+// `HOVER_DELAY` opens it (sweeping across rows doesn't flash every submenu on the way). Except while the
+// pointer is on its way from the open submenu's row to the submenu: while each move lands inside
+// the triangle between where it was and the submenu's near edge (it keeps getting nearer), rows
+// it crosses don't take over and the submenu's row stays highlighted. Resting (`AIM_REST`) or
+// turning away ends that, and the row under the pointer takes over. Leaving the menus keeps the
+// last submenu open.
+// Closing a menu tree forgets all of it, so it reopens with no submenu open.
+
+/// How long the pointer stays on a submenu row before its submenu opens.
+pub(crate) const HOVER_DELAY: f64 = 0.15;
+/// How long the pointer may rest inside the safe triangle before the row under it takes over.
+pub(crate) const AIM_REST: f64 = 0.3;
+/// A pointer that moved less than this is resting.
+const AIM_STILL: f32 = 1.0;
+/// The triangle reaches this far above and below the submenu.
+const AIM_EDGE_SLOP: f32 = 8.0;
+
+/// The hover state of one menu level.
+#[derive(Clone, Default, Debug)]
+struct Level {
+    /// The open submenu's key.
+    open: Option<String>,
+    /// The open submenu's row and where its panel was drawn (last frame).
+    row: Option<Rect>,
+    panel: Option<Rect>,
+    /// The pointer's last position counted as heading for the panel, and when it got there.
+    apex: Option<egui::Pos2>,
+    moved_at: f64,
+    /// This pass's verdict: the pointer is aiming at the panel.
+    pass: Option<u64>,
+    aiming: bool,
+    /// The row the pointer is on, waiting to take over (a submenu's key, or `None`: a plain row),
+    /// and since when; whether a row asked this pass (unasked, it lapses).
+    pending: Option<(Option<String>, f64)>,
+    asked: bool,
+    /// When the pointer came to rest in the triangle, if that's what ended aiming this pass.
+    rested_at: Option<f64>,
+}
+
+/// One menu tree's levels, by menu path ("" for the top).
+#[derive(Clone, Default, Debug)]
+struct Tree {
+    levels: std::collections::HashMap<String, Level>,
+}
+
+/// The menu level a menu frame's ui draws: its tree's root and its path.
+#[derive(Clone, Debug)]
+struct At {
+    root: Id,
+    path: String,
+}
+
+fn at_key(ui: &Ui) -> Id {
+    ui.id().with("menu_level")
+}
+
+fn level_at(ui: &Ui) -> At {
+    ui.data(|d| d.get_temp::<At>(at_key(ui))).unwrap_or(At { root: Id::new("menus"), path: String::new() })
+}
+
+fn with_level<R>(ctx: &egui::Context, at: &At, f: impl FnOnce(&mut Level) -> R) -> R {
+    ctx.data_mut(|d| f(d.get_temp_mut_or_default::<Tree>(at.root).levels.entry(at.path.clone()).or_default()))
+}
+
+/// Forget everything a menu tree remembers (it closed or opened anew).
+pub(crate) fn forget_tree(ctx: &egui::Context, root: Id) {
+    ctx.data_mut(|d| d.remove::<Tree>(root));
+}
+
+/// Open (`Some(key)`) or close (`None`) a submenu of `root`'s level `path`; the levels below the
+/// one it replaces are forgotten (they reopen closed).
+fn set_open(ctx: &egui::Context, root: Id, path: &str, key: Option<&str>) {
+    ctx.data_mut(|d| {
+        let tree = d.get_temp_mut_or_default::<Tree>(root);
+        let level = tree.levels.entry(path.to_string()).or_default();
+        if level.open.as_deref() == key {
+            return;
+        }
+        let old = std::mem::replace(&mut level.open, key.map(str::to_string));
+        level.row = None;
+        level.panel = None;
+        level.apex = None;
+        level.pending = None;
+        if let Some(old) = old {
+            let below = format!("{old}/");
+            tree.levels.retain(|p, _| *p != old && !p.starts_with(&below));
+        }
+    });
+}
+
+/// Whether `p` is in the triangle `a`, `b`, `c` (either winding, edges included).
+pub(crate) fn in_triangle(p: egui::Pos2, a: egui::Pos2, b: egui::Pos2, c: egui::Pos2) -> bool {
+    let side = |u: egui::Pos2, v: egui::Pos2| (v.x - u.x) * (p.y - u.y) - (v.y - u.y) * (p.x - u.x);
+    let (d1, d2, d3) = (side(a, b), side(b, c), side(c, a));
+    let neg = d1 < 0.0 || d2 < 0.0 || d3 < 0.0;
+    let pos = d1 > 0.0 || d2 > 0.0 || d3 > 0.0;
+    !(neg && pos)
+}
+
+/// Whether a pointer that moved from `from` to `p` is heading for `panel`: `p` is inside the
+/// triangle from `from` to the panel's near edge, so it got nearer the panel without leaving the
+/// rows' way to it. Straight up or down (or away) isn't.
+pub(crate) fn heading_for(from: egui::Pos2, p: egui::Pos2, panel: Rect) -> bool {
+    if ![from.x, from.y, p.x, p.y].iter().all(|v| v.is_finite()) {
+        return false;
     }
-    let open: Option<String> = ui.data(|d| d.get_temp(slot));
-    if open.as_deref() != Some(key) {
+    let edge = if panel.min.x >= from.x {
+        panel.min.x
+    } else if panel.max.x <= from.x {
+        panel.max.x
+    } else {
+        return false;
+    };
+    in_triangle(p, from, pos2(edge, panel.min.y - AIM_EDGE_SLOP), pos2(edge, panel.max.y + AIM_EDGE_SLOP))
+}
+
+/// Whether the pointer is on its way to this level's open submenu (rows it crosses don't take
+/// over). Worked out once per pass per level.
+fn aiming(ui: &Ui) -> bool {
+    let at = level_at(ui);
+    let ctx = ui.ctx();
+    let pass = ctx.cumulative_pass_nr();
+    let (p, now) = ctx.input(|i| (i.pointer.hover_pos(), i.time));
+    let (aiming, wait) = with_level(ctx, &at, |l| {
+        if l.pass == Some(pass) {
+            return (l.aiming, None);
+        }
+        l.pass = Some(pass);
+        l.aiming = false;
+        l.rested_at = None;
+        if !l.asked {
+            l.pending = None;
+        }
+        l.asked = false;
+        let (Some(p), Some(_), Some(panel)) = (p, l.open.as_ref(), l.panel) else {
+            l.apex = None;
+            return (false, None);
+        };
+        if panel.contains(p) {
+            l.apex = None;
+            return (false, None);
+        }
+        // On the row (its bottom edge is the next row's).
+        if l.row.is_some_and(|r| (r.min.x..r.max.x).contains(&p.x) && (r.min.y..r.max.y).contains(&p.y)) {
+            l.apex = Some(p);
+            l.moved_at = now;
+            return (false, None);
+        }
+        let Some(from) = l.apex else { return (false, None) };
+        if (p - from).length() <= AIM_STILL {
+            // Resting: the submenu holds a moment longer.
+            if !(0.0..AIM_REST).contains(&(now - l.moved_at)) {
+                l.apex = None;
+                // It has rested long enough: the row under it needn't wait again.
+                l.rested_at = Some(l.moved_at);
+                return (false, None);
+            }
+        } else if heading_for(from, p, panel) {
+            l.apex = Some(p);
+            l.moved_at = now;
+        } else {
+            l.apex = None;
+            return (false, None);
+        }
+        l.aiming = true;
+        (true, Some(AIM_REST - (now - l.moved_at)))
+    });
+    // Wake up when the rest runs out, so the row under a still pointer takes over.
+    if let Some(w) = wait.filter(|w| w.is_finite() && *w > 0.0) {
+        ctx.request_repaint_after(std::time::Duration::from_secs_f64(w));
+    }
+    aiming
+}
+
+/// The pointer is on a row of level `at` (`target`: the row's submenu, or `None` for a plain
+/// row): another open submenu closes at once, and `target` opens once the pointer has stayed
+/// there `HOVER_DELAY`.
+fn hover_request(ctx: &egui::Context, at: &At, target: Option<&str>) {
+    let now = ctx.input(|i| i.time);
+    if with_level(ctx, at, |l| l.open.is_some() && l.open.as_deref() != target) {
+        set_open(ctx, at.root, &at.path, None);
+    }
+    let left = with_level(ctx, at, |l| {
+        l.asked = true;
+        if l.open.as_deref() == target {
+            l.pending = None;
+            return None;
+        }
+        let since = match &l.pending {
+            Some((t, since)) if t.as_deref() == target => *since,
+            _ => {
+                let since = l.rested_at.unwrap_or(now);
+                l.pending = Some((target.map(str::to_string), since));
+                since
+            }
+        };
+        Some(HOVER_DELAY - (now - since))
+    });
+    match left {
+        Some(left) if left <= 0.0 => set_open(ctx, at.root, &at.path, target),
+        // Wake up when it's due, so a still pointer gets there.
+        Some(left) => ctx.request_repaint_after(std::time::Duration::from_secs_f64(left.min(HOVER_DELAY))),
+        None => {}
+    }
+}
+
+/// Whether the pointer is on a row of level `at` other than the open submenu's (it shows as
+/// hovered instead).
+fn pending_elsewhere(ctx: &egui::Context, at: &At) -> bool {
+    with_level(ctx, at, |l| l.pending.as_ref().is_some_and(|(t, _)| *t != l.open))
+}
+
+/// A plain row of the level being drawn: hovering it (not while aiming at a submenu) closes the
+/// level's open submenu. Returns whether it shows as hovered.
+fn plain_row_hover(ui: &Ui, resp: &egui::Response) -> bool {
+    let hovered = resp.hovered() && !aiming(ui);
+    if hovered {
+        hover_request(ui.ctx(), &level_at(ui), None);
+    }
+    hovered || resp.has_focus()
+}
+
+/// A submenu row whose panel (area `area`, `gap` right of the row) shows while it's open.
+#[allow(clippy::too_many_arguments)]
+fn submenu_at<R>(
+    ui: &mut Ui,
+    area: Id,
+    key: &str,
+    label: &str,
+    gap: f32,
+    constrain: bool,
+    t: &Tokens,
+    add: impl FnOnce(&mut Ui) -> Option<R>,
+) -> Option<R> {
+    let at = level_at(ui);
+    let aim = aiming(ui);
+    let w = ui.available_width();
+    let (r, resp) = ui.allocate_exact_size(vec2(w, 28.0), Sense::click());
+    // The keyboard and clicks open it at once; hovering after a moment.
+    if resp.has_focus() || resp.clicked() {
+        set_open(ui.ctx(), at.root, &at.path, Some(key));
+    } else if resp.hovered() && !aim {
+        hover_request(ui.ctx(), &at, Some(key));
+    }
+    let open = with_level(ui.ctx(), &at, |l| {
+        let open = l.open.as_deref() == Some(key);
+        if open {
+            l.row = Some(r);
+        }
+        open
+    });
+    a11y::submenu(&resp, label, open);
+    a11y::own_focus(&resp);
+    // The open submenu's row stays highlighted while the pointer is in the submenu (not while it
+    // rests on another row of this menu).
+    let keep = open && !pending_elsewhere(ui.ctx(), &at);
+    paint_submenu_row(ui, r, label, keep || (resp.hovered() && !aim) || resp.has_focus(), t);
+    if !open {
         return None;
     }
-    let pos = pos2(resp.rect.max.x + 4.0, resp.rect.min.y - 8.0);
-    egui::Area::new(Id::new(("submenu", key))).fixed_pos(pos).order(egui::Order::Foreground).show(ui.ctx(), |ui| menu_frame(ui, t, add)).inner
+    let pos = pos2(r.max.x + gap, r.min.y - 8.0);
+    let child = At { root: at.root, path: key.to_string() };
+    let shown =
+        egui::Area::new(area).fixed_pos(pos).order(egui::Order::Foreground).constrain(constrain).show(ui.ctx(), |ui| menu_frame(ui, t, child, add));
+    let panel = shown.response.rect;
+    with_level(ui.ctx(), &at, |l| l.panel = Some(panel));
+    shown.inner
 }
 
 /// A thin line between groups of menu items.
@@ -281,7 +677,8 @@ pub(crate) fn separator(ui: &mut Ui) {
     ui.add_space(4.0);
 }
 
-fn menu_frame<R>(ui: &mut Ui, t: &Tokens, add: impl FnOnce(&mut Ui) -> R) -> R {
+/// A menu panel drawing menu level `at`.
+fn menu_frame<R>(ui: &mut Ui, t: &Tokens, at: At, add: impl FnOnce(&mut Ui) -> R) -> R {
     egui::Frame::NONE
         .fill(t.menu)
         .corner_radius(CornerRadius::same(13))
@@ -292,6 +689,8 @@ fn menu_frame<R>(ui: &mut Ui, t: &Tokens, add: impl FnOnce(&mut Ui) -> R) -> R {
             let w = ui.data(|d| d.get_temp::<f32>(width_key(ui))).unwrap_or(0.0).max(MENU_W);
             ui.set_width(w);
             ui.spacing_mut().item_spacing = vec2(0.0, 0.0);
+            let key = at_key(ui);
+            ui.data_mut(|d| d.insert_temp(key, at));
             add(ui)
         })
         .inner
@@ -328,7 +727,7 @@ fn indented_item(ui: &mut Ui, label: &str, shortcut: &str, enabled: bool, checke
     }
     // The keyboard's item is highlighted like the hovered one.
     a11y::own_focus(&resp);
-    let hov = (resp.hovered() || resp.has_focus()) && enabled;
+    let hov = plain_row_hover(ui, &resp) && enabled;
     if hov {
         ui.painter().rect_filled(r, CornerRadius::same(5), t.menu_hover);
     }
@@ -348,24 +747,24 @@ fn indented_item(ui: &mut Ui, label: &str, shortcut: &str, enabled: bool, checke
     resp.clicked()
 }
 
-fn submenu_item(ui: &mut Ui, label: &str, t: &Tokens) -> egui::Response {
-    let w = ui.available_width();
-    let (r, resp) = ui.allocate_exact_size(vec2(w, 28.0), Sense::click());
-    a11y::submenu(&resp, label);
-    a11y::own_focus(&resp);
-    if resp.hovered() || resp.has_focus() {
+fn paint_submenu_row(ui: &mut Ui, r: Rect, label: &str, highlight: bool, t: &Tokens) {
+    if highlight {
         ui.painter().rect_filled(r, CornerRadius::same(5), t.menu_hover);
     }
     let galley = ui.painter().layout_no_wrap(label.to_string(), regular(12.0), t.menu_text);
     need_width(ui, 28.0 + galley.size().x + 28.0);
     ui.painter().galley(pos2(r.min.x + 28.0, r.center().y - galley.size().y / 2.0), galley, t.menu_text);
     icons::paint(ui.painter(), Rect::from_center_size(pos2(r.max.x - 12.0, r.center().y), vec2(12.0, 12.0)), Icon::ChevronRight, t.menu_text);
-    resp
 }
 
 /// Open the main menu at top-level menu `top` (control channel).
 pub fn open_main_menu(ctx: &egui::Context, top: &str) {
-    ctx.data_mut(|d| d.insert_temp(Id::new("main_open"), top.to_string()));
+    set_open(ctx, main_menu_id(), "", Some(top));
+}
+
+/// The context menu's area (and menu tree).
+fn ctx_menu_id() -> Id {
+    Id::new("ctx_menu")
 }
 
 /// The main menu's area.
@@ -394,13 +793,29 @@ const TOP_MENUS: &[&str] = &[
 
 pub fn popups(app: &mut FigApp, ctx: &egui::Context) {
     let t = Tokens::get(ctx);
+    // A closed menu forgets its open submenus (and a context menu opened somewhere else starts
+    // afresh), so neither reopens with a stale submenu showing.
+    if !app.ui.main_menu {
+        forget_tree(ctx, main_menu_id());
+    }
+    let ctx_at = app.ui.context_menu.as_ref().map(|(p, _)| *p);
+    let ctx_seen = Id::new("ctx_menu_at");
+    if ctx.data(|d| d.get_temp::<Option<egui::Pos2>>(ctx_seen)) != Some(ctx_at) {
+        ctx.data_mut(|d| d.insert_temp(ctx_seen, ctx_at));
+        forget_tree(ctx, ctx_menu_id());
+    }
+    // Select layer opened or closed from the control channel.
+    if let Some(open) = ctx.data_mut(|d| d.remove_temp::<bool>(select_layer_ask_id())) {
+        set_open(ctx, ctx_menu_id(), "", open.then_some(SELECT_LAYER));
+    }
     // Main menu.
     if app.ui.main_menu {
         let mut close = false;
         let area = egui::Area::new(main_menu_id()).fixed_pos(pos2(8.0, crate::tabs::HEIGHT + 48.0)).order(egui::Order::Foreground).show(ctx, |ui| {
-            menu_frame(ui, &t, |ui| {
+            menu_frame(ui, &t, At { root: main_menu_id(), path: String::new() }, |ui| {
                 // Quick actions search row.
                 let (r, resp) = ui.allocate_exact_size(vec2(ui.available_width(), 30.0), Sense::click());
+                plain_row_hover(ui, &resp);
                 a11y::menu_item(&resp, tr("Actions…"), crate::shortcuts::shortcut("app.actions").unwrap_or(""), None);
                 ui.painter().rect_filled(r.shrink(2.0), CornerRadius::same(5), Color32::from_white_alpha(18));
                 icons::paint(ui.painter(), Rect::from_center_size(pos2(r.min.x + 16.0, r.center().y), vec2(14.0, 14.0)), Icon::Search, t.menu_dim);
@@ -413,25 +828,13 @@ pub fn popups(app: &mut FigApp, ctx: &egui::Context) {
                     t.menu_dim,
                 );
                 if resp.clicked() {
-                    app.ui.palette = Some(String::new());
+                    set_palette(&mut app.ui, true);
                     close = true;
                 }
                 ui.add_space(6.0);
                 for top in TOP_MENUS {
-                    let resp = submenu_item(ui, tr(top), &t);
-                    if resp.hovered() || resp.has_focus() {
-                        ui.data_mut(|d| d.insert_temp(Id::new("main_open"), top.to_string()));
-                    }
-                    let open: Option<String> = ui.data(|d| d.get_temp(Id::new("main_open")));
-                    if open.as_deref() == Some(*top) {
-                        let pos = pos2(resp.rect.max.x + 12.0, resp.rect.min.y - 8.0);
-                        egui::Area::new(Id::new(("menu", *top))).fixed_pos(pos).order(egui::Order::Foreground).show(ui.ctx(), |ui| {
-                            menu_frame(ui, &t, |ui| {
-                                if menu_level(app, ui, top) {
-                                    close = true;
-                                }
-                            });
-                        });
+                    if submenu_at(ui, Id::new(("menu", *top)), top, tr(top), 12.0, false, &t, |ui| menu_level(app, ui, top).then_some(())).is_some() {
+                        close = true;
                     }
                 }
             });
@@ -439,6 +842,7 @@ pub fn popups(app: &mut FigApp, ctx: &egui::Context) {
         let clicked_outside = ctx.input(|i| i.pointer.any_pressed()) && !over_menu(ctx) || ctx.input(|i| i.key_pressed(egui::Key::Escape));
         if close || (clicked_outside && !area.response.hovered()) {
             app.ui.main_menu = false;
+            forget_tree(ctx, main_menu_id());
         }
     }
     // Context menu (from the keyboard: at the focused layer row or the canvas selection, taking the
@@ -451,8 +855,8 @@ pub fn popups(app: &mut FigApp, ctx: &egui::Context) {
             a11y::popup(&mut app.ui.nav, f, Id::new("ctx_menu"));
         }
         let mut close = false;
-        let area = egui::Area::new(Id::new("ctx_menu")).fixed_pos(pos).order(egui::Order::Foreground).constrain(true).show(ctx, |ui| {
-            menu_frame(ui, &t, |ui| {
+        let area = egui::Area::new(ctx_menu_id()).fixed_pos(pos).order(egui::Order::Foreground).constrain(true).show(ctx, |ui| {
+            menu_frame(ui, &t, At { root: ctx_menu_id(), path: String::new() }, |ui| {
                 if select_layer_menu(app, ui, pos, &t) {
                     close = true;
                 }
@@ -467,6 +871,30 @@ pub fn popups(app: &mut FigApp, ctx: &egui::Context) {
                         .collect();
                     (!secs.is_empty()).then(|| if secs.iter().all(|h| *h) { tr("Show section contents") } else { tr("Hide section contents") })
                 });
+                // Frames on the page (or in a section) convert to sections, and sections to frames.
+                let convert = app.session.doc().ok().and_then(|doc| {
+                    let nodes: Vec<_> = ids.iter().filter_map(|i| doc.node(*i)).collect();
+                    let on_board = |n: &figcraft_doc::Node| {
+                        n.parent.and_then(|p| doc.node(p)).is_some_and(|p| p.is_page() || matches!(p.kind, figcraft_doc::NodeKind::Section { .. }))
+                    };
+                    if nodes.is_empty() {
+                        None
+                    } else if nodes.iter().all(|n| matches!(n.kind, figcraft_doc::NodeKind::Section { .. })) {
+                        Some((tr("Convert to frame"), "object.convertToFrame"))
+                    } else if nodes.iter().all(|n| matches!(n.kind, figcraft_doc::NodeKind::Frame) && on_board(n)) {
+                        Some((tr("Convert to section"), "object.convertToSection"))
+                    } else {
+                        None
+                    }
+                });
+                // Two or more main components combine into a component set. Judged on the selection
+                // the command acts on: a layer row right-clicked in a multi-selection passes only itself.
+                let combine = app
+                    .session
+                    .doc()
+                    .ok()
+                    .filter(|doc| figcraft_engine::cmd::component::can_combine_variants(doc, &app.session.selection()))
+                    .map(|_| i18n::command("component.combineVariants", "Combine as variants"));
                 let mut entries: Vec<(&str, &str)> = if has_sel {
                     vec![
                         (tr("Copy"), "edit.copy"),
@@ -519,6 +947,16 @@ pub fn popups(app: &mut FigApp, ctx: &egui::Context) {
                 {
                     entries.insert(at + 1, (label, "section.toggleContents"));
                 }
+                if let Some(entry) = convert
+                    && let Some(at) = entries.iter().position(|e| e.1 == "object.wrapInSection")
+                {
+                    entries.insert(at + 1, entry);
+                }
+                if let Some(label) = &combine
+                    && let Some(at) = entries.iter().position(|e| e.1 == "component.create")
+                {
+                    entries.insert(at + 1, (label, "component.combineVariants"));
+                }
                 // A right-clicked ruler guide (selected, with no layers) can be removed.
                 if !has_sel && app.session.ds().is_ok_and(|d| d.selected_guide().is_some()) {
                     entries.splice(0..0, [(tr("Remove guide"), "guide.remove"), ("-", "")]);
@@ -532,11 +970,7 @@ pub fn popups(app: &mut FigApp, ctx: &egui::Context) {
                     if item(ui, label, sc, available(id), false, &t) {
                         if *id == "edit.paste" {
                             let p = app.to_page(pos);
-                            if app.session.clipboard.nodes.is_empty() {
-                                invoke(app, id);
-                            } else {
-                                app.run("edit.paste", json!({"x": p.x, "y": p.y}));
-                            }
+                            paste(app, None, Some((p.x, p.y)));
                         } else {
                             invoke(app, id);
                         }
@@ -548,20 +982,23 @@ pub fn popups(app: &mut FigApp, ctx: &egui::Context) {
         let clicked_outside = ctx.input(|i| i.pointer.any_pressed()) && !area.response.hovered() && !over_menu(ctx);
         if close || clicked_outside || ctx.input(|i| i.key_pressed(egui::Key::Escape)) {
             app.ui.context_menu = None;
-            ctx.data_mut(|d| d.remove::<bool>(select_layer_id()));
+            forget_tree(ctx, ctx_menu_id());
         }
     }
     crate::colorpicker::show(app, ctx);
     palette(app, ctx);
 }
 
-fn select_layer_id() -> Id {
-    Id::new("ctx_select_layer_open")
+/// The context menu's Select layer submenu (its key in the context menu's tree).
+const SELECT_LAYER: &str = "Select layer";
+
+fn select_layer_ask_id() -> Id {
+    Id::new("ctx_select_layer_ask")
 }
 
-/// Open (or close) the context menu's Select layer submenu.
+/// Open (or close) the context menu's Select layer submenu (applied when the menu next draws).
 pub fn open_select_layer(ctx: &egui::Context, open: bool) {
-    ctx.data_mut(|d| d.insert_temp(select_layer_id(), open));
+    ctx.data_mut(|d| d.insert_temp(select_layer_ask_id(), open));
 }
 
 /// The context menu's "Select layer" submenu (right-click on the canvas): every layer under the
@@ -585,23 +1022,15 @@ fn select_layer_menu(app: &mut FigApp, ui: &mut Ui, pos: egui::Pos2, t: &Tokens)
         return false;
     }
     let sel = ds.selection.clone();
-    let resp = submenu_item(ui, tr("Select layer"), t);
-    if resp.hovered() {
-        ui.data_mut(|d| d.insert_temp(select_layer_id(), true));
-    }
-    let mut picked = None;
-    if ui.data(|d| d.get_temp::<bool>(select_layer_id())).unwrap_or(false) {
-        let at = pos2(resp.rect.max.x + 4.0, resp.rect.min.y - 8.0);
-        egui::Area::new(Id::new("ctx_select_layer")).fixed_pos(at).order(egui::Order::Foreground).constrain(true).show(ui.ctx(), |ui| {
-            menu_frame(ui, t, |ui| {
-                for (id, depth, name) in &layers {
-                    if indented_item(ui, name, "", true, sel.contains(id), 12.0 * (*depth).min(8) as f32, t) {
-                        picked = Some(*id);
-                    }
-                }
-            });
-        });
-    }
+    let picked = submenu_at(ui, Id::new("ctx_select_layer"), SELECT_LAYER, tr("Select layer"), 4.0, true, t, |ui| {
+        let mut picked = None;
+        for (id, depth, name) in &layers {
+            if indented_item(ui, name, "", true, sel.contains(id), 12.0 * (*depth).min(8) as f32, t) {
+                picked = Some(*id);
+            }
+        }
+        picked
+    });
     separator(ui);
     match picked {
         Some(id) => {
@@ -612,81 +1041,402 @@ fn select_layer_menu(app: &mut FigApp, ui: &mut Ui, pos: egui::Pos2, t: &Tokens)
     }
 }
 
-/// The Actions palette: fuzzy search over every command.
+/// The Actions palette's content height (the frame adds its own 8 px margins).
+const PALETTE_H: f32 = 450.0;
+
+/// Open the Actions palette afresh (empty search, All tab, first row highlighted), or close it.
+pub fn set_palette(ui: &mut crate::UiState, open: bool) {
+    ui.palette = open.then(String::new);
+    ui.palette_tab = PaletteTab::All;
+    ui.palette_hi = 0;
+    ui.palette_armed = open;
+}
+
+/// Open the Actions palette afresh, or close it when it's open (⌘K, the toolbar's Actions button).
+pub fn toggle_palette(ui: &mut crate::UiState) {
+    let open = ui.palette.is_none();
+    set_palette(ui, open);
+}
+
+/// The Actions palette: search over commands, assets and plugins, with tabs, recents and grouped
+/// sections, floating above the toolbar. Rows run on click; Up and Down move the highlight and
+/// Enter runs the highlighted row.
 fn palette(app: &mut FigApp, ctx: &egui::Context) {
     let Some(mut q) = app.ui.palette.clone() else { return };
     let t = Tokens::get(ctx);
-    let screen = ctx.content_rect();
+    // Same centre and width as the toolbar pill (it centres on the canvas, not the window),
+    // floating 8 px above it. Fixed size: switching tabs never resizes the panel.
+    let bar_w = crate::toolbar::bar_width(app);
+    let bar = crate::toolbar::pill_rect(app.canvas.rect, bar_w);
+    let area = Rect::from_min_max(pos2(bar.min.x, bar.min.y - 8.0 - (PALETTE_H + 16.0)), pos2(bar.max.x, bar.min.y - 8.0));
     let mut run: Option<String> = None;
     let mut close = false;
-    egui::Area::new(Id::new("palette")).fixed_pos(pos2(screen.center().x - 260.0, screen.min.y + 120.0)).order(egui::Order::Foreground).show(
-        ctx,
-        |ui| {
-            egui::Frame::NONE
-                .fill(t.panel)
-                .corner_radius(CornerRadius::same(13))
-                .stroke(Stroke::new(1.0, t.border))
-                .shadow(egui::Shadow { offset: [0, 8], blur: 32, spread: 0, color: t.shadow })
-                .inner_margin(egui::Margin::same(8))
-                .show(ui, |ui| {
-                    ui.set_width(520.0);
-                    let r = ui.add(
-                        egui::TextEdit::singleline(&mut q)
-                            .hint_text(tr("Search actions, layers and tools"))
-                            .desired_width(500.0)
-                            .font(regular(14.0))
-                            .frame(egui::Frame::NONE.inner_margin(egui::Margin::same(8))),
-                    );
-                    r.request_focus();
-                    crate::widgets::select_all_on_focus(ui, &r, &q);
-                    ui.add_space(4.0);
-                    let ql = q.to_lowercase();
-                    // Labels match in the UI language and in English.
-                    let matches =
-                        |label: &str, english: &str, id: &str| ql.is_empty() || [label, english, id].iter().any(|s| s.to_lowercase().contains(&ql));
-                    let mut hits: Vec<(&str, std::borrow::Cow<str>, &str)> = Vec::new();
-                    let menu_items = MENU.iter().filter(|m| UI_COMMANDS.contains(&m.id)).map(|m| (m.id, m.label));
-                    for (id, english) in figcraft_engine::all_commands().iter().map(|c| (c.id, c.label)).chain(menu_items) {
-                        let label = i18n::command(id, english);
-                        if matches(&label, english, id) {
-                            hits.push((id, label, crate::shortcuts::shortcut(id).unwrap_or("")));
+    // A press anywhere outside closes the panel. The opening press is spared once, and the
+    // spare expires the first frame without a press (so the next outside press always closes).
+    let pressed = ctx.input(|i| i.pointer.any_pressed());
+    if pressed && !std::mem::replace(&mut app.ui.palette_armed, false) {
+        let on_toggle = app.ui.actions_rect.is_some_and(|b| ctx.input(|i| i.pointer.hover_pos().is_some_and(|p| b.contains(p))));
+        let outside = !on_toggle && ctx.input(|i| i.pointer.hover_pos().map(|p| !area.contains(p)).unwrap_or(false));
+        if outside {
+            close = true;
+        }
+    } else if !pressed {
+        app.ui.palette_armed = false;
+    }
+    // Taken before the search field sees them (it would move its cursor).
+    let step = ctx.input_mut(|i| {
+        i.count_and_consume_key(egui::Modifiers::NONE, egui::Key::ArrowDown) as i64
+            - i.count_and_consume_key(egui::Modifiers::NONE, egui::Key::ArrowUp) as i64
+    });
+    egui::Area::new(Id::new("palette")).fixed_pos(area.min).order(egui::Order::Foreground).show(ctx, |ui| {
+        egui::Frame::NONE
+            .fill(t.panel)
+            .corner_radius(CornerRadius::same(13))
+            .stroke(Stroke::new(1.0, t.border))
+            .shadow(egui::Shadow { offset: [0, 8], blur: 32, spread: 0, color: t.shadow })
+            .inner_margin(egui::Margin::same(8))
+            .show(ui, |ui| {
+                // Same outer width as the toolbar pill, and a fixed height: switching tabs
+                // never resizes the panel.
+                let inner = bar_w - 16.0;
+                ui.set_width(inner);
+                ui.set_height(PALETTE_H);
+                let r = ui.add(
+                    egui::TextEdit::singleline(&mut q)
+                        .hint_text(tr("Search actions, layers and tools"))
+                        .desired_width(inner - 16.0)
+                        .font(regular(14.0))
+                        .frame(egui::Frame::NONE.inner_margin(egui::Margin::same(8))),
+                );
+                r.request_focus();
+                crate::widgets::select_all_on_focus(ui, &r, &q);
+                // A new search starts again at the first row.
+                if r.changed() {
+                    app.ui.palette_hi = 0;
+                }
+                ui.add_space(4.0);
+                // Tabs: All, Assets, Plugins & widgets.
+                let tabs = [(PaletteTab::All, tr("All")), (PaletteTab::Assets, tr("Assets")), (PaletteTab::Plugins, tr("Plugins & widgets"))];
+                ui.horizontal(|ui| {
+                    ui.spacing_mut().item_spacing = vec2(4.0, 0.0);
+                    for (tab, label) in tabs {
+                        let active = app.ui.palette_tab == tab;
+                        // The frame stays on for every tab (transparent when idle) so the
+                        // active pill never moves its neighbours.
+                        let resp = ui.add(
+                            egui::Button::new(egui::RichText::new(label).size(12.0).color(if active { t.text } else { t.text_secondary }))
+                                .frame(true)
+                                .fill(if active { t.hover } else { Color32::TRANSPARENT })
+                                .corner_radius(CornerRadius::same(6)),
+                        );
+                        if resp.clicked() {
+                            app.ui.palette_tab = tab;
+                            app.ui.palette_hi = 0;
                         }
                     }
-                    hits.sort_by_key(|h| (!h.1.to_lowercase().starts_with(&ql), h.1.len()));
-                    hits.dedup_by(|a, b| a.0 == b.0);
-                    let enter = ui.input(|i| i.key_pressed(egui::Key::Enter));
-                    egui::ScrollArea::vertical().max_height(360.0).show(ui, |ui| {
-                        for (i, (id, label, sc)) in hits.iter().take(60).enumerate() {
-                            let w = ui.available_width();
-                            let (r, resp) = ui.allocate_exact_size(vec2(w, 30.0), Sense::click());
-                            if resp.hovered() || i == 0 {
-                                ui.painter().rect_filled(r, CornerRadius::same(5), if resp.hovered() { ACCENT } else { t.hover });
-                            }
-                            let col = if resp.hovered() { Color32::WHITE } else { t.text };
-                            ui.painter().text(pos2(r.min.x + 10.0, r.center().y), Align2::LEFT_CENTER, label.as_ref(), regular(12.0), col);
-                            ui.painter().text(
-                                pos2(r.max.x - 10.0, r.center().y),
-                                Align2::RIGHT_CENTER,
-                                pretty_shortcut(sc),
-                                regular(11.0),
-                                if resp.hovered() { Color32::WHITE } else { t.text_secondary },
-                            );
-                            if resp.clicked() || (enter && i == 0) {
-                                run = Some(id.to_string());
-                            }
-                        }
-                    });
                 });
-        },
-    );
+                ui.add_space(4.0);
+                let sections = palette_sections(app, &q, app.ui.palette_tab);
+                let count = sections.iter().map(|(_, rows)| rows.len()).sum::<usize>();
+                // At either end it stays where it was.
+                let hi = (app.ui.palette_hi as i64 + step).clamp(0, count.saturating_sub(1) as i64) as usize;
+                app.ui.palette_hi = hi;
+                // The pointer moving over a row moves the highlight there.
+                let pointer_moved = ui.input(|i| i.pointer.delta() != egui::Vec2::ZERO);
+                egui::ScrollArea::vertical().max_height(360.0).show(ui, |ui| {
+                    let mut i = 0;
+                    for (name, rows) in &sections {
+                        section(ui, &t, name, |ui| {
+                            for row in rows {
+                                let resp = draw_row(ui, &t, row, i == hi);
+                                if resp.clicked() {
+                                    run = Some(row.key.clone());
+                                }
+                                if pointer_moved && resp.hovered() && i != hi {
+                                    app.ui.palette_hi = i;
+                                    // Drawn there on the next frame, even if the pointer stops now.
+                                    ui.ctx().request_repaint();
+                                }
+                                if step != 0 && i == hi {
+                                    resp.scroll_to_me(None);
+                                }
+                                i += 1;
+                            }
+                        });
+                    }
+                });
+                if run.is_none() && ui.input(|i| i.key_pressed(egui::Key::Enter)) {
+                    run = sections.iter().flat_map(|(_, rows)| rows).nth(hi).map(|row| row.key.clone());
+                }
+            });
+    });
     if ctx.input(|i| i.key_pressed(egui::Key::Escape)) {
         close = true;
     }
-    if let Some(id) = run {
+    if let Some(key) = run {
         app.ui.palette = None;
-        invoke(app, &id);
+        run_action(app, &key);
         return;
     }
     app.ui.palette = if close { None } else { Some(q) };
     let _ = StrokeKind::Inside;
 }
+
+/// The rows a palette tab shows for the query, by section: All has Recents, the commands by menu,
+/// then plugins and widgets; Assets this file's components and styles; Plugins & widgets those.
+pub(crate) fn palette_sections(app: &FigApp, q: &str, tab: PaletteTab) -> Vec<(String, Vec<ActionRow>)> {
+    let mut out = match tab {
+        PaletteTab::All => {
+            let recents = app.session.prefs.recent_actions.iter().filter_map(|key| recent_row(app, key, q)).collect();
+            let mut out = vec![(tr("Recents").to_string(), recents)];
+            out.extend(command_sections(q));
+            out
+        }
+        PaletteTab::Assets => asset_sections(app, q),
+        PaletteTab::Plugins => Vec::new(),
+    };
+    if tab != PaletteTab::Assets {
+        out.push((tr("Plugins").to_string(), plugin_rows(app, q)));
+        out.push((tr("Widgets").to_string(), widget_rows(app, q)));
+    }
+    out.retain(|(_, rows)| !rows.is_empty());
+    out
+}
+
+/// Run a palette row: `command:<id>`, `plugin:<plugin>/<command>`, `widget:<plugin>`,
+/// `component:<node>` or `style:<id>`.
+pub(crate) fn run_action(app: &mut FigApp, key: &str) {
+    if let Some(id) = key.strip_prefix("command:") {
+        record_recent(app, key);
+        invoke(app, id);
+    } else if let Some(rest) = key.strip_prefix("plugin:") {
+        if let Some((plugin, command)) = rest.split_once('/') {
+            record_recent(app, key);
+            crate::plugins_ui::start(app, plugin, command);
+        }
+    } else if let Some(plugin) = key.strip_prefix("widget:") {
+        record_recent(app, key);
+        app.run("widget.insert", json!({ "plugin": plugin }));
+    } else if let Some(node) = key.strip_prefix("component:") {
+        if let Ok(n) = node.parse::<u64>() {
+            let (cx, cy) = app.session.ds().map(|d| (d.view.cx, d.view.cy)).unwrap_or((0.0, 0.0));
+            app.run("instance.place", json!({ "component": n, "x": cx, "y": cy }));
+        }
+    } else if let Some(style) = key.strip_prefix("style:") {
+        if app.session.selection().is_empty() {
+            app.toast(tr("Select layers to apply the style to"));
+        } else {
+            app.run("style.apply", json!({ "style": style }));
+        }
+    }
+}
+
+/// One pickable palette row.
+pub(crate) struct ActionRow {
+    pub(crate) key: String,
+    pub(crate) label: String,
+    hint: String,
+    /// A letter tile instead of an icon (plugins carry no artwork).
+    tile: Option<char>,
+}
+
+/// A section header with its rows.
+fn section(ui: &mut Ui, t: &Tokens, name: &str, rows: impl FnOnce(&mut Ui)) {
+    ui.add_space(10.0);
+    ui.painter().text(pos2(ui.min_rect().min.x + 10.0, ui.cursor().min.y + 8.0), Align2::LEFT_TOP, name, regular(12.5), t.text_secondary);
+    ui.add_space(22.0);
+    rows(ui);
+}
+
+/// Draw one row (a letter tile for plugins, else just the label) with its right-side hint,
+/// `highlighted` when Enter runs it.
+fn draw_row(ui: &mut Ui, t: &Tokens, row: &ActionRow, highlighted: bool) -> egui::Response {
+    let w = ui.available_width();
+    let (r, resp) = ui.allocate_exact_size(vec2(w, 34.0), Sense::click());
+    // The highlight pill stays inside the row: it never touches the panel's edges.
+    let pill = r.shrink2(vec2(4.0, 1.0));
+    if highlighted {
+        ui.painter().rect_filled(pill, CornerRadius::same(6), t.hover);
+    }
+    let mut label_x = r.min.x + 10.0;
+    if let Some(letter) = row.tile {
+        let tile = Rect::from_center_size(pos2(r.min.x + 20.0, r.center().y), vec2(18.0, 18.0));
+        ui.painter().rect_filled(tile, CornerRadius::same(5), t.hover);
+        ui.painter().text(tile.center(), Align2::CENTER_CENTER, letter.to_string(), regular(11.0), t.text);
+        label_x = r.min.x + 38.0;
+    }
+    ui.painter().text(pos2(label_x, r.center().y), Align2::LEFT_CENTER, &row.label, regular(13.0), t.text);
+    ui.painter().text(pos2(r.max.x - 10.0, r.center().y), Align2::RIGHT_CENTER, &row.hint, regular(11.0), t.text_secondary);
+    resp
+}
+
+/// Whether `label` (or `extra`) matches the query, in any case.
+fn matches(q: &str, label: &str, extra: &str) -> bool {
+    q.is_empty() || label.to_lowercase().contains(q) || extra.to_lowercase().contains(q)
+}
+
+/// A command's row: its label, and its shortcut as the hint.
+fn command_row(id: &str, label: String) -> ActionRow {
+    ActionRow { key: format!("command:{id}"), label, hint: crate::shortcuts::shortcut(id).map(pretty_shortcut).unwrap_or_default(), tile: None }
+}
+
+/// Most rows a search shows (the best matches).
+const MAX_HITS: usize = 60;
+
+/// Commands grouped by top-level menu, filtered by the query. Without one, the menus' items in
+/// catalog order; a search covers every command (the engine's and the UI's own, "Other" for those
+/// no menu lists), best matches first (labels starting with the query, then the shortest), each
+/// group placed by its best row. Labels match in the UI language and in English. The Plugins
+/// menu's items come with the plugins ([`plugin_rows`]).
+pub(crate) fn command_sections(q: &str) -> Vec<(String, Vec<ActionRow>)> {
+    let ql = q.trim().to_lowercase();
+    let mut menu_of = std::collections::HashMap::new();
+    for m in MENU.iter().filter(|m| m.label != SEP) {
+        menu_of.entry(m.id).or_insert(m);
+    }
+    let menu_items = MENU.iter().filter(|m| m.label != SEP).map(|m| (m.id, m.label));
+    let engine = figcraft_engine::all_commands().iter().map(|c| (c.id, c.label));
+    let candidates: Box<dyn Iterator<Item = (&str, &str)>> = if ql.is_empty() { Box::new(menu_items) } else { Box::new(menu_items.chain(engine)) };
+    let mut seen = std::collections::HashSet::new();
+    // By top-level menu; `None`: no menu lists it.
+    let mut hits: Vec<(Option<&str>, ActionRow)> = Vec::new();
+    for (id, english) in candidates {
+        if !available(id) || !seen.insert(id) {
+            continue;
+        }
+        let menu = menu_of.get(id);
+        let group = menu.map(|m| m.menu.split('/').next().unwrap_or(m.menu));
+        if group == Some("Plugins") {
+            continue;
+        }
+        let label = match menu {
+            Some(m) => i18n::menu_item(id, m.label),
+            None => i18n::command(id, english),
+        };
+        if matches(&ql, &label, &format!("{english} {id}")) {
+            hits.push((group, command_row(id, label.into_owned())));
+        }
+    }
+    if !ql.is_empty() {
+        hits.sort_by_cached_key(|(_, row)| (!row.label.to_lowercase().starts_with(&ql), row.label.chars().count()));
+        hits.truncate(MAX_HITS);
+    }
+    let mut groups: Vec<(String, Vec<ActionRow>)> = Vec::new();
+    for (group, row) in hits {
+        let group = group.map_or_else(|| tr("Other"), tr).to_string();
+        match groups.iter_mut().find(|(g, _)| *g == group) {
+            Some((_, rows)) => rows.push(row),
+            None => groups.push((group, vec![row])),
+        }
+    }
+    groups
+}
+
+/// Installed plugins' commands, filtered by the query.
+fn plugin_rows(app: &FigApp, q: &str) -> Vec<ActionRow> {
+    let ql = q.to_lowercase();
+    let mut rows = Vec::new();
+    for p in &app.session.prefs.plugins {
+        let m = &p.manifest;
+        for c in &m.commands {
+            let label = if m.commands.len() == 1 { m.name.clone() } else { format!("{} — {}", m.name, c.label) };
+            if !matches(&ql, &label, &m.id) {
+                continue;
+            }
+            rows.push(ActionRow {
+                key: format!("plugin:{}/{}", m.id, c.id),
+                label,
+                hint: if c.params.is_empty() { tr("Plugin").to_string() } else { c.label.clone() },
+                tile: m.name.chars().next(),
+            });
+        }
+    }
+    // The Plugins menu's own items (run last, manage, import).
+    for m in MENU.iter().filter(|m| m.label != SEP && m.menu.split('/').next() == Some("Plugins") && available(m.id)) {
+        let label = i18n::menu_item(m.id, m.label);
+        if matches(&ql, &label, &format!("{} {}", m.label, m.id)) {
+            rows.push(command_row(m.id, label.into_owned()));
+        }
+    }
+    rows
+}
+
+/// Installed widgets, filtered by the query.
+fn widget_rows(app: &FigApp, q: &str) -> Vec<ActionRow> {
+    let ql = q.to_lowercase();
+    app.session
+        .prefs
+        .plugins
+        .iter()
+        .filter(|p| p.manifest.widget)
+        .filter(|p| matches(&ql, &p.manifest.name, &p.manifest.id))
+        .map(|p| ActionRow {
+            key: format!("widget:{}", p.manifest.id),
+            label: p.manifest.name.clone(),
+            hint: tr("Widget").to_string(),
+            tile: p.manifest.name.chars().next(),
+        })
+        .collect()
+}
+
+/// This file's components and styles, filtered by the query.
+fn asset_sections(app: &FigApp, q: &str) -> Vec<(String, Vec<ActionRow>)> {
+    let ql = q.to_lowercase();
+    let Ok(doc) = app.session.doc() else { return Vec::new() };
+    let components: Vec<ActionRow> = figcraft_engine::library::local_components(doc)
+        .iter()
+        .filter_map(|id| doc.node(*id))
+        .filter(|n| matches(&ql, &n.name, ""))
+        .map(|n| ActionRow { key: format!("component:{}", n.id.0), label: n.name.clone(), hint: tr("Component").to_string(), tile: None })
+        .collect();
+    let styles: Vec<ActionRow> = figcraft_engine::library::local_styles(doc)
+        .filter(|s| matches(&ql, &s.name, ""))
+        .map(|s| ActionRow { key: format!("style:{}", s.id), label: s.name.clone(), hint: tr("Style").to_string(), tile: None })
+        .collect();
+    let mut out = Vec::new();
+    if !components.is_empty() {
+        out.push((tr("Components").to_string(), components));
+    }
+    if !styles.is_empty() {
+        out.push((tr("Styles").to_string(), styles));
+    }
+    out
+}
+
+/// A recent action back as a row (gone commands, plugins or assets drop out).
+pub(crate) fn recent_row(app: &FigApp, key: &str, q: &str) -> Option<ActionRow> {
+    let ql = q.to_lowercase();
+    if let Some(id) = key.strip_prefix("command:") {
+        let spec = figcraft_engine::find_command(id);
+        let menu_label = figcraft_engine::catalog::MENU.iter().find(|m| m.id == id);
+        let english = menu_label.map(|m| m.label).or_else(|| spec.map(|s| s.label)).unwrap_or(id);
+        let label = i18n::command(id, english);
+        if !available(id) || !matches(&ql, &label, &format!("{english} {id}")) {
+            return None;
+        }
+        return Some(command_row(id, label.into_owned()));
+    }
+    if let Some(rest) = key.strip_prefix("plugin:") {
+        let (pid, cid) = rest.split_once('/')?;
+        let p = app.session.prefs.plugins.iter().find(|p| p.manifest.id == pid)?;
+        let c = p.manifest.commands.iter().find(|c| c.id == cid)?;
+        let label = if p.manifest.commands.len() == 1 { p.manifest.name.clone() } else { format!("{} — {}", p.manifest.name, c.label) };
+        if !matches(&ql, &label, pid) {
+            return None;
+        }
+        return Some(ActionRow { key: key.to_string(), label, hint: tr("Plugin").to_string(), tile: p.manifest.name.chars().next() });
+    }
+    if let Some(pid) = key.strip_prefix("widget:") {
+        let p = app.session.prefs.plugins.iter().find(|p| p.manifest.id == pid && p.manifest.widget)?;
+        if !matches(&ql, &p.manifest.name, pid) {
+            return None;
+        }
+        return Some(ActionRow {
+            key: key.to_string(),
+            label: p.manifest.name.clone(),
+            hint: tr("Widget").to_string(),
+            tile: p.manifest.name.chars().next(),
+        });
+    }
+    None
+}
diff --git a/crates/ui-egui/src/missing_fonts.rs b/crates/ui-egui/src/missing_fonts.rs
new file mode 100644
index 000000000..b6c794777
--- /dev/null
+++ b/crates/ui-egui/src/missing_fonts.rs
@@ -0,0 +1,115 @@
+//! The Missing fonts window (#752): the fonts a file uses that aren't installed, whose text is
+//! drawn in a fallback font. It opens by itself after the user opens a file that has any (once
+//! the installed fonts are indexed and any import report is closed), and from Text ▸ Missing fonts.
+
+use egui::RichText;
+use figcraft_engine::fonts::{Missing, missing};
+use serde_json::{Value, json};
+
+use crate::FigApp;
+use crate::i18n::{tr, trn};
+use crate::theme::{Tokens, regular};
+
+#[derive(Clone, Debug)]
+pub struct Shown {
+    /// The document it lists: the window goes when that document closes.
+    pub uid: u64,
+    pub families: Vec<Missing>,
+    /// Asked for before the installed fonts were indexed: the list comes once they are.
+    pub indexing: bool,
+}
+
+impl Shown {
+    pub fn inspect(&self) -> Value {
+        json!({
+            "families": self.families.iter().map(|m| json!({"family": m.family, "layers": m.layers})).collect::<Vec<_>>(),
+            "indexing": self.indexing,
+        })
+    }
+}
+
+/// After the user opened a file, or imported pages into one (results with a `summary`; not a
+/// placed image or SVG, a file that was open already, or Clear recent): look for missing fonts in
+/// it once that can be told ([`show`]). Not in the browser, which has only its built-in fonts.
+pub fn check_later(app: &mut FigApp, command: &str, result: Option<&Value>) {
+    if !cfg!(target_arch = "wasm32")
+        && matches!(command, "file.open" | "file.openRecent" | "file.import")
+        && result.is_some_and(|r| r.get("summary").is_some())
+        && let Ok(ds) = app.session.ds()
+    {
+        app.ui.font_checks.push(ds.uid);
+    }
+}
+
+/// The window for document `uid`, listing what it misses (even nothing, when asked for).
+fn list(app: &mut FigApp, uid: u64) -> Option<Vec<Missing>> {
+    let ds = app.session.docs.iter().find(|d| d.uid == uid)?;
+    let families = missing(&ds.doc);
+    app.ui.missing_fonts = Some(Shown { uid, families: families.clone(), indexing: false });
+    Some(families)
+}
+
+/// Text ▸ Missing fonts (`dialog.missingFonts`): the window for the file in front.
+pub fn request(app: &mut FigApp) {
+    let Ok(uid) = app.session.ds().map(|d| d.uid) else { return };
+    if figcraft_text::installed_fonts_known() {
+        list(app, uid);
+    } else {
+        app.ui.missing_fonts = Some(Shown { uid, families: Vec::new(), indexing: true });
+    }
+}
+
+pub fn show(app: &mut FigApp, ctx: &egui::Context) {
+    // Whether the installed fonts are indexed is asked only while a list waits for it.
+    let waiting = app.ui.missing_fonts.as_ref().filter(|m| m.indexing).map(|m| m.uid);
+    if (waiting.is_some() || !app.ui.font_checks.is_empty()) && figcraft_text::installed_fonts_known() {
+        if let Some(uid) = waiting {
+            list(app, uid);
+        }
+        if !app.ui.font_checks.is_empty() && app.ui.import_report.is_none() && app.ui.missing_fonts.is_none() {
+            let uid = app.ui.font_checks.remove(0);
+            if list(app, uid).is_some_and(|f| f.is_empty()) {
+                app.ui.missing_fonts = None;
+            }
+        }
+    }
+    if app.ui.missing_fonts.as_ref().is_some_and(|m| !app.session.docs.iter().any(|d| d.uid == m.uid)) {
+        app.ui.missing_fonts = None;
+    }
+    let Some(shown) = &app.ui.missing_fonts else { return };
+    let t = Tokens::get(ctx);
+    let mut open = true;
+    let mut close_clicked = false;
+    crate::dialogs::window(tr("Missing fonts"), ctx).open(&mut open).show(ctx, |ui| {
+        ui.set_width(380.0);
+        if shown.indexing {
+            ui.label(tr("Checking the fonts installed on this computer…"));
+        } else if shown.families.is_empty() {
+            ui.label(tr("All the fonts this file uses are installed"));
+        } else {
+            ui.label(
+                RichText::new(tr(
+                    "This file uses fonts that aren't installed on this computer. Their text is drawn in a fallback font until you install them.",
+                ))
+                .color(t.text_secondary)
+                .font(regular(11.0)),
+            );
+            ui.add_space(6.0);
+            egui::ScrollArea::vertical().id_salt("missing_fonts").max_height(260.0).show(ui, |ui| {
+                for m in &shown.families {
+                    ui.horizontal(|ui| {
+                        ui.label(RichText::new(&m.family).strong());
+                        let used =
+                            if m.layers == 0 { tr("only in a text style or variable").to_string() } else { trn("{n} text layers", m.layers, &[]) };
+                        ui.label(RichText::new(used).color(t.text_secondary));
+                    });
+                }
+            });
+        }
+        ui.add_space(12.0);
+        close_clicked = crate::widgets::button(ui, tr("Close"), true, true).clicked();
+    });
+    if !open || close_clicked {
+        app.ui.missing_fonts = None;
+    }
+}
diff --git a/crates/ui-egui/src/missing_fonts_tests.rs b/crates/ui-egui/src/missing_fonts_tests.rs
new file mode 100644
index 000000000..2b11260a4
--- /dev/null
+++ b/crates/ui-egui/src/missing_fonts_tests.rs
@@ -0,0 +1,149 @@
+use figcraft_engine::Session;
+use serde_json::{Value, json};
+
+use crate::import_report::Report;
+use crate::layers_drag_tests::Ui;
+
+/// A saved file with text in `families` (the first two layers share the first family).
+fn saved(name: &str, families: &[&str]) -> String {
+    let mut s = Session::new();
+    for (i, f) in families.iter().chain(families.first()).enumerate() {
+        s.execute("text.create", &json!({"text": "Hamburgefonstiv", "x": 0, "y": 40 * i, "props": {"fontFamily": f}})).unwrap();
+    }
+    let path = std::env::temp_dir().join(format!("figcraft-missing-fonts-{name}-{}.figcraft", std::process::id()));
+    let path = path.to_string_lossy().into_owned();
+    s.execute("file.saveAs", &json!({"path": path})).unwrap();
+    path
+}
+
+/// The installed fonts are indexed, as the desktop app does at startup.
+fn fonts_indexed() -> bool {
+    figcraft_text::scan_system_fonts();
+    figcraft_text::installed_fonts_known()
+}
+
+fn listed(u: &Ui) -> Value {
+    u.app.inspect()["missingFonts"].clone()
+}
+
+#[test]
+fn opening_a_file_lists_its_missing_fonts_and_not_the_installed_ones() {
+    if !fonts_indexed() {
+        eprintln!("skipped: system fonts opted out");
+        return;
+    }
+    let installed = figcraft_text::family_names().into_iter().next();
+    let mut families = vec!["FigCraft Missing UI"];
+    families.extend(installed.as_deref());
+    let path = saved("open", &families);
+    let mut u = Ui::new(Session::new());
+    // Programmatic opens (control channel, MCP, scripts) never open the window.
+    u.app.run("file.open", json!({"path": path}));
+    u.frame(vec![]);
+    assert_eq!(listed(&u), Value::Null);
+    u.app.run("file.close", json!({}));
+
+    u.app.run_user("file.open", json!({"path": path}));
+    std::fs::remove_file(&path).unwrap();
+    u.frame(vec![]);
+    assert_eq!(listed(&u), json!({"families": [{"family": "FigCraft Missing UI", "layers": 2}], "indexing": false}));
+    u.frame(vec![]);
+    let shown = u.frame_output(vec![]).shapes;
+    assert!(crate::import_report_tests::shown_texts(shown).iter().any(|t| t == "2 text layers"));
+
+    // It goes with its file.
+    u.app.run("file.close", json!({}));
+    u.frame(vec![]);
+    assert_eq!(listed(&u), Value::Null);
+}
+
+#[test]
+fn a_file_without_missing_fonts_opens_no_window() {
+    if !fonts_indexed() {
+        eprintln!("skipped: system fonts opted out");
+        return;
+    }
+    let Some(installed) = figcraft_text::family_names().into_iter().next() else {
+        eprintln!("skipped: no fonts on this machine");
+        return;
+    };
+    let path = saved("clean", &[&installed]);
+    let mut u = Ui::new(Session::new());
+    u.app.run_user("file.open", json!({"path": path}));
+    std::fs::remove_file(&path).unwrap();
+    u.frame(vec![]);
+    assert_eq!(listed(&u), Value::Null);
+    assert!(u.app.ui.font_checks.is_empty(), "the check ran");
+}
+
+#[test]
+fn it_waits_for_the_import_report_to_close() {
+    if !fonts_indexed() {
+        eprintln!("skipped: system fonts opted out");
+        return;
+    }
+    let path = saved("report", &["FigCraft Missing Report"]);
+    let mut u = Ui::new(Session::new());
+    u.app.run_user("file.open", json!({"path": path}));
+    std::fs::remove_file(&path).unwrap();
+    let mut report =
+        Report::from_result("file.open", &json!({}), &json!({"warnings": ["Synthetic note"], "summary": {"name": "Synthetic"}})).unwrap();
+    report.uid = u.app.session.ds().unwrap().uid;
+    u.app.ui.import_report = Some(report);
+    u.frame(vec![]);
+    assert_eq!(listed(&u), Value::Null, "the import report comes first");
+    u.app.ui.import_report = None;
+    u.frame(vec![]);
+    assert_eq!(listed(&u)["families"][0]["family"], "FigCraft Missing Report");
+}
+
+#[test]
+fn text_menu_shows_the_window_for_the_file_in_front_even_with_nothing_missing() {
+    assert!(fonts_indexed());
+    let mut u = Ui::new(Session::new());
+    assert!(u.app.run("text.missingFonts", json!({})).is_some());
+    assert_eq!(listed(&u), json!({"families": [], "indexing": false}));
+    u.frame(vec![]);
+    let shown = u.frame_output(vec![]).shapes;
+    assert!(crate::import_report_tests::shown_texts(shown).iter().any(|t| t == "All the fonts this file uses are installed"));
+    let escape =
+        vec![egui::Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: egui::Modifiers::NONE }];
+    u.frame(escape);
+    assert_eq!(listed(&u), Value::Null, "Escape closes it");
+}
+
+#[test]
+fn asked_for_before_the_fonts_are_indexed_it_lists_them_once_they_are() {
+    assert!(fonts_indexed());
+    let path = saved("indexing", &["FigCraft Missing Indexing"]);
+    let mut u = Ui::new(Session::new());
+    u.app.run("file.open", json!({"path": path}));
+    std::fs::remove_file(&path).unwrap();
+    // As Text ▸ Missing fonts leaves it while the startup scan is still running.
+    let uid = u.app.session.ds().unwrap().uid;
+    u.app.ui.missing_fonts = Some(crate::missing_fonts::Shown { uid, families: Vec::new(), indexing: true });
+    u.frame(vec![]);
+    assert_eq!(listed(&u), json!({"families": [{"family": "FigCraft Missing Indexing", "layers": 2}], "indexing": false}));
+}
+
+#[test]
+fn placing_images_or_clearing_recents_does_not_bring_it_back() {
+    assert!(fonts_indexed());
+    let path = saved("place", &["FigCraft Missing Place"]);
+    let svg = std::env::temp_dir().join(format!("figcraft-missing-fonts-place-{}.svg", std::process::id()));
+    std::fs::write(&svg, r#"<svg xmlns="http://www.w3.org/2000/svg" width="10" height="10"><rect width="10" height="10"/></svg>"#).unwrap();
+    let mut u = Ui::new(Session::new());
+    u.app.run_user("file.open", json!({"path": path}));
+    u.frame(vec![]);
+    assert_eq!(listed(&u)["families"][0]["family"], "FigCraft Missing Place");
+    u.app.ui.missing_fonts = None;
+    // A placed SVG, the same file opened again (it only comes to the front), Clear recent.
+    assert!(u.app.run_user("file.import", json!({"path": svg.to_string_lossy()})).is_some());
+    assert!(u.app.run_user("file.open", json!({"path": path})).is_some());
+    u.app.run_user("file.openRecent", json!({"clear": true}));
+    std::fs::remove_file(&path).unwrap();
+    std::fs::remove_file(&svg).unwrap();
+    u.frame(vec![]);
+    assert!(u.app.ui.font_checks.is_empty());
+    assert_eq!(listed(&u), Value::Null);
+}
diff --git a/crates/ui-egui/src/online.rs b/crates/ui-egui/src/online.rs
index 261424cb0..2f054986d 100644
--- a/crates/ui-egui/src/online.rs
+++ b/crates/ui-egui/src/online.rs
@@ -72,7 +72,7 @@ fn manage(app: &mut FigApp, ctx: &egui::Context, f: (&str, &str), action: &str,
 }
 
 /// Open recorded file `f` as its owner; its tab shows once the file arrives.
-fn open(app: &mut FigApp, f: &OnlineFile) {
+pub(crate) fn open(app: &mut FigApp, f: &OnlineFile) {
     let Some(r) = app.run("collab.openFile", json!({"server": f.server, "file": f.file})) else { return };
     if r["alreadyOpen"] == true && !r["document"].is_null() {
         app.ui.home = false;
diff --git a/crates/ui-egui/src/padding_individual_tests.rs b/crates/ui-egui/src/padding_individual_tests.rs
new file mode 100644
index 000000000..bc95886e9
--- /dev/null
+++ b/crates/ui-egui/src/padding_individual_tests.rs
@@ -0,0 +1,114 @@
+//! Individual padding in the Design panel, driven headless: the four side fields only
+//! appear once the toggle opens, and typing in one sets that side alone.
+
+use egui::accesskit::Role;
+use egui::{Event, Id, Key, Modifiers, Pos2, pos2};
+use figcraft_doc::NodeId;
+use figcraft_engine::Session;
+use serde_json::json;
+
+use crate::layers_drag_tests::Ui;
+
+/// An auto layout frame with uniform padding 10, selected.
+fn scene() -> (Ui, NodeId) {
+    let mut s = Session::new();
+    let f =
+        NodeId(
+            s.execute("frame.create", &json!({"x": 0, "y": 0, "width": 300, "height": 200, "props": {"layout": "horizontal", "padding": 10}}))
+                .unwrap()["id"]
+                .as_u64()
+                .unwrap(),
+        );
+    s.execute("select.set", &json!({"ids": [f]})).unwrap();
+    (Ui::new(s), f)
+}
+
+/// The frame's padding as `[top, right, bottom, left]`.
+fn padding(u: &Ui, f: NodeId) -> [f64; 4] {
+    u.app.session.doc().unwrap().node(f).unwrap().layout.clone().unwrap().padding
+}
+
+/// A full press-and-release at `p`, then settling one frame.
+fn click(u: &mut Ui, p: Pos2) {
+    u.button(p, true);
+    u.button(p, false);
+    u.frame(vec![]);
+}
+
+/// A press-and-release of Enter, committing the focused number field.
+fn enter(u: &mut Ui) {
+    u.frame(vec![
+        Event::Key { key: Key::Enter, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE },
+        Event::Key { key: Key::Enter, physical_key: None, pressed: false, repeat: false, modifiers: Modifiers::NONE },
+    ]);
+}
+
+/// The middle of the toggle button named `label`, found in the AccessKit tree.
+fn named_button(u: &mut Ui, label: &str) -> Pos2 {
+    u.ctx.enable_accesskit();
+    u.frame(vec![]);
+    let out = u.frame_output(vec![]);
+    let nodes = out.platform_output.accesskit_update.expect("an AccessKit update").nodes;
+    let n = nodes.iter().map(|(_, n)| n).find(|n| n.role() == Role::Button && n.label() == Some(label)).expect(label);
+    let b = n.bounds().expect("bounds");
+    pos2(((b.x0 + b.x1) / 2.0) as f32, ((b.y0 + b.y1) / 2.0) as f32)
+}
+
+/// The side fields stay hidden until the toggle opens, then typing in one sets
+/// that side alone in a single undo step.
+#[test]
+fn side_fields_show_only_once_the_toggle_opens_and_set_one_side() {
+    let (mut u, f) = scene();
+    assert_eq!(padding(&u, f), [10.0; 4]);
+    // Shut: no per-side fields.
+    assert!(u.ctx.read_response(Id::new(("padding", 0)).with("field")).is_none(), "top field hidden until toggled");
+    // Click the toggle: the four sides appear.
+    let t = named_button(&mut u, "Individual padding");
+    click(&mut u, t);
+    let top = u.ctx.read_response(Id::new(("padding", 0)).with("field")).expect("top field shows").rect.center();
+    assert!(u.ctx.read_response(Id::new(("padding", 3)).with("field")).is_some(), "left field shows");
+    // Typing in the top field sets only the top, in one undo step.
+    let history = u.app.session.undo_depth().0;
+    click(&mut u, top);
+    u.frame(vec![Event::Text("8".into())]);
+    enter(&mut u);
+    u.frame(vec![]);
+    assert_eq!(padding(&u, f), [8.0, 10.0, 10.0, 10.0]);
+    assert_eq!(u.app.session.undo_depth().0, history + 1);
+    u.app.run("edit.undo", json!({}));
+    assert_eq!(padding(&u, f), [10.0; 4]);
+}
+
+/// The middle of the shut pair field with accessible name `label`.
+fn named_field(u: &mut Ui, label: &str) -> Pos2 {
+    u.ctx.enable_accesskit();
+    u.frame(vec![]);
+    let out = u.frame_output(vec![]);
+    let nodes = out.platform_output.accesskit_update.expect("an AccessKit update").nodes;
+    let n = nodes.iter().map(|(_, n)| n).find(|n| n.role() != Role::Button && n.label() == Some(label)).expect(label);
+    let b = n.bounds().expect("bounds");
+    pos2(((b.x0 + b.x1) / 2.0) as f32, ((b.y0 + b.y1) / 2.0) as f32)
+}
+
+/// The shut pair fields read Mixed when their sides disagree and edit their own axis: horizontal
+/// touches left and right only, vertical touches top and bottom only.
+#[test]
+fn shut_pair_fields_edit_their_own_axis() {
+    let (mut u, f) = scene();
+    u.app.run("node.set", json!({"ids": [f], "props": {"paddingLeft": 16.0, "paddingRight": 54.0}}));
+    assert_eq!(padding(&u, f), [10.0, 54.0, 10.0, 16.0]);
+    let shown = crate::live_tests::texts(&crate::live_tests::flat(&u.frame_output(vec![]).shapes));
+    assert!(shown.iter().any(|(t, _, _)| t == "Mixed"), "sides that disagree read Mixed: {shown:?}");
+    let h = named_field(&mut u, "Horizontal padding");
+    click(&mut u, h);
+    u.frame(vec![Event::Text("20".into())]);
+    enter(&mut u);
+    u.frame(vec![]);
+    assert_eq!(padding(&u, f), [10.0, 20.0, 10.0, 20.0]);
+    let v = named_field(&mut u, "Vertical padding");
+    click(&mut u, v);
+    u.frame(vec![Event::Text("7".into())]);
+    enter(&mut u);
+    u.frame(vec![]);
+    assert_eq!(padding(&u, f), [7.0, 20.0, 7.0, 20.0]);
+}
diff --git a/crates/ui-egui/src/palette_tests.rs b/crates/ui-egui/src/palette_tests.rs
new file mode 100644
index 000000000..cfe9c1cd2
--- /dev/null
+++ b/crates/ui-egui/src/palette_tests.rs
@@ -0,0 +1,163 @@
+//! The Actions palette, driven headless: runs from it record recents (newest first, capped),
+//! sections group commands by menu, a search covers every command with the best matches first,
+//! Up/Down move the highlight and Enter runs it, gone entries drop out of Recents, a used plugin
+//! resolves back to a row, and a press outside the panel closes it.
+
+use egui::{Event, Key, Modifiers, Pos2};
+use figcraft_engine::Session;
+use serde_json::json;
+
+use crate::layers_drag_tests::Ui;
+
+#[test]
+fn palette_runs_record_recents_newest_first_and_capped() {
+    let mut u = Ui::new(Session::new());
+    // Menus, shortcuts and context menus don't touch the palette's Recents.
+    crate::menus::invoke(&mut u.app, "view.zoomIn");
+    assert!(u.app.session.prefs.recent_actions.is_empty(), "only the palette records recents");
+    for id in ["view.zoomIn", "view.zoomOut", "edit.copyAsText", "style.list", "edit.findReplace", "edit.copyAsCss", "view.zoomIn"] {
+        crate::menus::run_action(&mut u.app, &format!("command:{id}"));
+    }
+    let r = &u.app.session.prefs.recent_actions;
+    assert_eq!(r.len(), figcraft_engine::MAX_RECENT_ACTIONS, "recents are capped: {r:?}");
+    assert_eq!(r[0], "command:view.zoomIn", "a re-run moves to the front: {r:?}");
+    assert_eq!(r.iter().filter(|k| k.as_str() == "command:view.zoomIn").count(), 1, "no duplicates: {r:?}");
+    assert!(!r.contains(&"command:view.zoomOut".to_string()), "the oldest drops out: {r:?}");
+}
+
+#[test]
+fn sections_group_by_menu_in_catalog_order() {
+    let groups = crate::menus::command_sections("");
+    assert!(!groups.is_empty(), "the catalog has commands");
+    assert_eq!(groups[0].0, "File", "catalog order starts at File");
+    for (group, rows) in &groups {
+        assert!(!rows.is_empty(), "{group} has no rows");
+        for row in rows {
+            assert!(row.key.starts_with("command:"), "unexpected key {}", row.key);
+        }
+    }
+    let names: Vec<&str> = groups.iter().map(|(g, _)| g.as_str()).collect();
+    assert!(names.contains(&"File") && names.contains(&"Edit"), "menus group: {names:?}");
+    assert!(!names.iter().any(|g| g.starts_with("Plugins")), "plugins have their own tab");
+}
+
+#[test]
+fn query_filters_to_matches() {
+    let groups = crate::menus::command_sections("save");
+    let labels: Vec<&str> = groups.iter().flat_map(|(_, rows)| rows.iter().map(|r| r.label.as_str())).collect();
+    assert!(!labels.is_empty(), "something matches 'save'");
+    assert!(labels.iter().all(|l| l.to_lowercase().contains("save")), "only matches: {labels:?}");
+    assert!(crate::menus::command_sections("zzz-no-such-action").iter().all(|(_, r)| r.is_empty()));
+}
+
+#[test]
+fn gone_entries_drop_out_of_recents() {
+    let u = Ui::new(Session::new());
+    assert!(crate::menus::recent_row(&u.app, "command:nope.nope", "").is_none(), "gone commands drop out");
+    assert!(crate::menus::recent_row(&u.app, "plugin:nope.nope/nope", "").is_none(), "gone plugins drop out");
+    assert!(crate::menus::recent_row(&u.app, "widget:nope", "").is_none(), "gone widgets drop out");
+}
+
+/// A used plugin (API 4, several commands) resolves back to a Recents row.
+#[test]
+fn used_plugin_resolves_to_a_recent_row() {
+    let mut u = Ui::new(Session::new());
+    let plugin: figcraft_engine::plugins::InstalledPlugin = serde_json::from_value(json!({
+        "manifest": {
+            "id": "dev.local.solar-icons",
+            "name": "Solar icons",
+            "main": "solar_icons.wasm",
+            "api": 4,
+            "commands": [
+                {"id": "panel", "label": "Panel"},
+                {"id": "grid", "label": "Grid"},
+            ],
+        },
+    }))
+    .unwrap();
+    u.app.session.prefs.plugins.push(plugin);
+    crate::menus::record_recent(&mut u.app, "plugin:dev.local.solar-icons/panel");
+    let row = crate::menus::recent_row(&u.app, "plugin:dev.local.solar-icons/panel", "").expect("a used plugin stays in Recents");
+    assert_eq!(row.label, "Solar icons — Panel");
+    assert!(crate::menus::recent_row(&u.app, "plugin:dev.local.solar-icons/panel", "zzz").is_none(), "the query filters recents");
+}
+
+/// A press outside the panel closes it; the opening press is spared once.
+#[test]
+fn outside_press_closes_the_panel() {
+    let mut u = Ui::new(Session::new());
+    u.app.ui.palette = Some(String::new());
+    u.app.ui.palette_armed = true;
+    // The opening press: spared, and disarmed.
+    u.button(Pos2::new(720.0, 20.0), true);
+    u.button(Pos2::new(720.0, 20.0), false);
+    assert!(u.app.ui.palette.is_some(), "the opening press is spared");
+    // The next press outside: closed.
+    u.button(Pos2::new(720.0, 20.0), true);
+    u.button(Pos2::new(720.0, 20.0), false);
+    assert!(u.app.ui.palette.is_none(), "an outside press closes the panel");
+    // One click is enough: the spare expires on frames without a press.
+    u.app.ui.palette = Some(String::new());
+    u.app.ui.palette_armed = true;
+    u.frame(vec![]);
+    u.button(Pos2::new(720.0, 20.0), true);
+    u.button(Pos2::new(720.0, 20.0), false);
+    assert!(u.app.ui.palette.is_none(), "a single outside press closes the panel");
+}
+
+fn rows(groups: &[(String, Vec<crate::menus::ActionRow>)]) -> Vec<&crate::menus::ActionRow> {
+    groups.iter().flat_map(|(_, rows)| rows).collect()
+}
+
+/// A search reaches commands no menu lists (in an "Other" group), not just menu items.
+#[test]
+fn search_covers_every_command() {
+    let menu = figcraft_engine::catalog::MENU;
+    let spec = figcraft_engine::all_commands().iter().find(|c| !menu.iter().any(|m| m.id == c.id)).expect("a command no menu lists");
+    let groups = crate::menus::command_sections(spec.id);
+    let key = format!("command:{}", spec.id);
+    let group = groups.iter().find(|(_, rows)| rows.iter().any(|r| r.key == key)).map(|(g, _)| g.as_str());
+    assert_eq!(group, Some("Other"), "{} is found: {:?}", spec.id, groups.iter().map(|(g, _)| g).collect::<Vec<_>>());
+    // Without a query the palette lists the menus' items only.
+    assert!(rows(&crate::menus::command_sections("")).iter().all(|r| r.key != key));
+}
+
+/// Labels starting with the query come first, the shortest first; the rest are capped.
+#[test]
+fn search_ranks_prefix_matches_first() {
+    let groups = crate::menus::command_sections("zoom");
+    let hits = rows(&groups);
+    let first = hits.first().expect("something matches 'zoom'");
+    assert!(first.label.to_lowercase().starts_with("zoom"), "a prefix match leads: {}", first.label);
+    let shortest = hits.iter().filter(|r| r.label.to_lowercase().starts_with("zoom")).map(|r| r.label.chars().count()).min();
+    assert_eq!(Some(first.label.chars().count()), shortest, "the shortest prefix match leads");
+    assert!(rows(&crate::menus::command_sections("e")).len() <= 60, "a broad search is capped");
+}
+
+fn key(u: &mut Ui, k: Key) {
+    u.frame(vec![
+        Event::Key { key: k, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE },
+        Event::Key { key: k, physical_key: None, pressed: false, repeat: false, modifiers: Modifiers::NONE },
+    ]);
+}
+
+/// Up and Down move the highlight (it stops at the ends); Enter runs the highlighted row.
+#[test]
+fn arrows_move_the_highlight_and_enter_runs_it() {
+    let mut u = Ui::new(Session::new());
+    crate::menus::set_palette(&mut u.app.ui, true);
+    u.frame(vec![]);
+    u.frame(vec![Event::Text("zoom".into())]);
+    assert_eq!(u.app.ui.palette.as_deref(), Some("zoom"));
+    assert_eq!(u.app.ui.palette_hi, 0, "a search starts at the first row");
+    key(&mut u, Key::ArrowUp);
+    assert_eq!(u.app.ui.palette_hi, 0, "it stops at the top");
+    key(&mut u, Key::ArrowDown);
+    key(&mut u, Key::ArrowDown);
+    key(&mut u, Key::ArrowUp);
+    assert_eq!(u.app.ui.palette_hi, 1);
+    let want = rows(&crate::menus::palette_sections(&u.app, "zoom", crate::menus::PaletteTab::All)).get(1).map(|r| r.key.clone()).expect("two rows");
+    key(&mut u, Key::Enter);
+    assert!(u.app.ui.palette.is_none(), "Enter runs a row and closes the palette");
+    assert_eq!(u.app.session.prefs.recent_actions.first(), Some(&want), "the highlighted row ran");
+}
diff --git a/crates/ui-egui/src/panel_remove_tests.rs b/crates/ui-egui/src/panel_remove_tests.rs
index 299a4b6f8..3805dca38 100644
--- a/crates/ui-egui/src/panel_remove_tests.rs
+++ b/crates/ui-egui/src/panel_remove_tests.rs
@@ -1,5 +1,6 @@
-//! Removing fill, effect and layout grid rows in the Design panel, driven through egui headless: an
-//! open colour picker and open settings stay with their items, and go when their item goes.
+//! Adding and removing fill, effect and layout grid rows in the Design panel, driven through egui headless:
+//! adding a paint opens its colour picker; an open colour picker and open settings stay with their items,
+//! and go when their item goes.
 
 use egui::{Event, Id, Pos2};
 use figcraft_doc::NodeId;
@@ -123,3 +124,46 @@ fn removing_effects_and_grids_keeps_open_settings_with_their_rows() {
     assert_eq!(u.app.session.doc().unwrap().node(f).unwrap().grids.len(), 1);
     assert!(flag(&u, "grid_open", 0) && !flag(&u, "grid_open", 1));
 }
+
+/// The centre of the button labelled `label` (found in the AccessKit tree).
+fn button(u: &mut Ui, label: &str) -> Pos2 {
+    let out = u.frame_output(vec![]);
+    let b = out.platform_output.accesskit_update.unwrap().nodes.into_iter().find(|(_, n)| n.label() == Some(label)).and_then(|(_, n)| n.bounds());
+    let b = b.unwrap_or_else(|| panic!("no {label:?} button"));
+    Pos2::new(((b.x0 + b.x1) / 2.0) as f32, ((b.y0 + b.y1) / 2.0) as f32)
+}
+
+#[test]
+fn adding_a_fill_or_stroke_opens_the_color_picker() {
+    let mut s = Session::new();
+    let r = id(s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 50, "height": 50})).unwrap());
+    s.execute("select.set", &json!({"ids": [r]})).unwrap();
+    let mut u = Ui::new(s);
+    u.ctx.enable_accesskit();
+    assert_eq!(u.app.ui.picker, None);
+
+    let add_fill = button(&mut u, "Add fill");
+    click(&mut u, add_fill);
+    assert_eq!(u.app.ui.picker, Some(PickerTarget::Paint { fills: true, index: 1, ids: vec![r] }));
+
+    let add_stroke = button(&mut u, "Add stroke");
+    click(&mut u, add_stroke);
+    assert_eq!(u.app.ui.picker, Some(PickerTarget::Paint { fills: false, index: 0, ids: vec![r] }));
+}
+
+#[test]
+fn adding_a_fill_to_mixed_fills_opens_no_picker() {
+    let mut s = Session::new();
+    let a = id(s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 50, "height": 50})).unwrap());
+    let b = id(s.execute("shape.rectangle", &json!({"x": 60, "y": 0, "width": 50, "height": 50})).unwrap());
+    s.execute("fill.add", &json!({"ids": [b]})).unwrap();
+    s.execute("select.set", &json!({"ids": [a, b]})).unwrap();
+    let mut u = Ui::new(s);
+    u.ctx.enable_accesskit();
+
+    let add_fill = button(&mut u, "Add fill");
+    click(&mut u, add_fill);
+    let doc = u.app.session.doc().unwrap();
+    assert_eq!((doc.node(a).unwrap().fills.len(), doc.node(b).unwrap().fills.len()), (2, 3));
+    assert_eq!(u.app.ui.picker, None);
+}
diff --git a/crates/ui-egui/src/panel_width_tests.rs b/crates/ui-egui/src/panel_width_tests.rs
index a5a84d04e..882a97a70 100644
--- a/crates/ui-egui/src/panel_width_tests.rs
+++ b/crates/ui-egui/src/panel_width_tests.rs
@@ -67,16 +67,17 @@ fn panels_fit_the_window() {
     let (l0, l1, r0, r1) = (*LEFT_PANEL.start(), *LEFT_PANEL.end(), *RIGHT_PANEL.start(), *RIGHT_PANEL.end());
     // (room beside the icon rail, left asked (none: closed), right asked) → (left, right) drawn
     let rows = [
-        ((1384.0, Some(240.0), 240.0), (240.0, 240.0), "as asked in a wide window"),
-        ((1384.0, Some(100.0), 100.0), (l0, r0), "never narrower than their least"),
-        ((1384.0, Some(900.0), 900.0), (l1, r1), "never wider than their most"),
-        ((1384.0, None, 300.0), (0.0, 300.0), "the left panel closed"),
-        ((744.0, Some(240.0), 240.0), (240.0, 240.0), "the smallest window with the default widths"),
-        ((744.0, Some(480.0), 480.0), (l0, 744.0 - l0 - CANVAS_MIN), "the smallest window: the left panel gives way first, then the right"),
-        ((744.0, Some(480.0), 240.0), (744.0 - 240.0 - CANVAS_MIN, 240.0), "the left panel gives the canvas its room"),
-        ((744.0, None, 480.0), (0.0, 480.0), "with the left panel closed the right one has room"),
-        ((300.0, Some(240.0), 240.0), (l0, r0), "a window smaller than any layout: the least widths"),
-        ((1384.0, Some(f32::NAN), f32::INFINITY), (PANEL_DEFAULT, PANEL_DEFAULT), "junk widths: the default"),
+        ((1384.0, Some(240.0), Some(240.0)), (240.0, 240.0), "as asked in a wide window"),
+        ((1384.0, Some(100.0), Some(100.0)), (l0, r0), "never narrower than their least"),
+        ((1384.0, Some(900.0), Some(900.0)), (l1, r1), "never wider than their most"),
+        ((1384.0, None, Some(300.0)), (0.0, 300.0), "the left panel closed"),
+        ((744.0, Some(240.0), Some(240.0)), (240.0, 240.0), "the smallest window with the default widths"),
+        ((744.0, Some(480.0), Some(480.0)), (l0, 744.0 - l0 - CANVAS_MIN), "the smallest window: the left panel gives way first, then the right"),
+        ((744.0, Some(480.0), Some(240.0)), (744.0 - 240.0 - CANVAS_MIN, 240.0), "the left panel gives the canvas its room"),
+        ((744.0, None, Some(480.0)), (0.0, 480.0), "with the left panel closed the right one has room"),
+        ((300.0, Some(240.0), Some(240.0)), (l0, r0), "a window smaller than any layout: the least widths"),
+        ((1384.0, Some(f32::NAN), Some(f32::INFINITY)), (PANEL_DEFAULT, PANEL_DEFAULT), "junk widths: the default"),
+        ((744.0, Some(480.0), None), (480.0, 0.0), "the right panel closed (a board's): the left one keeps its width"),
     ];
     for ((avail, left, right), want, why) in rows {
         assert_eq!(fit_panels(avail, left, right), want, "{why}");
@@ -85,7 +86,7 @@ fn panels_fit_the_window() {
     for avail in [744.0, 900.0, 1384.0] {
         for left in [None, Some(l0), Some(300.0), Some(l1)] {
             for right in [r0, 333.0, r1] {
-                let (l, r) = fit_panels(avail, left, right);
+                let (l, r) = fit_panels(avail, left, Some(right));
                 assert!(avail - l - r >= CANVAS_MIN, "{avail} {left:?} {right}: canvas {}", avail - l - r);
             }
         }
diff --git a/crates/ui-egui/src/paste_image_tests.rs b/crates/ui-egui/src/paste_image_tests.rs
new file mode 100644
index 000000000..b6775f93a
--- /dev/null
+++ b/crates/ui-egui/src/paste_image_tests.rs
@@ -0,0 +1,409 @@
+//! Pasting an image copied in another app (#663). On the desktop, egui-winit swallows Cmd/Ctrl+V's
+//! press and sends a paste event only when the clipboard holds text: an image leaves just the
+//! key's release. The browser sends the press and a paste event (`web_clipboard_tests`).
+
+use std::cell::RefCell;
+use std::rc::Rc;
+
+use egui::{Event, Key, Modifiers, PointerButton, Pos2, RawInput, Rect, Shape, vec2};
+use figcraft_doc::NodeId;
+use figcraft_engine::Session;
+use serde_json::json;
+
+use crate::{FigApp, Services};
+
+/// What the system clipboard holds when a paste chord is pressed (#716).
+#[derive(Clone, Copy, Debug)]
+enum Held {
+    /// FigCraft's own copy (its SVG text).
+    Ours,
+    /// Text copied in another app.
+    Text,
+    /// An image copied in another app.
+    Image,
+}
+
+const HELD: [Held; 3] = [Held::Ours, Held::Text, Held::Image];
+
+#[derive(Default)]
+struct Clip {
+    text: Option<String>,
+    image: Option<(u32, u32, Vec<u8>)>,
+}
+
+/// The desktop clipboard.
+struct Desktop(Rc<RefCell<Clip>>);
+
+impl Services for Desktop {
+    fn clipboard_set_text(&mut self, s: &str) {
+        *self.0.borrow_mut() = Clip { text: Some(s.into()), image: None };
+    }
+    fn clipboard_get_text(&mut self) -> Option<String> {
+        self.0.borrow().text.clone()
+    }
+    fn clipboard_get_image(&mut self) -> Option<(u32, u32, Vec<u8>)> {
+        self.0.borrow().image.clone()
+    }
+}
+
+struct Win {
+    ctx: egui::Context,
+    app: FigApp,
+    time: f64,
+    clip: Rc<RefCell<Clip>>,
+    shapes: Vec<Shape>,
+}
+
+impl Win {
+    fn new() -> Self {
+        let mut s = Session::new();
+        s.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 100, "height": 50})).unwrap();
+        let ctx = egui::Context::default();
+        let clip = Rc::new(RefCell::new(Clip::default()));
+        let app = FigApp::new(s, Box::new(Desktop(clip.clone())));
+        let mut w = Self { ctx, app, time: 0.0, clip, shapes: Vec::new() };
+        for _ in 0..3 {
+            w.frame(vec![]);
+        }
+        w
+    }
+
+    fn frame(&mut self, events: Vec<Event>) {
+        self.frame_with(events, false);
+    }
+
+    /// `take_v`: something ahead of the app (a prototype's key trigger) consumes a V press.
+    fn frame_with(&mut self, events: Vec<Event>, take_v: bool) {
+        self.time += 1.0 / 60.0;
+        let input =
+            RawInput { screen_rect: Some(Rect::from_min_size(Pos2::ZERO, vec2(1440.0, 900.0))), time: Some(self.time), events, ..Default::default() };
+        let app = &mut self.app;
+        let mut out = self.ctx.run_ui(input, |ui| {
+            if take_v {
+                ui.ctx().input_mut(|i| i.consume_key(Modifiers::NONE, Key::V));
+            }
+            app.ui(ui);
+        });
+        out.textures_delta.clear();
+        self.shapes = out.shapes.into_iter().map(|s| s.shape).collect();
+    }
+
+    fn copy_image_elsewhere(&mut self) {
+        *self.clip.borrow_mut() = Clip { text: None, image: Some((2, 2, vec![255; 16])) };
+    }
+
+    /// Cmd/Ctrl+V as egui-winit delivers it: the press brings a paste event when the clipboard
+    /// holds text and nothing otherwise; the release comes as a key event.
+    fn cmd_v(&mut self, m: Modifiers) {
+        let text = self.clip.borrow().text.clone().filter(|t| !t.is_empty());
+        self.frame(text.map(Event::Paste).into_iter().collect());
+        self.frame(vec![key(Key::V, false, m)]);
+        self.frame(vec![]);
+    }
+
+    /// A Cmd/Ctrl+V chord with its modifiers, as egui-winit delivers it: they go down first, the V
+    /// press brings a paste event only for text, its release comes as a key event, then they're
+    /// let go.
+    fn chord(&mut self, m: Modifiers) {
+        let text = self.clip.borrow().text.clone().filter(|t| !t.is_empty());
+        self.frame(vec![Event::ModifiersChanged(m)]);
+        self.frame(text.map(Event::Paste).into_iter().collect());
+        self.frame(vec![key(Key::V, false, m)]);
+        self.frame(vec![Event::ModifiersChanged(Modifiers::NONE)]);
+    }
+
+    /// A red rectangle A copied in FigCraft, and a grey rectangle B selected; then `held` on the
+    /// system clipboard. Returns (A, B).
+    fn copy_a_select_b(&mut self, held: Held) -> (NodeId, NodeId) {
+        let s = &mut self.app.session;
+        let a = s.doc().unwrap().nodes().find(|n| n.name == "Rectangle").unwrap().id;
+        s.execute("fill.set", &json!({"ids": [a.0], "color": "#e53935"})).unwrap();
+        let b = s.execute("shape.rectangle", &json!({"x": 400, "y": 250, "width": 100, "height": 50})).unwrap();
+        let b = NodeId(b["id"].as_u64().unwrap());
+        s.execute("select.set", &json!({"ids": [a.0]})).unwrap();
+        crate::menus::invoke(&mut self.app, "edit.copy");
+        self.app.session.execute("edit.copyProperties", &json!({})).unwrap();
+        self.app.session.execute("select.set", &json!({"ids": [b.0]})).unwrap();
+        match held {
+            Held::Ours => {}
+            Held::Text => self.clip.borrow_mut().text = Some("hello from another app".into()),
+            Held::Image => self.copy_image_elsewhere(),
+        }
+        (a, b)
+    }
+
+    fn fill(&self, id: NodeId) -> String {
+        let n = figcraft_engine::inspect::node_json(self.app.session.doc().unwrap(), id, 0);
+        n["fills"][0]["color"].as_str().unwrap_or_default().to_string()
+    }
+
+    /// Top-lefts of the rectangles other than `b`.
+    fn rects_besides(&self, b: NodeId) -> Vec<(i64, i64)> {
+        let doc = self.app.session.doc().unwrap();
+        let mut at: Vec<_> = doc
+            .nodes()
+            .filter(|n| n.name == "Rectangle" && n.id != b)
+            .filter_map(|n| doc.world_bounds(n.id))
+            .map(|r| (r.x0.round() as i64, r.y0.round() as i64))
+            .collect();
+        at.sort();
+        at
+    }
+
+    fn named(&self, name: &str) -> usize {
+        self.app.session.doc().unwrap().nodes().filter(|n| n.name == name).count()
+    }
+
+    fn texts(&self) -> usize {
+        self.app.session.doc().unwrap().nodes().filter(|n| matches!(n.kind, figcraft_doc::NodeKind::Text(_))).count()
+    }
+
+    fn rects(&self) -> usize {
+        self.named("Rectangle")
+    }
+}
+
+// egui sets `command` for Cmd on macOS and for Ctrl elsewhere; macOS Ctrl is a separate key.
+const CMD: Modifiers = if cfg!(target_os = "macos") { Modifiers::COMMAND } else { Modifiers::COMMAND.plus(Modifiers::CTRL) };
+
+fn key(key: Key, pressed: bool, modifiers: Modifiers) -> Event {
+    Event::Key { key, physical_key: Some(key), pressed, repeat: false, modifiers }
+}
+
+#[test]
+fn cmd_v_pastes_an_image_copied_elsewhere() {
+    let mut w = Win::new();
+    w.copy_image_elsewhere();
+    w.cmd_v(CMD);
+    assert_eq!(w.named("Pasted image"), 1, "the image was pasted from the key's release");
+    w.cmd_v(CMD);
+    assert_eq!(w.named("Pasted image"), 2, "and again");
+}
+
+#[test]
+fn cmd_released_before_v_still_pastes_the_image() {
+    let mut w = Win::new();
+    w.copy_image_elsewhere();
+    w.cmd_v(Modifiers::NONE);
+    assert_eq!(w.named("Pasted image"), 1);
+}
+
+#[test]
+fn text_pastes_once_from_its_paste_event() {
+    let mut w = Win::new();
+    *w.clip.borrow_mut() = Clip { text: Some("hello from another app".into()), image: None };
+    w.cmd_v(CMD);
+    assert_eq!(w.texts(), 1, "the paste event pasted the text, the release nothing more");
+    assert_eq!(w.rects(), 1);
+}
+
+#[test]
+fn text_pastes_once_when_another_key_is_let_go_first() {
+    let mut w = Win::new();
+    *w.clip.borrow_mut() = Clip { text: Some("hello".into()), image: None };
+    // Cmd+A then Cmd+V typed fast: A comes up after V went down.
+    w.frame(vec![key(Key::A, true, CMD)]);
+    w.frame(vec![Event::Paste("hello".into())]);
+    w.frame(vec![key(Key::A, false, CMD)]);
+    w.frame(vec![key(Key::V, false, CMD)]);
+    w.frame(vec![]);
+    assert_eq!(w.texts(), 1);
+    assert_eq!(w.rects(), 1);
+}
+
+#[test]
+fn a_v_press_consumed_elsewhere_does_not_paste_on_release() {
+    let mut w = Win::new();
+    w.copy_image_elsewhere();
+    w.frame_with(vec![key(Key::V, true, Modifiers::NONE)], true);
+    w.frame(vec![key(Key::V, false, Modifiers::NONE)]);
+    w.frame(vec![]);
+    assert_eq!(w.named("Pasted image"), 0);
+}
+
+#[test]
+fn the_browser_sequence_pastes_once() {
+    let mut w = Win::new();
+    w.copy_image_elsewhere();
+    w.frame(vec![key(Key::V, true, CMD)]);
+    w.frame(vec![key(Key::V, false, CMD)]);
+    w.frame(vec![]);
+    assert_eq!(w.named("Pasted image"), 1);
+}
+
+#[test]
+fn v_alone_pastes_nothing() {
+    let mut w = Win::new();
+    w.copy_image_elsewhere();
+    w.frame(vec![key(Key::V, true, Modifiers::NONE)]);
+    w.frame(vec![key(Key::V, false, Modifiers::NONE)]);
+    assert_eq!(w.named("Pasted image"), 0);
+}
+
+#[test]
+fn a_paste_event_from_another_key_does_not_block_the_next_cmd_v() {
+    let mut w = Win::new();
+    *w.clip.borrow_mut() = Clip { text: Some("text".into()), image: None };
+    // Shift+Insert on Windows.
+    w.frame(vec![Event::Paste("text".into())]);
+    w.frame(vec![key(Key::Insert, false, Modifiers::SHIFT)]);
+    w.copy_image_elsewhere();
+    w.cmd_v(CMD);
+    assert_eq!(w.named("Pasted image"), 1);
+}
+
+#[test]
+fn a_v_press_lost_to_another_window_does_not_block_the_next_cmd_v() {
+    let mut w = Win::new();
+    w.copy_image_elsewhere();
+    w.frame(vec![key(Key::V, true, Modifiers::NONE), Event::WindowFocused(false)]);
+    w.frame(vec![Event::WindowFocused(true)]);
+    w.cmd_v(CMD);
+    assert_eq!(w.named("Pasted image"), 1);
+}
+
+#[test]
+fn v_held_while_the_window_was_away_pastes_nothing_on_release() {
+    let mut w = Win::new();
+    w.copy_image_elsewhere();
+    // Pressed in another window: only the focus and the release arrive here.
+    w.frame(vec![Event::WindowFocused(true)]);
+    w.frame(vec![key(Key::V, false, Modifiers::NONE)]);
+    w.frame(vec![]);
+    assert_eq!(w.named("Pasted image"), 0);
+    w.cmd_v(CMD);
+    assert_eq!(w.named("Pasted image"), 1, "the next Cmd+V still pastes");
+}
+
+#[test]
+fn cmd_v_in_a_panel_field_does_not_paste_on_the_canvas() {
+    let mut w = Win::new();
+    w.copy_image_elsewhere();
+    w.frame(vec![]);
+    w.app.field_focus = true;
+    w.frame(vec![key(Key::V, false, CMD)]);
+    w.frame(vec![]);
+    assert_eq!(w.named("Pasted image"), 0);
+}
+
+#[test]
+fn paste_here_prefers_a_newer_image_over_copied_layers() {
+    let mut w = Win::new();
+    w.app.session.execute("select.all", &json!({})).unwrap();
+    crate::menus::invoke(&mut w.app, "edit.copy");
+    assert!(!w.app.session.clipboard.nodes.is_empty(), "layers copied");
+    w.app.session.execute("select.none", &json!({})).unwrap();
+    w.copy_image_elsewhere();
+    let at = Pos2::new(900.0, 600.0);
+    for pressed in [true, false] {
+        w.frame(vec![
+            Event::PointerMoved(at),
+            Event::PointerButton { pos: at, button: PointerButton::Secondary, pressed, modifiers: Modifiers::NONE },
+        ]);
+    }
+    w.frame(vec![]);
+    let item = crate::live_tests::text_center(&w.shapes, "Paste here");
+    for pressed in [true, false] {
+        w.frame(vec![
+            Event::PointerMoved(item),
+            Event::PointerButton { pos: item, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE },
+        ]);
+    }
+    w.frame(vec![]);
+    assert_eq!(w.named("Pasted image"), 1, "the newer image was pasted");
+    assert_eq!(w.rects(), 1, "not the copied rectangle");
+    let p = w.app.to_page(at);
+    let doc = w.app.session.doc().unwrap();
+    let img = doc.nodes().find(|n| n.name == "Pasted image").unwrap();
+    let b = doc.world_bounds(img.id).unwrap();
+    assert!((b.x0 - p.x).abs() < 0.01 && (b.y0 - p.y).abs() < 0.01, "top-left where the menu opened: {b:?} vs {p:?}");
+}
+
+#[test]
+fn shift_cmd_v_pastes_over_the_selection_whatever_the_clipboard_holds() {
+    for held in HELD {
+        let mut w = Win::new();
+        let (_, b) = w.copy_a_select_b(held);
+        w.chord(CMD.plus(Modifiers::SHIFT));
+        assert_eq!(w.rects_besides(b), [(10, 10), (400, 250)], "{held:?}: A's copy at B's top-left, nothing else");
+        assert_eq!(w.texts(), 0, "{held:?}: no text pasted");
+        assert_eq!(w.named("Pasted image"), 0, "{held:?}: no image pasted");
+    }
+}
+
+#[test]
+fn alt_cmd_v_pastes_properties_whatever_the_clipboard_holds() {
+    for held in HELD {
+        let mut w = Win::new();
+        let (_, b) = w.copy_a_select_b(held);
+        w.chord(CMD.plus(Modifiers::ALT));
+        assert_eq!(w.fill(b), "#E53935", "{held:?}: B took A's fill");
+        assert_eq!(w.rects_besides(b), [(10, 10)], "{held:?}: no layer pasted");
+        assert_eq!(w.texts(), 0, "{held:?}: no text pasted");
+        assert_eq!(w.named("Pasted image"), 0, "{held:?}: no image pasted");
+    }
+}
+
+#[test]
+fn a_chord_let_go_within_one_frame_still_reads_its_modifiers() {
+    let mut w = Win::new();
+    let (_, b) = w.copy_a_select_b(Held::Text);
+    let m = CMD.plus(Modifiers::SHIFT);
+    w.frame(vec![
+        Event::ModifiersChanged(m),
+        Event::Paste("hello from another app".into()),
+        key(Key::V, false, m),
+        Event::ModifiersChanged(Modifiers::NONE),
+    ]);
+    w.frame(vec![]);
+    assert_eq!(w.rects_besides(b), [(10, 10), (400, 250)]);
+    assert_eq!(w.texts(), 0);
+}
+
+#[test]
+fn cmd_let_go_before_v_still_pastes_over() {
+    let mut w = Win::new();
+    let (_, b) = w.copy_a_select_b(Held::Image);
+    w.frame(vec![Event::ModifiersChanged(CMD.plus(Modifiers::SHIFT))]);
+    w.frame(vec![Event::ModifiersChanged(Modifiers::SHIFT)]);
+    w.frame(vec![key(Key::V, false, Modifiers::SHIFT)]);
+    w.frame(vec![Event::ModifiersChanged(Modifiers::NONE)]);
+    assert_eq!(w.rects_besides(b), [(10, 10), (400, 250)], "pasted over, not flipped or a plain paste");
+    assert_eq!(w.named("Pasted image"), 0);
+}
+
+#[test]
+fn a_held_chord_pastes_over_once() {
+    let mut w = Win::new();
+    let (_, b) = w.copy_a_select_b(Held::Text);
+    let m = CMD.plus(Modifiers::SHIFT);
+    w.frame(vec![Event::ModifiersChanged(m)]);
+    // Auto-repeat: egui-winit sends a paste event for every repeated press.
+    for _ in 0..3 {
+        w.frame(vec![Event::Paste("hello from another app".into())]);
+    }
+    w.frame(vec![key(Key::V, false, m)]);
+    w.frame(vec![Event::ModifiersChanged(Modifiers::NONE)]);
+    assert_eq!(w.rects_besides(b), [(10, 10), (400, 250)]);
+    assert_eq!(w.texts(), 0);
+}
+
+#[test]
+fn shift_insert_still_pastes_text() {
+    let mut w = Win::new();
+    let (_, b) = w.copy_a_select_b(Held::Text);
+    w.frame(vec![Event::ModifiersChanged(Modifiers::SHIFT), Event::Paste("hello from another app".into())]);
+    w.frame(vec![key(Key::Insert, false, Modifiers::SHIFT), Event::ModifiersChanged(Modifiers::NONE)]);
+    assert_eq!(w.texts(), 1);
+    assert_eq!(w.rects_besides(b), [(10, 10)]);
+}
+
+#[test]
+fn cmd_v_after_a_paste_chord_is_a_plain_paste_again() {
+    let mut w = Win::new();
+    let (_, b) = w.copy_a_select_b(Held::Text);
+    w.chord(CMD.plus(Modifiers::SHIFT));
+    w.chord(CMD);
+    assert_eq!(w.texts(), 1, "the text was pasted by the plain Cmd+V");
+    assert_eq!(w.rects_besides(b), [(10, 10), (400, 250)], "Shift+Cmd+V pasted over once");
+}
diff --git a/crates/ui-egui/src/pending_open.rs b/crates/ui-egui/src/pending_open.rs
index 63c213ffd..f5e978c61 100644
--- a/crates/ui-egui/src/pending_open.rs
+++ b/crates/ui-egui/src/pending_open.rs
@@ -1,13 +1,17 @@
 //! Files dropped on the home screen or the canvas open a frame later, behind a card that says what
 //! is happening: opening a large `.fig` blocks the UI thread for a while, and the card is on screen
-//! before it does (rather than a window that freezes without a word).
+//! before it does (rather than a window that freezes without a word). A file with no path to read
+//! (every drop in the browser) waits behind the card until its contents arrive.
+
+use std::sync::Arc;
+use std::task::{Context as TaskContext, Poll, Waker};
 
 use figcraft_doc::NodeId;
-use serde_json::Value;
+use serde_json::{Value, json};
 
-use crate::FigApp;
 use crate::i18n::{tr, trf, trn};
 use crate::theme::{Tokens, semibold};
+use crate::{FigApp, ReadFuture, RepaintWaker};
 
 /// A dropped file waiting to be opened (`file.open`, a document of its own) or imported
 /// (`file.import`, into the current document).
@@ -18,6 +22,8 @@ pub struct PendingOpen {
     pub command: &'static str,
     /// Canvas imports stay with the document and page that received the drop.
     pub target: Option<ImportTarget>,
+    /// The file's contents still on their way; they go into `params` as `data` once read.
+    pub read: Option<ReadFuture>,
 }
 
 pub struct ImportTarget {
@@ -26,10 +32,20 @@ pub struct ImportTarget {
     pub name: String,
 }
 
+/// Queues dropped file `f` to open as a document of its own: by path, or by its contents when there
+/// is no file on disk to read. Callers checked its extension, so there is a name to tell the format by.
+pub(crate) fn open_dropped(app: &mut FigApp, f: &egui::DroppedFileHandle) {
+    let path = f.path();
+    let name = path.file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_default();
+    let (params, read) =
+        if path.exists() { (json!({"path": path.to_string_lossy()}), None) } else { (json!({"name": name}), Some(crate::dropped_bytes(f, &name))) };
+    app.ui.pending_opens.push(PendingOpen { label: name, params, command: "file.open", target: None, read });
+}
+
 fn run_pending(app: &mut FigApp, pending: PendingOpen) -> Option<Value> {
     let target = match pending.target {
         Some(target) => target,
-        None if pending.command != "file.import" => return app.run(pending.command, pending.params),
+        None if pending.command != "file.import" => return app.run_user(pending.command, pending.params),
         None => {
             cancel(app, tr("The destination document is unavailable. Nothing was imported.").to_string());
             return None;
@@ -49,7 +65,7 @@ fn run_pending(app: &mut FigApp, pending: PendingOpen) -> Option<Value> {
     let previous_selection = app.session.docs[index].selection.clone();
     app.session.active = index;
     app.session.docs[index].page = target.page;
-    let result = app.run(pending.command, pending.params);
+    let result = app.run_user(pending.command, pending.params);
     if previous_page != target.page
         && let Some(doc) = app.session.docs.iter_mut().find(|doc| doc.uid == target.uid)
         && doc.doc.pages.contains(&previous_page)
@@ -66,33 +82,83 @@ fn run_pending(app: &mut FigApp, pending: PendingOpen) -> Option<Value> {
 
 /// An import that has no destination left: nothing is imported, and the user is told why.
 fn cancel(app: &mut FigApp, message: String) {
-    app.ui.last_error = Some(message.clone());
-    app.toast(message);
+    app.show_error(message);
 }
 
+/// Space between files dropped together on the canvas.
+const IMPORT_GAP: f64 = 20.0;
+
 /// Frames the card is drawn before the files open: egui lays a new card out invisibly on its first
 /// frame, so the second one is the first the window shows.
 const FRAMES_BEFORE_OPENING: u8 = 2;
 
-/// The card while files wait, then (once it has been on screen) open them. Called before the import
-/// report, so a report for these files shows after them.
+/// Polls the contents still being read: those that arrived go into their file's parameters, files
+/// that couldn't be read are dropped with a message. Whether any are still on their way.
+fn read_contents(app: &mut FigApp, ctx: &egui::Context) -> bool {
+    let waker = Waker::from(Arc::new(RepaintWaker(ctx.clone())));
+    let mut cx = TaskContext::from_waker(&waker);
+    let mut reading = false;
+    let mut unread = Vec::new();
+    app.ui.pending_opens.retain_mut(|pending| {
+        let Some(read) = pending.read.as_mut() else { return true };
+        match read.as_mut().poll(&mut cx) {
+            Poll::Pending => {
+                reading = true;
+                true
+            }
+            Poll::Ready(Ok(bytes)) => {
+                use base64::Engine as _;
+                pending.params["data"] = json!(base64::engine::general_purpose::STANDARD.encode(&bytes));
+                pending.read = None;
+                true
+            }
+            Poll::Ready(Err(why)) => {
+                unread.push(why);
+                false
+            }
+        }
+    });
+    for why in unread {
+        app.show_error(why);
+    }
+    reading
+}
+
+/// The card while files wait, then (once it has been on screen and their contents are read) open
+/// them. Called before the import report, so a report for these files shows after them.
 pub fn pending_opens(app: &mut FigApp, ctx: &egui::Context) {
+    let reading = read_contents(app, ctx);
     if app.ui.pending_opens.is_empty() {
         app.ui.pending_open_frames = 0;
         return;
     }
     ctx.request_repaint();
-    if app.ui.pending_open_frames >= FRAMES_BEFORE_OPENING {
+    if app.ui.pending_open_frames >= FRAMES_BEFORE_OPENING && !reading {
         app.ui.pending_open_frames = 0;
-        for pending in std::mem::take(&mut app.ui.pending_opens) {
+        // Files dropped together land side by side: each starts where the previous one ends.
+        let mut next_x: Option<f64> = None;
+        for mut pending in std::mem::take(&mut app.ui.pending_opens) {
             let command = pending.command;
-            if run_pending(app, pending).is_some() && command == "file.open" {
+            let canvas = command == "file.import" && pending.params.get("x").is_some();
+            if canvas && let Some(x) = next_x {
+                pending.params["x"] = json!(x);
+            }
+            let page = pending.target.as_ref().map(|t| (t.uid, t.page));
+            let result = run_pending(app, pending);
+            if result.is_some() && command == "file.open" {
                 app.ui.home = false;
             }
+            if canvas {
+                let right = result.as_ref().and_then(|r| r.get("id")?.as_u64()).and_then(|id| {
+                    let doc = &app.session.docs.iter().find(|d| Some(d.uid) == page.map(|p| p.0))?.doc;
+                    doc.world_bounds(NodeId(id)).map(|b| b.x1)
+                });
+                next_x = right.map(|r| r + IMPORT_GAP).or(next_x);
+            }
         }
         return;
     }
-    app.ui.pending_open_frames += 1;
+    app.ui.pending_open_frames = app.ui.pending_open_frames.saturating_add(1);
     let title = match app.ui.pending_opens.first().map(|p| p.command) {
         Some("file.import") => {
             let name = app
diff --git a/crates/ui-egui/src/plugin_panel_tests.rs b/crates/ui-egui/src/plugin_panel_tests.rs
index f154c6294..e4bc6d4fa 100644
--- a/crates/ui-egui/src/plugin_panel_tests.rs
+++ b/crates/ui-egui/src/plugin_panel_tests.rs
@@ -13,7 +13,7 @@ use crate::layers_drag_tests::Ui;
 
 /// A plugin whose first call shows a panel with every kind of control and whose later calls (the
 /// panel's events) make a rectangle.
-fn panel_module() -> Vec<u8> {
+pub(crate) fn panel_module() -> Vec<u8> {
     let spec = json!({"title": "Test panel", "controls": [
         {"type": "note", "label": "Hello from the plugin"},
         {"type": "number", "name": "size", "label": "Size", "value": 10},
diff --git a/crates/ui-egui/src/plugins_ui.rs b/crates/ui-egui/src/plugins_ui.rs
index 481b446c3..745cde881 100644
--- a/crates/ui-egui/src/plugins_ui.rs
+++ b/crates/ui-egui/src/plugins_ui.rs
@@ -151,7 +151,7 @@ pub fn menu(app: &mut FigApp, ui: &mut Ui, t: &Tokens) -> bool {
                 }
             }
             commands => {
-                let picked = crate::menus::submenu(ui, "Plugins", &format!("Plugins/plugin:{}", m.id), &m.name, t, |ui| {
+                let picked = crate::menus::submenu(ui, &format!("Plugins/plugin:{}", m.id), &m.name, t, |ui| {
                     commands.iter().find(|c| crate::menus::item(ui, &c.label, "", true, false, t)).map(|c| c.id.clone())
                 });
                 if let Some(c) = picked {
@@ -164,7 +164,7 @@ pub fn menu(app: &mut FigApp, ui: &mut Ui, t: &Tokens) -> bool {
         app.session.prefs.plugins.iter().filter(|p| p.manifest.widget).map(|p| (p.manifest.id.as_str(), p.manifest.name.as_str())).collect();
     let widget = (!widgets.is_empty())
         .then(|| {
-            crate::menus::submenu(ui, "Plugins", "Plugins/widgets", tr("Widgets"), t, |ui| {
+            crate::menus::submenu(ui, "Plugins/widgets", tr("Widgets"), t, |ui| {
                 widgets.iter().find(|(_, name)| crate::menus::item(ui, name, "", true, false, t)).map(|(id, _)| id.to_string())
             })
         })
diff --git a/crates/ui-egui/src/present.rs b/crates/ui-egui/src/present.rs
index b5f177af0..fae1e1a7c 100644
--- a/crates/ui-egui/src/present.rs
+++ b/crates/ui-egui/src/present.rs
@@ -4,8 +4,9 @@
 //! The player works on its own copy of the document (interactive components, variables and scroll
 //! offsets change it without touching the user's file) and copies the editor's document again
 //! whenever it changes, so the preview pane follows edits live. On a device, the presented frame
-//! is sized to the device's screen ([`fit_viewport`]): what doesn't fit is clipped, or scrolls when
-//! the frame's overflow allows it. A responsive prototype's frame is instead resized to the screen
+//! is sized to the device's screen ([`fit_viewport`]): a frame bigger than the screen scrolls
+//! through its whole size (as in Figma, with no overflow setting), while content past the frame's
+//! own edges scrolls only as its overflow allows and is otherwise clipped. A responsive prototype's frame is instead resized to the screen
 //! (the device's, else the player's whole area) and laid out again, its constraints and auto layout
 //! responding (`figcraft_engine::cmd::proto::respond`, on the player's copy, from the design each
 //! time). Device bodies are drawn in code in the device's colour. Every frame is rendered through
@@ -270,6 +271,8 @@ pub struct Presenter {
     anim_tex: Option<egui::TextureHandle>,
     temp: Option<Temp>,
     textures: HashMap<NodeId, FrameTex>,
+    /// Small current-screen preview in the full-window bar, cached until its content changes.
+    bar_thumb: Option<(NodeId, usize, egui::TextureHandle)>,
     arrived: f64,
     delays_fired: HashSet<(NodeId, usize)>,
     /// Mouse triggers waiting out their delay.
@@ -328,6 +331,11 @@ impl Presenter {
         true
     }
 
+    /// The frame the presentation started from (Restart goes back there).
+    pub fn start(&self) -> NodeId {
+        self.start
+    }
+
     pub fn new(start: NodeId) -> Self {
         Self {
             current: start,
@@ -348,6 +356,7 @@ impl Presenter {
             anim_tex: None,
             temp: None,
             textures: HashMap::new(),
+            bar_thumb: None,
             arrived: -1.0,
             delays_fired: HashSet::new(),
             waiting: Vec::new(),
@@ -390,6 +399,18 @@ impl Presenter {
         self.stop_scrolling();
     }
 
+    /// A new device changes the viewport and may relayout every frame. Start at its top instead
+    /// of carrying scroll offsets or a drag from the old screen into the new one.
+    fn reset_for_device(&mut self) {
+        self.pan = None;
+        self.scroll.clear();
+        self.scroll_anim = None;
+        self.press = None;
+        self.dragged = false;
+        self.stop_scrolling();
+        self.rev += 1;
+    }
+
     /// The current offset of `t` (a frame's scroll, else the view's pan).
     fn offset(&self, t: Scroller) -> (f64, f64) {
         match t {
@@ -496,6 +517,16 @@ impl Presenter {
         self.rev += 1;
     }
 
+    /// After an action changed layers of `design` (since `before`): text resizes to what it shows,
+    /// instances follow and auto layout reflows, as after an edit on the canvas; then
+    /// [`relayout`](Self::relayout).
+    fn settle(&mut self, before: &Document) {
+        if let Some(d) = self.design.as_mut() {
+            figcraft_engine::normalize(d, before);
+        }
+        self.relayout();
+    }
+
     /// Responsive prototypes: resize the presented frame to a screen of `size` (None: frames
     /// keep their size). Lays out again only when it changes.
     fn respond_to(&mut self, size: Option<(f64, f64)>) {
@@ -850,7 +881,9 @@ impl Presenter {
             }
             Action::CloseOverlay => self.close_overlay(now),
             Action::OpenUrl { url } => {
-                if !url.trim().is_empty() {
+                // The URL comes from the document and this action fires from whatever trigger the
+                // prototype sets, including a delay, so no click is implied: only a web link opens.
+                if figcraft_engine::doc_urls::openable(url) {
                     self.urls.push(url.clone());
                 }
                 true
@@ -862,28 +895,31 @@ impl Presenter {
                 }
                 self.begin(tr, dur, easing, now);
                 let Some(d) = self.design.as_mut() else { return false };
+                let before = d.clone();
                 if let Some(n) = d.node_mut(inst)
                     && let NodeKind::Instance { component, .. } = &mut n.kind
                 {
                     *component = *dest;
                 }
                 figcraft_engine::components::sync_instance(d, inst);
-                self.relayout();
+                self.settle(&before);
                 true
             }
             Action::SetVariable { variable, value, expr } => {
                 let Some(d) = self.design.as_mut() else { return false };
+                let before = d.clone();
                 let set = figcraft_engine::proto_run::set_variable(d, node, variable, value, expr.as_ref());
                 if set {
-                    self.relayout();
+                    self.settle(&before);
                 }
                 set
             }
             Action::SetVariableMode { collection, mode } => {
                 let Some(d) = self.design.as_mut() else { return false };
+                let before = d.clone();
                 let set = figcraft_engine::proto_run::set_mode(d, self.current, collection, mode);
                 if set {
-                    self.relayout();
+                    self.settle(&before);
                 }
                 set
             }
@@ -1153,11 +1189,13 @@ pub fn scroll_range(doc: &Document, frame: NodeId) -> (f64, f64) {
 
 /// How far `frame`'s content can scroll when `viewport` (page units, from its top-left) of it
 /// shows, as a device's screen shows a top-level frame: the frame itself is content then, so a
-/// frame taller than the screen scrolls through its whole height. Without a viewport the frame
-/// shows at its own size and what overflows it scrolls. Only the axes its overflow allows scroll.
+/// frame bigger than the screen scrolls through its whole size whatever its overflow (as in
+/// Figma, a top-level frame needs no overflow setting for that). Without a viewport the frame
+/// shows at its own size and what overflows it scrolls. Content past the frame's own edges
+/// scrolls only on the axes its overflow allows.
 pub fn scroll_range_in(doc: &Document, frame: NodeId, viewport: Option<(f64, f64)>) -> (f64, f64) {
     let Some(n) = doc.node(frame) else { return (0.0, 0.0) };
-    if n.overflow == Overflow::None {
+    if n.overflow == Overflow::None && viewport.is_none() {
         return (0.0, 0.0);
     }
     let (mut x1, mut y1) = (0.0f64, 0.0f64);
@@ -1174,6 +1212,13 @@ pub fn scroll_range_in(doc: &Document, frame: NodeId, viewport: Option<(f64, f64
         x1 += l.padding[1];
         y1 += l.padding[2];
     }
+    // Axes the overflow doesn't scroll clip what lies past the frame's edges.
+    if !matches!(n.overflow, Overflow::Horizontal | Overflow::Both) {
+        x1 = 0.0;
+    }
+    if !matches!(n.overflow, Overflow::Vertical | Overflow::Both) {
+        y1 = 0.0;
+    }
     let (vw, vh) = match viewport {
         Some(v) => {
             x1 = x1.max(n.width);
@@ -1182,8 +1227,7 @@ pub fn scroll_range_in(doc: &Document, frame: NodeId, viewport: Option<(f64, f64
         }
         None => (n.width, n.height),
     };
-    let rx = if matches!(n.overflow, Overflow::Horizontal | Overflow::Both) { (x1 - vw).max(0.0) } else { 0.0 };
-    let ry = if matches!(n.overflow, Overflow::Vertical | Overflow::Both) { (y1 - vh).max(0.0) } else { 0.0 };
+    let (rx, ry) = ((x1 - vw).max(0.0), (y1 - vh).max(0.0));
     (if rx.is_finite() { rx } else { 0.0 }, if ry.is_finite() { ry } else { 0.0 })
 }
 
@@ -1625,12 +1669,26 @@ enum BarAction {
     Inspect,
 }
 
+pub struct PresentTab {
+    pub id: u64,
+    /// Empty while the tab is on screen: then the player is in `app.ui.present`.
+    pub pres: Option<Presenter>,
+    pub doc_uid: u64,
+    pub path: Option<String>,
+    pub page: NodeId,
+    pub file: String,
+    pub page_name: String,
+}
+
 /// The full-window presenter (while `app.ui.present` is set). Escape or Close ends it.
 pub fn show(app: &mut FigApp, ui: &mut Ui) {
     let ctx = ui.ctx().clone();
     let now = ctx.input(|i| i.time);
     let Some(mut pres) = app.ui.present.take() else { return };
-    if let Ok(ds) = app.session.ds() {
+    // A tab can play a file that is closed or not in front. Then it must not read or change
+    // the file in front.
+    let live = crate::tabs::present_owner_active(app);
+    if live && let Ok(ds) = app.session.ds() {
         pres.sync(&ds.doc, now);
     }
     poll_pads(app, &mut pres, &ctx);
@@ -1651,6 +1709,7 @@ pub fn show(app: &mut FigApp, ui: &mut Ui) {
     egui::CentralPanel::default().frame(egui::Frame::NONE).show(ui, |ui| {
         action = player(&mut pres, ui, ui.max_rect(), now, Chrome { keys: !typing, ..FULL }).or(action);
     });
+    let picked_device = navigation_bar(&mut pres, &ctx, now);
     // Keys the prototype left alone: C shows the comments, F fills the screen.
     if !typing {
         if ctx.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::C)) {
@@ -1666,7 +1725,8 @@ pub fn show(app: &mut FigApp, ui: &mut Ui) {
         Some(BarAction::Inspect) => pres.view.inspect = !pres.view.inspect,
         _ => {}
     }
-    if pres.view.comments
+    if live
+        && pres.view.comments
         && let Some((frame, place, clip)) = pres.shown
     {
         crate::comments::presenter(app, &ctx, frame, place, clip);
@@ -1676,13 +1736,128 @@ pub fn show(app: &mut FigApp, ui: &mut Ui) {
     finish(app, &mut pres);
     // The options carry over to the next presentation.
     app.ui.present_view = pres.view;
-    if let Some(BarAction::Responsive(on)) = action {
+    if live && let Some(BarAction::Responsive(on)) = action {
         app.run("proto.settings", json!({"responsive": on}));
     }
-    if action == Some(BarAction::Close) || ctx.input(|i| i.key_pressed(egui::Key::Escape)) {
-        return;
+    if live && let Some(device) = picked_device {
+        choose_device(app, &mut pres, &device);
     }
     app.ui.present = Some(pres);
+    if action == Some(BarAction::Close) || ctx.input(|i| i.key_pressed(egui::Key::Escape)) {
+        if let Some(id) = app.ui.present_active {
+            crate::tabs::close_present(app, id);
+        } else {
+            app.ui.present = None;
+        }
+    }
+}
+
+/// Device choices in the presenter use the screen's real dimensions and reflow a copy of the
+/// design through constraints and auto layout. "No device" returns to the original frame size.
+fn choose_device(app: &mut FigApp, p: &mut Presenter, device: &str) {
+    let responsive = device != "None";
+    if app.run("proto.settings", json!({"device": device, "responsive": responsive})).is_some() {
+        p.reset_for_device();
+    }
+}
+
+/// Controls that stay in reach while viewing a prototype, including screen stepping, device and
+/// scale. The selected device is returned to the caller so it can go through the normal document
+/// command (and undo/save) rather than changing only the player's copy.
+fn navigation_bar(p: &mut Presenter, ctx: &egui::Context, now: f64) -> Option<String> {
+    let t = Tokens::get(ctx);
+    let doc = p.doc.as_ref()?;
+    let frames = doc.top_frames(doc.page_of(p.current).unwrap_or(p.current));
+    let index = frames.iter().position(|id| *id == p.current);
+    let settings = page_settings(doc, p.current);
+    let mut navigate = None;
+    let mut device_choice = None;
+    egui::Area::new(Id::new("present_navigation")).anchor(Align2::CENTER_BOTTOM, vec2(0.0, -18.0)).order(egui::Order::Foreground).show(ctx, |ui| {
+        egui::Frame::NONE
+            .fill(t.panel)
+            .stroke(Stroke::new(1.0, t.border))
+            .corner_radius(CornerRadius::same(9))
+            .inner_margin(egui::Margin::symmetric(8, 5))
+            .show(ui, |ui| {
+                ui.horizontal(|ui| {
+                    let prev = index.and_then(|i| i.checked_sub(1)).and_then(|i| frames.get(i)).copied();
+                    let next = index.and_then(|i| frames.get(i + 1)).copied();
+                    let previous =
+                        ui.add_enabled(prev.is_some(), egui::Button::new("").min_size(vec2(26.0, 24.0))).on_hover_text(tr("Previous frame"));
+                    icons::paint(
+                        ui.painter(),
+                        Rect::from_center_size(previous.rect.center(), vec2(21.0, 21.0)),
+                        Icon::ChevronLeft,
+                        if prev.is_some() { t.icon } else { t.icon_secondary },
+                    );
+                    if previous.clicked() {
+                        navigate = prev;
+                    }
+                    ui.label(egui::RichText::new(format!("{} / {}", index.map_or(0, |i| i + 1), frames.len())).color(t.text));
+                    let following = ui.add_enabled(next.is_some(), egui::Button::new("").min_size(vec2(26.0, 24.0))).on_hover_text(tr("Next frame"));
+                    icons::paint(
+                        ui.painter(),
+                        Rect::from_center_size(following.rect.center(), vec2(21.0, 21.0)),
+                        Icon::ChevronRight,
+                        if next.is_some() { t.icon } else { t.icon_secondary },
+                    );
+                    if following.clicked() {
+                        navigate = next;
+                    }
+                    ui.separator();
+                    let model = if settings.device.is_empty() || settings.device == "None" { tr("No device") } else { &settings.device };
+                    let device_menu = ui.menu_button(format!("{model}    "), |ui| {
+                        navigation_menu(ui, |ui| {
+                            egui::ScrollArea::vertical().max_height(410.0).show(ui, |ui| {
+                                if ui.selectable_label(settings.device.is_empty() || settings.device == "None", tr("No device")).clicked() {
+                                    device_choice = Some("None".to_owned());
+                                    ui.close();
+                                }
+                                ui.separator();
+                                for device in PrototypeSettings::DEVICES {
+                                    let label = format!("{}  {}×{}", device.name, device.width as u32, device.height as u32);
+                                    if ui.selectable_label(settings.device == device.name, label).clicked() {
+                                        device_choice = Some(device.name.to_owned());
+                                        ui.close();
+                                    }
+                                }
+                                ui.separator();
+                                if ui.selectable_label(settings.device == PrototypeSettings::CUSTOM_DEVICE, tr("Custom size")).clicked() {
+                                    device_choice = Some(PrototypeSettings::CUSTOM_DEVICE.to_owned());
+                                    ui.close();
+                                }
+                            });
+                        });
+                    });
+                    paint_menu_chevron(ui.painter(), device_menu.response.rect, t.icon_secondary);
+                    let scale_menu = ui.menu_button(format!("{}    ", tr(p.view.scale.label(settings.device().is_some()))), |ui| {
+                        navigation_menu(ui, |ui| {
+                            for scale in PresentScale::options(settings.device().is_some()) {
+                                if ui.selectable_label(p.view.scale == *scale, tr(scale.label(settings.device().is_some()))).clicked() {
+                                    p.set_scale(*scale);
+                                    ui.close();
+                                }
+                            }
+                        });
+                    });
+                    paint_menu_chevron(ui.painter(), scale_menu.response.rect, t.icon_secondary);
+                });
+            });
+    });
+    if let Some(id) = navigate {
+        p.go(id, Transition::Instant, 0.0, Easing::Linear, now, true, false);
+    }
+    device_choice
+}
+
+fn paint_menu_chevron(painter: &egui::Painter, button: Rect, color: Color32) {
+    let icon = Rect::from_center_size(pos2(button.right() - 11.0, button.center().y), vec2(17.0, 17.0));
+    icons::paint(painter, icon, Icon::Chevron, color);
+}
+
+fn navigation_menu(ui: &mut Ui, add: impl FnOnce(&mut Ui)) {
+    ui.set_min_width(212.0);
+    add(ui);
 }
 
 /// How often the player polls the controllers while its prototype has gamepad triggers (seconds).
@@ -2045,16 +2220,17 @@ fn inspect_hover(p: &mut Presenter, painter: &egui::Painter, ctx: &egui::Context
 /// the right (text on the dark full-window bar, icons in the pane, which follows the theme).
 fn top_bar(p: &mut Presenter, ui: &mut Ui, bar: Rect, now: f64, chrome: Chrome) -> Option<BarAction> {
     let t = Tokens::get(ui.ctx());
-    let (fill, text, dim, hover) = if chrome.pane {
-        (t.panel, t.text, t.text_secondary, t.hover)
-    } else {
-        (Color32::from_rgb(0x2C, 0x2C, 0x2C), Color32::WHITE, Color32::from_gray(140), Color32::from_white_alpha(28))
-    };
+    let (fill, text, dim, hover) = (t.panel, t.text, t.text_secondary, t.hover);
     let r = chrome.round;
     ui.painter().rect_filled(bar, CornerRadius { nw: r, ne: r, sw: 0, se: 0 }, fill);
     if chrome.pane {
         ui.painter().line_segment([bar.left_bottom(), bar.right_bottom()], Stroke::new(1.0, t.border));
     }
+    let source_key = p.source.as_ref().map_or(0, |s| Arc::as_ptr(s) as usize);
+    if !chrome.pane && p.bar_thumb.as_ref().is_none_or(|(id, source, _)| *id != p.current || *source != source_key) {
+        p.bar_thumb =
+            p.source.as_ref().and_then(|d| crate::assets_panel::thumbnail(ui.ctx(), d, p.current, 38.0)).map(|tex| (p.current, source_key, tex));
+    }
     let doc = p.doc.as_ref()?;
     let name = doc.node(p.current).map(|n| n.name.clone()).unwrap_or_default();
     let flows = match doc.page_of(p.start).and_then(|pg| doc.node(pg)).map(|n| &n.kind) {
@@ -2092,7 +2268,7 @@ fn top_bar(p: &mut Presenter, ui: &mut Ui, bar: Rect, now: f64, chrome: Chrome)
         }
         let on = (*act == BarAction::Comments && p.view.comments) || (*act == BarAction::Inspect && p.view.inspect);
         if on {
-            ui.painter().rect_filled(br, CornerRadius::same(5), ACCENT);
+            ui.painter().rect_filled(br, CornerRadius::same(5), t.accent);
         } else if resp.hovered() {
             ui.painter().rect_filled(br, CornerRadius::same(5), hover);
         }
@@ -2103,9 +2279,9 @@ fn top_bar(p: &mut Presenter, ui: &mut Ui, bar: Rect, now: f64, chrome: Chrome)
             resp = resp.tip(tr("Inspect the layer under the pointer: size, colours, typography"));
         }
         if chrome.pane {
-            icons::paint(ui.painter(), br.shrink(5.0), *icon, t.icon);
+            icons::paint(ui.painter(), br.shrink(5.0), *icon, if on { t.accent_on } else { t.icon });
         } else {
-            ui.painter().text(br.center(), Align2::CENTER_CENTER, shown, regular(11.5), text);
+            ui.painter().text(br.center(), Align2::CENTER_CENTER, shown, regular(11.5), if on { t.accent_on } else { text });
         }
         if *act == BarAction::Options {
             let menu = crate::right::menu_popup(&resp).width(220.0).show(|ui| options_menu(p, ui, device, settings.responsive, now));
@@ -2117,19 +2293,33 @@ fn top_bar(p: &mut Presenter, ui: &mut Ui, bar: Rect, now: f64, chrome: Chrome)
     // Left: the flow picker and the frame's name, clipped before the buttons.
     let left = ui.painter().with_clip_rect(Rect::from_min_max(bar.min, pos2(x, bar.max.y)));
     let mut lx = bar.min.x + if chrome.pane { 8.0 } else { 12.0 };
+    if !chrome.pane {
+        let thumb = Rect::from_center_size(pos2(lx + 15.0, bar.center().y), vec2(28.0, 28.0));
+        left.rect_filled(thumb, CornerRadius::same(4), t.field);
+        if let Some((_, _, tex)) = &p.bar_thumb {
+            let size = tex.size_vec2();
+            if size.x > 0.0 && size.y > 0.0 {
+                let scaled = size * (26.0 / size.x.max(size.y));
+                let dst = Rect::from_center_size(thumb.center(), scaled);
+                left.image(tex.id(), dst, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);
+            }
+        }
+        lx += 38.0;
+    }
     // The flow playing: its name on the picker, its description on hover; the menu lists each
     // flow with its description.
     let playing = flows.iter().find(|f| f.start == p.start);
     if !flows.is_empty() {
-        let label = format!("{}  ▾", playing.map_or(tr("Flows"), |f| f.name.as_str()));
+        let label = playing.map_or(tr("Flows"), |f| f.name.as_str()).to_owned();
         let tip = playing.map(|f| f.description.trim()).filter(|d| !d.is_empty()).unwrap_or(tr("Flows")).to_string();
         let galley = left.layout_no_wrap(label, semibold(11.5), text);
-        let fr = Rect::from_min_size(pos2(lx, bar.center().y - 12.0), vec2(galley.size().x + 16.0, 24.0));
+        let fr = Rect::from_min_size(pos2(lx, bar.center().y - 12.0), vec2(galley.size().x + 30.0, 24.0));
         let resp = ui.interact(fr.intersect(left.clip_rect()), ui.id().with("pflows"), Sense::click()).tip(tip);
         if resp.hovered() {
             left.rect_filled(fr, CornerRadius::same(5), hover);
         }
         left.galley(pos2(fr.min.x + 8.0, fr.center().y - galley.size().y / 2.0), galley, text);
+        paint_menu_chevron(&left, fr, t.icon_secondary);
         crate::right::menu_popup(&resp).width(240.0).show(|ui| {
             let t = Tokens::get(ui.ctx());
             for f in &flows {
@@ -2149,7 +2339,7 @@ fn top_bar(p: &mut Presenter, ui: &mut Ui, bar: Rect, now: f64, chrome: Chrome)
         left.text(pos2(lx, bar.center().y), Align2::LEFT_CENTER, "/", regular(11.5), dim);
         lx += 14.0;
     }
-    left.text(pos2(lx, bar.center().y), Align2::LEFT_CENTER, name, regular(11.5), if chrome.pane { text } else { Color32::from_gray(220) });
+    left.text(pos2(lx, bar.center().y), Align2::LEFT_CENTER, name, regular(11.5), text);
     action
 }
 
@@ -2211,7 +2401,7 @@ fn scrollers_at(p: &Presenter, base: &Document, disp: &Document, root: NodeId, p
     let mut out: Vec<NodeId> = disp
         .subtree(root)
         .into_iter()
-        .filter(|f| disp.node(*f).is_some_and(|n| n.visible && n.overflow != Overflow::None))
+        .filter(|f| disp.node(*f).is_some_and(|n| n.visible && (n.overflow != Overflow::None || *f == root)))
         .filter(|f| disp.world_bounds(*f).is_some_and(|b| place.rect(b).contains(q)))
         .filter(|f| p.range(base, *f) != (0.0, 0.0))
         .collect();
@@ -2418,14 +2608,21 @@ fn input(p: &mut Presenter, ctx: &egui::Context, l: &Layout, over_area: bool, ke
             }
             return;
         }
-        // Otherwise the drag scrolls the innermost frame under it that scrolls, else pans a view
-        // bigger than the window.
+        // A drag begun inside a mobile screen moves its content, even if the pointer leaves the
+        // screen. The device body stays in place even when the drag begins outside its screen.
+        // Panning the whole view remains available only without a mobile device.
         if let Some(base) = p.doc.clone() {
-            let target = scrollers_at(p, &base, doc, root, &place, start)
-                .first()
+            let horizontal = d.x.abs() >= d.y.abs();
+            let scrolls = scrollers_at(p, &base, doc, root, &place, start);
+            let on_axis = |range: (f64, f64)| if horizontal { range.0 > 0.0 } else { range.1 > 0.0 };
+            let mobile = page_settings(&base, root).device().is_some_and(|device| device.rotates);
+            let target = scrolls
+                .iter()
                 .copied()
+                .find(|f| on_axis(p.range(&base, *f)))
+                .or_else(|| scrolls.first().copied())
                 .map(Scroller::Frame)
-                .or((p.pan_range != (0.0, 0.0)).then_some(Scroller::View));
+                .or((!mobile && p.pan_range != (0.0, 0.0)).then_some(Scroller::View));
             if let Some(t) = target {
                 p.fling = None;
                 p.drag_scroll = Some((t, clamp_scroll(p.offset(t), p.limits(&base, t))));
@@ -2685,6 +2882,125 @@ mod tests {
     use super::*;
     use figcraft_doc::NodeKind;
 
+    use crate::present_tests::{Ui, id};
+
+    #[test]
+    fn device_picker_reflows_without_resizing_the_saved_frame_and_can_revert() {
+        let mut session = figcraft_engine::Session::new();
+        let frame = id(&session.execute("node.create", &json!({"type": "frame", "width": 894, "height": 844})).unwrap());
+        let right = id(&session
+            .execute("node.create", &json!({"type": "rectangle", "parent": frame, "x": 804, "y": 20, "width": 80, "height": 40}))
+            .unwrap());
+        session.execute("node.set", &json!({"id": right, "props": {"constraints": {"horizontal": "right", "vertical": "top"}}})).unwrap();
+        let mut ui = Ui::new(session);
+        ui.run("proto.present", json!({"start": frame}));
+
+        let mut presenter = ui.app.ui.present.take().unwrap();
+        presenter.pan = Some((100.0, 200.0));
+        presenter.scroll.insert(frame, (75.0, 50.0));
+        choose_device(&mut ui.app, &mut presenter, "iPhone 17");
+        assert!(presenter.pan.is_none() && presenter.scroll.is_empty());
+        ui.app.ui.present = Some(presenter);
+        ui.frame(vec![]);
+
+        let shown = &ui.app.ui.present.as_ref().unwrap().doc.as_ref().unwrap();
+        assert_eq!((shown.node(frame).unwrap().width, shown.node(frame).unwrap().height), (402.0, 874.0));
+        assert_eq!(shown.world_bounds(right).unwrap().x0, 312.0, "right constraint follows the phone edge");
+        assert_eq!(ui.app.inspect()["presenter"]["viewport"], json!([402.0, 874.0]));
+        assert_eq!(ui.app.inspect()["presenter"]["scrollRange"], json!([0.0, 0.0]));
+        assert_eq!(ui.app.session.doc().unwrap().node(frame).unwrap().width, 894.0, "the saved design keeps its geometry");
+
+        let area = Rect::from_min_max(pos2(0.0, 40.0), pos2(1440.0, 900.0));
+        let screen_before = layout(ui.app.ui.present.as_mut().unwrap(), area, FULL).unwrap().screen;
+        ui.button(pos2(720.0, 440.0), true);
+        ui.frame(vec![egui::Event::PointerMoved(pos2(300.0, 300.0))]);
+        ui.button(pos2(300.0, 300.0), false);
+        assert_eq!(ui.app.inspect()["presenter"]["scroll"], json!([0.0, 0.0]), "fitted content does not move");
+        assert_eq!(layout(ui.app.ui.present.as_mut().unwrap(), area, FULL).unwrap().screen, screen_before);
+
+        let mut presenter = ui.app.ui.present.take().unwrap();
+        choose_device(&mut ui.app, &mut presenter, "None");
+        ui.app.ui.present = Some(presenter);
+        ui.frame(vec![]);
+        assert_eq!(ui.app.inspect()["presenter"]["frameSize"], json!([894.0, 844.0]));
+        assert_eq!(ui.app.inspect()["presenter"]["responsive"], Value::Null);
+    }
+
+    #[test]
+    fn device_presets_show_their_screen_at_the_real_resolution_in_their_body() {
+        let mut session = figcraft_engine::Session::new();
+        let frame = id(&session.execute("node.create", &json!({"type": "frame", "width": 894, "height": 844})).unwrap());
+        let mut ui = Ui::new(session);
+        ui.run("proto.present", json!({"start": frame}));
+        let area = Rect::from_min_max(pos2(0.0, 40.0), pos2(1440.0, 860.0));
+
+        for (name, width, height) in
+            [("iPad mini", 744.0, 1133.0), ("MacBook Air", 1280.0, 832.0), ("Desktop", 1440.0, 1024.0), ("iPhone 17", 402.0, 874.0)]
+        {
+            let mut presenter = ui.app.ui.present.take().unwrap();
+            choose_device(&mut ui.app, &mut presenter, name);
+            ui.app.ui.present = Some(presenter);
+            ui.frame(vec![]);
+
+            let presenter = ui.app.ui.present.as_mut().unwrap();
+            let laid = layout(presenter, area, FULL).unwrap();
+            assert!(laid.color.is_some(), "{name}: drawn in its body");
+            assert!((f64::from(laid.screen.width()) / laid.scale - width).abs() < 0.1, "{name}: width");
+            assert!((f64::from(laid.screen.height()) / laid.scale - height).abs() < 0.1, "{name}: height");
+            assert_eq!(ui.app.session.doc().unwrap().node(frame).unwrap().width, 894.0);
+        }
+    }
+
+    /// A phone shows a frame's content past its screen only as far as the frame's overflow lets it
+    /// scroll: with "No scrolling" it's clipped, like on every other device.
+    #[test]
+    fn a_phone_scrolls_only_what_the_frames_overflow_allows() {
+        let on_phone = |overflow: &str| {
+            let mut session = figcraft_engine::Session::new();
+            let frame = id(&session.execute("node.create", &json!({"type": "frame", "width": 894, "height": 844})).unwrap());
+            session.execute("node.create", &json!({"type": "rectangle", "parent": frame, "x": 650, "y": 1050, "width": 80, "height": 80})).unwrap();
+            session.execute("node.set", &json!({"id": frame, "props": {"overflow": overflow}})).unwrap();
+            let mut ui = Ui::new(session);
+            ui.run("proto.present", json!({"start": frame}));
+            let mut presenter = ui.app.ui.present.take().unwrap();
+            choose_device(&mut ui.app, &mut presenter, "iPhone 17");
+            ui.app.ui.present = Some(presenter);
+            ui.frame(vec![]);
+            (ui, frame)
+        };
+        let start = pos2(720.0, 440.0);
+        let drag = |ui: &mut Ui, to: Pos2| {
+            ui.button(start, true);
+            ui.frame(vec![egui::Event::PointerMoved(to)]);
+            ui.button(to, false);
+            ui.app.inspect()["presenter"].clone()
+        };
+
+        let (mut ui, frame) = on_phone("none");
+        assert_eq!(ui.app.inspect()["presenter"]["scrollRange"], json!([0.0, 0.0]));
+        assert_eq!(drag(&mut ui, start - vec2(100.0, 120.0))["scroll"], json!([0.0, 0.0]), "no scrolling stays clipped");
+        assert_eq!(ui.app.session.doc().unwrap().node(frame).unwrap().width, 894.0);
+
+        let (mut ui, frame) = on_phone("both");
+        let range = &ui.app.inspect()["presenter"]["scrollRange"];
+        assert!(range[0].as_f64().unwrap() > 0.0 && range[1].as_f64().unwrap() > 0.0, "{range}");
+        let scroll = drag(&mut ui, start - vec2(100.0, 120.0))["scroll"].clone();
+        assert!(scroll[0].as_f64().unwrap() > 0.0 && scroll[1].as_f64().unwrap() > 0.0, "{scroll}");
+        assert_eq!(ui.app.session.doc().unwrap().node(frame).unwrap().width, 894.0);
+
+        // The content keeps following a drag after the pointer leaves the screen, while the
+        // device itself stays fixed on the stage.
+        ui.frames(60, Vec::new);
+        let area = Rect::from_min_max(pos2(0.0, 40.0), pos2(1440.0, 900.0));
+        let screen_before = layout(ui.app.ui.present.as_mut().unwrap(), area, FULL).unwrap().screen;
+        ui.button(start, true);
+        ui.frame(vec![egui::Event::PointerMoved(pos2(300.0, 300.0))]);
+        let during = ui.app.inspect()["presenter"].clone();
+        assert!(during["scroll"][0].as_f64().unwrap() > 0.0, "{during}");
+        assert_eq!(layout(ui.app.ui.present.as_mut().unwrap(), area, FULL).unwrap().screen, screen_before);
+        ui.button(pos2(300.0, 300.0), false);
+    }
+
     fn doc_with_two_frames() -> (Document, NodeId, NodeId) {
         let mut d = Document::new("t");
         let page = d.add_page("Page 1");
@@ -2873,9 +3189,11 @@ mod tests {
         assert_eq!(disp.world_bounds(list).unwrap().y0, 800.0);
         p.scroll_to(0.0, 99_999.0);
         assert_eq!(p.scroll[&a], (0.0, 1148.0), "clamped to the range");
-        // Without scrolling the screen only clips; without a device the frame shows whole.
+        // A top-level frame taller than the screen scrolls without an overflow setting (its own
+        // range still clips nested content); without a device the frame shows whole.
         d.get_mut(a).unwrap().overflow = Overflow::None;
-        assert_eq!(scroll_range_in(&d, a, viewport(&d, a)), (0.0, 0.0));
+        assert_eq!(scroll_range_in(&d, a, viewport(&d, a)), (0.0, 1148.0));
+        assert_eq!(scroll_range(&d, a), (0.0, 0.0));
         if let Some(pg) = d.page_of(a)
             && let NodeKind::Page { prototype, .. } = &mut d.get_mut(pg).unwrap().kind
         {
diff --git a/crates/ui-egui/src/present_behaviour_tests.rs b/crates/ui-egui/src/present_behaviour_tests.rs
index 791e0d3fc..e9a036f27 100644
--- a/crates/ui-egui/src/present_behaviour_tests.rs
+++ b/crates/ui-egui/src/present_behaviour_tests.rs
@@ -454,6 +454,99 @@ fn interactive_components_change_in_place() {
     }
 }
 
+/// A hugging auto layout frame (in `parent`, else on the page) holding text `chars`: (frame, text).
+fn hugging_label(s: &mut Session, parent: Option<NodeId>, name: &str, x: f64, chars: &str) -> (NodeId, NodeId) {
+    let f = id(&ex(s, "frame.create", json!({"x": x, "y": 600, "width": 60, "height": 30, "name": name, "parent": parent})));
+    let t = id(&ex(s, "text.create", json!({"text": chars, "x": 0, "y": 0, "parent": f})));
+    ex(s, "node.set", json!({"ids": [f], "props": {"layout": "horizontal", "padding": 8, "sizingH": "hug", "sizingV": "hug"}}));
+    (f, t)
+}
+
+fn size(d: &Document, n: NodeId) -> (f64, f64) {
+    d.node(n).map(|n| (n.width, n.height)).unwrap()
+}
+
+#[test]
+fn change_to_lays_out_the_instance_around_its_own_content() {
+    // Change to shows the other variant in place: the instance keeps its overrides (a longer
+    // label), so it is laid out around them, as switching the variant on the canvas does.
+    figcraft_text::scan_system_fonts();
+    let mut s = Session::new();
+    let variants: Vec<NodeId> = ["Default", "Hover"]
+        .iter()
+        .enumerate()
+        .map(|(k, state)| {
+            let (f, _) = hugging_label(&mut s, None, &format!("State={state}"), k as f64 * 150.0, "Button");
+            id(&ex(&mut s, "component.create", json!({"ids": [f]})))
+        })
+        .collect();
+    let set = id(&ex(&mut s, "component.combineVariants", json!({"ids": variants.clone()})));
+    on(&mut s, variants[0], json!({"type": "onClick"}), json!({"type": "changeTo", "dest": variants[1]}), json!({"type": "instant"}), 0);
+    let screen = frame(&mut s, "Screen", 0.0, 400.0, 300.0);
+    let button = id(&ex(&mut s, "instance.create", json!({"component": set, "x": 20, "y": 20, "parent": screen})));
+    let label = s.doc().unwrap().node(button).unwrap().children[0];
+    ex(&mut s, "text.set", json!({"id": label, "characters": "A much longer label"}));
+    let (main, canvas, canvas_label) = {
+        let d = s.doc().unwrap();
+        (size(d, variants[1]), size(d, button), size(d, label))
+    };
+    // Without any font nothing is measured and both sizes are the main's.
+    if figcraft_text::layout_node(s.doc().unwrap().node(label).unwrap()).is_some_and(|(l, _)| !l.glyphs.is_empty()) {
+        assert!(canvas.0 > main.0 + 20.0, "on the canvas the instance hugs its longer label");
+    }
+    let mut p = player(s.doc().unwrap().clone(), screen);
+    assert!(p.fire(button, 0, None, 1.0));
+    let d = p.doc.as_ref().unwrap();
+    assert!(matches!(d.node(button).unwrap().kind, NodeKind::Instance { component, .. } if component == variants[1]));
+    assert_eq!((size(d, button), size(d, label)), (canvas, canvas_label), "the Hover variant, laid out around the instance's label");
+}
+
+/// A screen holding a hugging chip whose text is bound to string variable `label` of collection
+/// "Copy" (modes A "Short" and B "A much longer label"), the chip's click running `action`:
+/// (session, screen, chip, text).
+fn bound_chip(action: Value) -> (Session, NodeId, NodeId, NodeId) {
+    figcraft_text::scan_system_fonts();
+    let mut s = Session::new();
+    ex(&mut s, "variable.createCollection", json!({"name": "Copy", "modes": ["A", "B"]}));
+    ex(
+        &mut s,
+        "variable.create",
+        json!({"collection": "Copy", "name": "label", "type": "string", "values": {"A": "Short", "B": "A much longer label"}}),
+    );
+    let screen = frame(&mut s, "Screen", 0.0, 400.0, 300.0);
+    let (chip, text) = hugging_label(&mut s, Some(screen), "Chip", 20.0, "Short");
+    ex(&mut s, "variable.bind", json!({"ids": [text], "field": "characters", "variable": "label"}));
+    on(&mut s, chip, json!({"type": "onClick"}), action, json!({"type": "instant"}), 0);
+    (s, screen, chip, text)
+}
+
+#[test]
+fn set_variable_and_set_mode_lay_out_the_text_they_change() {
+    // A text bound to a string variable shows what an interaction sets, measured: the hugging
+    // chip around it grows with it, to the size the canvas gives the same text.
+    let cases = [
+        (
+            json!({"type": "setVariable", "variable": "label", "value": "A much longer label"}),
+            "variable.set",
+            json!({"variable": "label", "value": "A much longer label"}),
+        ),
+        (json!({"type": "setVariableMode", "collection": "Copy", "mode": "B"}), "variable.setMode", json!({"collection": "Copy", "mode": "B"})),
+    ];
+    for (action, canvas_cmd, canvas_params) in cases {
+        let (mut s, screen, chip, text) = bound_chip(action.clone());
+        let mut p = player(s.doc().unwrap().clone(), screen);
+        assert!(p.fire(chip, 0, None, 1.0), "{action}");
+        let page = s.doc().unwrap().page_of(screen).unwrap();
+        let mut params = canvas_params;
+        if canvas_cmd == "variable.setMode" {
+            params["ids"] = json!([page]);
+        }
+        ex(&mut s, canvas_cmd, params);
+        let (d, canvas) = (p.doc.as_ref().unwrap(), s.doc().unwrap());
+        assert_eq!((size(d, chip), size(d, text)), (size(canvas, chip), size(canvas, text)), "{action}: the chip grows with its text");
+    }
+}
+
 #[test]
 fn a_drag_started_transition_follows_the_pointer() {
     let (mut u, hot) = one_interaction(json!({"type": "onDrag"}), json!({"type": "push", "direction": "left"}), 400);
diff --git a/crates/ui-egui/src/present_links_tests.rs b/crates/ui-egui/src/present_links_tests.rs
new file mode 100644
index 000000000..8223890c2
--- /dev/null
+++ b/crates/ui-egui/src/present_links_tests.rs
@@ -0,0 +1,71 @@
+//! A prototype's Open link action carries a URL from the document and fires from whatever trigger
+//! the prototype sets, including a delay, so the player hands the opener only a web link
+//! ([`figcraft_engine::doc_urls`]). Without that, a saved document opens `javascript:` in the web
+//! build's own origin (stored XSS) and `smb:`/`ms-…:` through the desktop's handlers.
+
+use std::sync::{Arc, Mutex};
+
+use figcraft_engine::Session;
+use serde_json::{Value, json};
+
+use crate::Services;
+use crate::present_tests::{Ui as Harness, id};
+
+/// Records every URL the player asks the platform to open.
+#[derive(Default)]
+struct Opened(Arc<Mutex<Vec<String>>>);
+
+impl Services for Opened {
+    fn open_url(&mut self, url: &str) {
+        if let Ok(mut v) = self.0.lock() {
+            v.push(url.to_string());
+        }
+    }
+}
+
+fn ex(s: &mut Session, cmd: &str, p: Value) -> Value {
+    s.execute(cmd, &p).unwrap_or_else(|e| panic!("{cmd} {p}: {e}"))
+}
+
+/// A presented frame whose layer opens `url` 100ms after the screen appears — no click anywhere.
+fn opens_after_a_delay(url: &str) -> Vec<String> {
+    let mut s = Session::new();
+    let f = id(&ex(&mut s, "frame.create", json!({"x": 0, "y": 0, "width": 300, "height": 400, "name": "A"})));
+    let layer = id(&ex(&mut s, "shape.rectangle", json!({"x": 10, "y": 10, "width": 30, "height": 30, "parent": f})));
+    ex(
+        &mut s,
+        "proto.interaction.add",
+        json!({"id": layer, "trigger": {"type": "afterDelay", "ms": 100}, "action": {"type": "openUrl", "url": url}, "transition": {"type": "instant"}}),
+    );
+    let seen = Arc::new(Mutex::new(Vec::new()));
+    let mut u = Harness::new(s);
+    u.app.services = Box::new(Opened(seen.clone()));
+    u.run("proto.present", json!({"start": f}));
+    // Well past the delay.
+    u.frames(40, Vec::new);
+    seen.lock().map(|v| v.clone()).unwrap_or_default()
+}
+
+#[test]
+fn a_prototype_opens_web_links() {
+    assert_eq!(opens_after_a_delay("https://example.com/a"), ["https://example.com/a"]);
+    assert_eq!(opens_after_a_delay("mailto:a@b.c"), ["mailto:a@b.c"]);
+}
+
+#[test]
+fn a_prototype_cannot_open_a_script_or_handler_url() {
+    for url in [
+        // In the web build the opener is `window.open`, which runs this in the app's own origin.
+        "javascript:alert(document.cookie)",
+        "JavaScript:alert(1)",
+        "data:text/html,<script>alert(1)</script>",
+        // Reaches the file system; a UNC host also sends Windows credentials.
+        "file:///etc/passwd",
+        "smb://attacker.example/share/x",
+        // Handed to an application handler by the desktop.
+        "ms-msdt:/id PCWDiagnostic",
+        "figcraft://join?host=127.0.0.1:47900&file=f&token=t",
+    ] {
+        assert!(opens_after_a_delay(url).is_empty(), "{url:?} must never reach the opener");
+    }
+}
diff --git a/crates/ui-egui/src/present_tab_tests.rs b/crates/ui-egui/src/present_tab_tests.rs
new file mode 100644
index 000000000..1868babb6
--- /dev/null
+++ b/crates/ui-egui/src/present_tab_tests.rs
@@ -0,0 +1,193 @@
+use egui::accesskit::{Node, Role};
+use egui::{Key, Pos2, pos2};
+use figcraft_doc::proto::PrototypeSettings;
+use serde_json::{Value, json};
+
+use crate::present_tests::{Ui, id, setup};
+
+const FILE_TAB: Pos2 = pos2(100.0, 20.0);
+
+fn click(u: &mut Ui, at: Pos2) {
+    u.button(at, true);
+    u.button(at, false);
+    u.frame(vec![]);
+}
+
+fn tabs(u: &Ui) -> Value {
+    u.app.inspect()["presentTabs"].clone()
+}
+
+fn presenting(u: &Ui) -> bool {
+    u.app.inspect()["presenting"] == json!(true)
+}
+
+fn nodes(u: &mut Ui) -> Vec<Node> {
+    u.ctx.enable_accesskit();
+    u.frame(vec![]);
+    u.frame_output(vec![]).platform_output.accesskit_update.expect("an AccessKit update").nodes.into_iter().map(|(_, n)| n).collect()
+}
+
+fn centre(n: &Node) -> Pos2 {
+    let b = n.bounds().unwrap();
+    pos2(((b.x0 + b.x1) / 2.0) as f32, ((b.y0 + b.y1) / 2.0) as f32)
+}
+
+fn click_label(u: &mut Ui, label: &str) {
+    let all = nodes(u);
+    let n = all.iter().find(|n| n.label().is_some_and(|l| l.trim() == label)).unwrap_or_else(|| panic!("no {label:?} on screen"));
+    click(u, centre(n));
+}
+
+/// The presenter bar's Options button: it has no label, and sits right of Show comments.
+fn open_options(u: &mut Ui) {
+    let all = nodes(u);
+    let comments = all.iter().find(|n| n.label() == Some("Show comments (Shift+C)")).unwrap().bounds().unwrap();
+    let options = all
+        .iter()
+        .filter(|n| n.role() == Role::Unknown && n.label().is_none())
+        .filter(|n| n.bounds().is_some_and(|b| b.y0 == comments.y0 && b.x0 > comments.x1))
+        .min_by(|a, b| a.bounds().unwrap().x0.total_cmp(&b.bounds().unwrap().x0))
+        .expect("the Options button");
+    click(u, centre(options));
+}
+
+fn front_settings(u: &Ui) -> PrototypeSettings {
+    let page = u.app.session.page().unwrap();
+    crate::present::page_settings(u.app.session.doc().unwrap(), page)
+}
+
+/// The middle of presentation tab `k` and of its close button, after `files` file tabs named
+/// "Untitled".
+fn present_tab(u: &Ui, files: usize, k: usize) -> (Pos2, Pos2) {
+    let width = |chars: usize, lo: f32, hi: f32| (12.0 * 0.6 * chars as f32 + 64.0).clamp(lo, hi);
+    let mut x = 52.0 + files as f32 * width("Untitled".len(), 120.0, 220.0);
+    let names: Vec<String> = tabs(u).as_array().unwrap().iter().map(|t| t["name"].as_str().unwrap().to_string()).collect();
+    for n in names.iter().take(k) {
+        x += width(n.chars().count(), 140.0, 260.0);
+    }
+    let w = width(names[k].chars().count(), 140.0, 260.0);
+    (pos2(x + w / 2.0, 20.0), pos2(x + w - 16.0, 20.0))
+}
+
+#[test]
+fn the_tab_is_named_after_the_file_and_page_and_its_x_closes_it() {
+    let (mut u, a, ..) = setup();
+    u.run("proto.present", json!({"start": a}));
+    assert!(presenting(&u));
+    assert_eq!(tabs(&u), json!([{"name": "Untitled - Page 1", "active": true}]));
+    click(&mut u, FILE_TAB);
+    assert!(!presenting(&u));
+    assert_eq!(tabs(&u)[0]["active"], false);
+    let (tab, close) = present_tab(&u, 1, 0);
+    click(&mut u, tab);
+    assert!(presenting(&u));
+    click(&mut u, close);
+    assert_eq!((presenting(&u), tabs(&u)), (false, json!([])));
+    assert!(!u.app.ui.home, "back to its file");
+}
+
+#[test]
+fn play_again_shows_the_tab_as_it_was_and_another_page_opens_a_new_one() {
+    let (mut u, a, b, _) = setup();
+    u.run("proto.present", json!({"start": a}));
+    u.key(pos2(720.0, 470.0), Key::ArrowRight);
+    click(&mut u, FILE_TAB);
+    u.run("proto.present", json!({"start": a}));
+    assert_eq!(tabs(&u).as_array().unwrap().len(), 1, "same page: the same tab");
+    assert_eq!(u.app.inspect()["presenter"]["current"], json!(b), "it shows the prototype as it was");
+    u.run("proto.present", json!({"start": b}));
+    assert_eq!(tabs(&u).as_array().unwrap().len(), 1);
+    assert_eq!(u.app.inspect()["presenter"]["history"], json!([]), "another start frame starts again");
+
+    click(&mut u, FILE_TAB);
+    let page = id(&u.run("page.add", json!({"name": "Second"})));
+    u.run("page.select", json!({"id": page}));
+    let c = id(&u.run("node.create", json!({"type": "frame", "name": "C", "x": 0, "y": 0, "width": 200, "height": 200})));
+    u.run("proto.present", json!({"start": c}));
+    assert_eq!(tabs(&u), json!([{"name": "Untitled - Page 1", "active": false}, {"name": "Untitled - Second", "active": true}]));
+    let (first, _) = present_tab(&u, 1, 0);
+    click(&mut u, first);
+    assert_eq!(tabs(&u), json!([{"name": "Untitled - Page 1", "active": true}, {"name": "Untitled - Second", "active": false}]));
+    assert_eq!(u.app.inspect()["presenter"]["current"], json!(b));
+}
+
+#[test]
+fn the_presentation_plays_on_when_its_file_closes() {
+    let (mut u, a, b, _) = setup();
+    let hot = id(&u.run("node.create", json!({"type": "rectangle", "parent": a, "x": 0, "y": 0, "width": 393, "height": 80})));
+    u.run("proto.interaction.add", json!({"id": hot, "dest": b}));
+    u.run("proto.present", json!({"start": a}));
+    click(&mut u, FILE_TAB);
+    u.run("file.close", json!({"index": 0, "force": true}));
+    assert_eq!(tabs(&u), json!([{"name": "Untitled - Page 1", "active": false}]));
+    let (tab, _) = present_tab(&u, 0, 0);
+    click(&mut u, tab);
+    assert!(presenting(&u));
+    let spot = u.app.inspect()["presenter"]["hotspots"][0]["rect"].clone();
+    let r: Vec<f32> = spot.as_array().unwrap().iter().map(|v| v.as_f64().unwrap() as f32).collect();
+    click(&mut u, pos2((r[0] + r[2]) / 2.0, (r[1] + r[3]) / 2.0));
+    u.frames(60, Vec::new);
+    assert_eq!(u.app.inspect()["presenter"]["current"], json!(b), "the prototype still plays");
+    u.key(pos2(700.0, 500.0), Key::Escape);
+    assert_eq!(tabs(&u), json!([]));
+    assert!(u.app.ui.home, "no file to go back to: Home");
+}
+
+#[test]
+fn a_tab_whose_file_closed_leaves_the_file_in_front_alone() {
+    let (mut u, a, ..) = setup();
+    u.run("proto.present", json!({"start": a}));
+    click(&mut u, FILE_TAB);
+    u.run("file.new", json!({}));
+    u.run("file.close", json!({"index": 0, "force": true}));
+    let (tab, _) = present_tab(&u, 1, 0);
+    click(&mut u, tab);
+    u.frames(5, Vec::new);
+    assert!(presenting(&u));
+    assert!(!crate::tabs::present_owner_active(&u.app));
+    assert_eq!(u.app.inspect()["presenter"]["current"], json!(a), "it keeps playing its own copy");
+    let before = front_settings(&u);
+    click_label(&mut u, "iPhone 16");
+    click_label(&mut u, "iPhone 17  402×874");
+    assert!(presenting(&u));
+    for size in ["Fixed size", "Responsive"] {
+        open_options(&mut u);
+        click_label(&mut u, size);
+    }
+    assert_eq!(front_settings(&u), before, "picking a device or Responsive leaves the file in front alone");
+    assert!(!u.app.session.ds().unwrap().is_dirty());
+}
+
+#[test]
+fn a_saved_file_opened_again_gets_its_tab_back() {
+    let (mut u, a, ..) = setup();
+    let dir = std::env::temp_dir().join(format!("figcraft-present-tab-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("Proto.figcraft").to_string_lossy().to_string();
+    u.run("file.saveAs", json!({"path": path}));
+    u.run("proto.present", json!({"start": a}));
+    click(&mut u, FILE_TAB);
+    u.run("file.close", json!({"index": 0}));
+    u.run("file.open", json!({"path": path}));
+    u.run("proto.present", json!({"start": a}));
+    // Saved as Proto.figcraft: the file's title follows its name.
+    assert_eq!(tabs(&u), json!([{"name": "Proto - Page 1", "active": true}]));
+    u.key(pos2(700.0, 500.0), Key::Escape);
+    assert!(!u.app.ui.home, "back to its file");
+    assert_eq!(tabs(&u), json!([]));
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+#[test]
+fn renaming_the_file_or_the_page_renames_the_tab() {
+    let (mut u, a, ..) = setup();
+    u.run("proto.present", json!({"start": a}));
+    click(&mut u, FILE_TAB);
+    u.run("file.rename", json!({"name": "Playground"}));
+    u.run("page.rename", json!({"name": "Calendar"}));
+    u.frame(vec![]);
+    assert_eq!(tabs(&u), json!([{"name": "Playground - Calendar", "active": false}]));
+    u.run("file.close", json!({"index": 0, "force": true}));
+    u.frame(vec![]);
+    assert_eq!(tabs(&u)[0]["name"], "Playground - Calendar", "the names stay when the file closes");
+}
diff --git a/crates/ui-egui/src/present_tests.rs b/crates/ui-egui/src/present_tests.rs
index a1e4ebe23..73bccaedf 100644
--- a/crates/ui-egui/src/present_tests.rs
+++ b/crates/ui-egui/src/present_tests.rs
@@ -23,11 +23,18 @@ impl Ui {
     }
 
     pub(crate) fn frame(&mut self, events: Vec<Event>) {
+        self.frame_output(events);
+    }
+
+    /// [`Self::frame`], returning what egui output (the AccessKit tree when it's enabled).
+    pub(crate) fn frame_output(&mut self, events: Vec<Event>) -> egui::FullOutput {
         self.time += 1.0 / 60.0;
         let input =
             RawInput { screen_rect: Some(Rect::from_min_size(Pos2::ZERO, vec2(1440.0, 900.0))), time: Some(self.time), events, ..Default::default() };
         let app = &mut self.app;
-        self.ctx.run_ui(input, |ui| app.ui(ui)).textures_delta.clear();
+        let mut out = self.ctx.run_ui(input, |ui| app.ui(ui));
+        out.textures_delta.clear();
+        out
     }
 
     pub(crate) fn frames(&mut self, n: usize, events: impl Fn() -> Vec<Event>) {
@@ -175,6 +182,38 @@ fn the_frame_scrolls_on_the_device_screen_by_wheel_and_drag() {
     assert_eq!(u.scroll_y(), 0.0);
 }
 
+/// A long top-level frame scrolls on a phone with no overflow setting, as in Figma: the landing
+/// page template's Phone frame ("No scrolling", hugging its height) scrolls by the wheel.
+#[test]
+fn a_top_level_frame_taller_than_the_phone_scrolls_without_an_overflow_setting() {
+    let mut s = Session::new();
+    s.execute("file.newFromTemplate", &json!({"template": "landing-page"})).unwrap();
+    s.execute("proto.settings", &json!({"device": "iPhone 16", "responsive": true})).unwrap();
+    let doc = s.doc().unwrap();
+    let page = doc.first_page().unwrap();
+    let phone = doc.top_frames(page).into_iter().find(|f| doc.node(*f).unwrap().name == "Phone").unwrap();
+    assert_eq!(doc.node(phone).unwrap().overflow, figcraft_doc::proto::Overflow::None);
+    let mut u = Ui::new(s);
+    u.run("proto.preview", json!({"start": phone}));
+    let range = u.preview()["scrollRange"][1].as_f64().unwrap();
+    assert!(range > 1000.0, "the page is far taller than the screen: {range}");
+    let c = u.pane().center();
+    let wheel = move || {
+        vec![
+            Event::PointerMoved(c),
+            Event::MouseWheel {
+                unit: egui::MouseWheelUnit::Point,
+                delta: vec2(0.0, -60.0),
+                phase: egui::TouchPhase::Move,
+                modifiers: Default::default(),
+            },
+        ]
+    };
+    u.frames(6, wheel);
+    u.frames(20, Vec::new);
+    assert!(u.scroll_y() > 0.0, "{}", u.scroll_y());
+}
+
 #[test]
 fn full_window_presenter_shares_the_player() {
     let (mut u, a, ..) = setup();
diff --git a/crates/ui-egui/src/present_view_tests.rs b/crates/ui-egui/src/present_view_tests.rs
index 3571b2add..42647dc09 100644
--- a/crates/ui-egui/src/present_view_tests.rs
+++ b/crates/ui-egui/src/present_view_tests.rs
@@ -95,6 +95,28 @@ fn scale_options_match_the_command_and_cycle() {
     assert!(!PresentScale::options(true).contains(&PresentScale::FitWidth));
 }
 
+#[test]
+fn presentation_tab_keeps_the_current_screen_when_returning_to_the_editor() {
+    let (mut u, a, b, _) = setup();
+    u.run("proto.present", json!({"start": a}));
+    u.key(pos2(720.0, 470.0), Key::ArrowRight);
+    assert_eq!(presenter(&u)["current"], json!(b));
+
+    let design_tab = pos2(100.0, 20.0);
+    u.button(design_tab, true);
+    u.button(design_tab, false);
+    assert!(u.app.ui.present.is_none());
+    assert_eq!(presenter(&u)["current"], json!(b));
+
+    let name_len = u.app.session.doc().unwrap().name.chars().count() as f32;
+    let design_w = (12.0 * 0.6 * name_len + 64.0).clamp(120.0, 220.0);
+    let preview_tab = pos2(8.0 + 44.0 + design_w + 40.0, 20.0);
+    u.button(preview_tab, true);
+    u.button(preview_tab, false);
+    assert!(u.app.ui.present.is_some());
+    assert_eq!(presenter(&u)["current"], json!(b));
+}
+
 /// No device: a big screen (2000×3000) and a small one, presenting the big one.
 fn big() -> (Ui, NodeId) {
     let mut s = Session::new();
@@ -117,10 +139,10 @@ fn num(v: &Value) -> f64 {
 fn presenter_scales_by_its_options_and_pans_what_overflows() {
     let (mut u, big) = big();
     let at = pos2(720.0, 470.0);
-    // Fit: scaled down to the 1376×796 inside the padding; nothing pans.
+    // Fit: the tab strip leaves 1376×756 inside the presenter's padding; nothing pans.
     let p = presenter(&u);
     assert_eq!(p["scale"], "fit");
-    assert!((num(&p["zoom"]) - 796.0 / 3000.0).abs() < 1e-3, "{p}");
+    assert!((num(&p["zoom"]) - 756.0 / 3000.0).abs() < 1e-3, "{p}");
     assert_eq!(p["panRange"], json!([0.0, 0.0]));
     // Z: fit width (the whole 1440 width; the rest of the height pans).
     u.key(at, Key::Z);
@@ -128,14 +150,14 @@ fn presenter_scales_by_its_options_and_pans_what_overflows() {
     assert_eq!(p["scale"], "fitWidth");
     assert!((num(&p["zoom"]) - 0.72).abs() < 1e-3, "{p}");
     assert_eq!(p["panRange"][0], 0.0);
-    assert!((num(&p["panRange"][1]) - (2160.0 - 860.0)).abs() < 1.0, "{p}");
+    assert!((num(&p["panRange"][1]) - (2160.0 - 820.0)).abs() < 1.0, "{p}");
     // Z: fill (here the width decides too), then 100%: both ways overflow, centred across at the top.
     u.key(at, Key::Z);
     assert_eq!(presenter(&u)["scale"], "fill");
     u.key(at, Key::Z);
     let p = presenter(&u);
     assert_eq!((p["scale"].as_str(), num(&p["zoom"])), (Some("actual"), 1.0));
-    assert_eq!(p["panRange"], json!([624.0, 2204.0]));
+    assert_eq!(p["panRange"], json!([624.0, 2244.0]));
     assert_eq!(p["pan"], json!([312.0, 0.0]));
     // The wheel pans down; a drag pans with the pointer.
     let wheel = move || {
@@ -192,7 +214,7 @@ fn devices_turn_and_their_frame_can_hide() {
     let with_body = num(&presenter(&u)["zoom"]);
     u.run("proto.presentOptions", json!({"deviceFrame": false}));
     let bare = num(&presenter(&u)["zoom"]);
-    assert!(bare > with_body && (bare - 796.0 / 852.0).abs() < 1e-3, "{with_body} {bare}");
+    assert!(bare > with_body && (bare - 756.0 / 852.0).abs() < 1e-3, "{with_body} {bare}");
     // A device offers no fit width: Z goes fit → fill → 100%.
     u.key(pos2(720.0, 470.0), Key::Z);
     assert_eq!(presenter(&u)["scale"], "fill");
diff --git a/crates/ui-egui/src/proto_canvas.rs b/crates/ui-egui/src/proto_canvas.rs
index 6310c05c1..956523ee9 100644
--- a/crates/ui-egui/src/proto_canvas.rs
+++ b/crates/ui-egui/src/proto_canvas.rs
@@ -8,7 +8,6 @@ use egui::{Color32, CornerRadius, Id, Pos2, Rect, Shape, Stroke, StrokeKind, pos
 use figcraft_doc::{Document, NodeId};
 use serde_json::{Value, json};
 
-use crate::theme::ACCENT;
 use crate::{FigApp, RightTab};
 
 const HANDLE_R: f32 = 7.0;
@@ -140,7 +139,7 @@ fn arrow(painter: &egui::Painter, pts: &[Pos2; 4], col: Color32) {
 }
 
 fn plus_handle(painter: &egui::Painter, c: Pos2, hot: bool) {
-    painter.circle_filled(c, HANDLE_R + if hot { 1.0 } else { 0.0 }, ACCENT);
+    painter.circle_filled(c, HANDLE_R + if hot { 1.0 } else { 0.0 }, crate::theme::canvas_accent(painter.ctx()));
     painter.circle_stroke(c, HANDLE_R + if hot { 1.0 } else { 0.0 }, Stroke::new(1.5, Color32::WHITE));
     painter.line_segment([c - vec2(3.5, 0.0), c + vec2(3.5, 0.0)], Stroke::new(1.5, Color32::WHITE));
     painter.line_segment([c - vec2(0.0, 3.5), c + vec2(0.0, 3.5)], Stroke::new(1.5, Color32::WHITE));
@@ -161,7 +160,11 @@ pub fn draw(app: &FigApp, painter: &egui::Painter) {
         let selected = sel.contains(&nd.source);
         let is_open = open == Some((nd.source, nd.index));
         let near = dragging.is_none() && hover.is_some_and(|q| bezier_distance(&nd.pts, q) < 5.0);
-        let col = if selected || is_open || near { ACCENT } else { ACCENT.gamma_multiply(0.55) };
+        let col = if selected || is_open || near {
+            crate::theme::canvas_accent(painter.ctx())
+        } else {
+            crate::theme::canvas_accent(painter.ctx()).gamma_multiply(0.55)
+        };
         let w = if is_open || near {
             2.5
         } else if selected {
@@ -177,7 +180,12 @@ pub fn draw(app: &FigApp, painter: &egui::Painter) {
                 .and_then(|it| figcraft_doc::proto::walk(&it.actions).find_map(|a| a.dest()))
             && let Some(r) = screen_rect(app, doc, dest)
         {
-            painter.rect_stroke(r, CornerRadius::ZERO, Stroke::new(1.0, ACCENT.gamma_multiply(0.7)), StrokeKind::Outside);
+            painter.rect_stroke(
+                r,
+                CornerRadius::ZERO,
+                Stroke::new(1.0, crate::theme::canvas_accent(painter.ctx()).gamma_multiply(0.7)),
+                StrokeKind::Outside,
+            );
         }
         painter.add(egui::epaint::CubicBezierShape::from_points_stroke(nd.pts, false, Color32::TRANSPARENT, Stroke::new(w, col)));
         painter.circle_filled(nd.pts[0], 3.5, col);
@@ -190,12 +198,17 @@ pub fn draw(app: &FigApp, painter: &egui::Painter) {
                 && doc.top_level_frame(d.source) != Some(f)
                 && let Some(r) = screen_rect(app, doc, f)
             {
-                painter.rect_stroke(r, CornerRadius::ZERO, Stroke::new(2.0, ACCENT), StrokeKind::Outside);
+                painter.rect_stroke(r, CornerRadius::ZERO, Stroke::new(2.0, crate::theme::canvas_accent(painter.ctx())), StrokeKind::Outside);
             }
             let dx = ((d.pos.x - d.from.x).abs() * 0.5).max(30.0) * if d.pos.x >= d.from.x { 1.0 } else { -1.0 };
             let pts = [d.from, d.from + vec2(dx, 0.0), d.pos - vec2(dx, 0.0), d.pos];
-            painter.add(egui::epaint::CubicBezierShape::from_points_stroke(pts, false, Color32::TRANSPARENT, Stroke::new(2.0, ACCENT)));
-            arrow(painter, &pts, ACCENT);
+            painter.add(egui::epaint::CubicBezierShape::from_points_stroke(
+                pts,
+                false,
+                Color32::TRANSPARENT,
+                Stroke::new(2.0, crate::theme::canvas_accent(painter.ctx())),
+            ));
+            arrow(painter, &pts, crate::theme::canvas_accent(painter.ctx()));
             plus_handle(painter, d.from, true);
         }
         None => {
@@ -272,6 +285,9 @@ pub fn input(app: &mut FigApp, ui: &egui::Ui, resp: &egui::Response) -> bool {
         crate::proto_panel::open_editor(&ctx, Some((n.source, n.index)));
         return true;
     }
+    if pressed && crate::proto_panel::editor(&ctx).is_some() {
+        crate::proto_panel::open_editor(&ctx, None);
+    }
     false
 }
 
@@ -279,6 +295,26 @@ pub fn input(app: &mut FigApp, ui: &egui::Ui, resp: &egui::Response) -> bool {
 mod tests {
     use super::*;
 
+    /// A press on a connection handle takes the keyboard from the Pages list, as a press anywhere
+    /// else on the canvas does, so a later Delete can't take the page (#859).
+    #[test]
+    fn a_press_on_a_connection_handle_ends_the_pages_list_focus() {
+        let mut s = figcraft_engine::Session::new();
+        let a = s.execute("frame.create", &json!({"x": 0, "y": 0, "width": 200, "height": 150})).unwrap();
+        let a = crate::present_tests::id(&a);
+        s.execute("select.set", &json!({"ids": [a]})).unwrap();
+        let mut u = crate::present_tests::Ui::new(s);
+        u.app.ui.right_tab = RightTab::Prototype;
+        u.run("view.zoomSelection", json!({}));
+        u.frames(2, Vec::new);
+        u.app.ui.pages_focus = u.app.session.ds().ok().map(|d| d.uid);
+        let doc = u.app.session.doc().unwrap().clone();
+        let (_, at) = *handles(&u.app, &doc, &[a]).first().unwrap();
+        u.button(at, true);
+        assert!(u.app.ui.pages_focus.is_none());
+        u.button(at, false);
+    }
+
     #[test]
     fn curves_leave_the_facing_side() {
         let a = Rect::from_min_size(pos2(0.0, 0.0), vec2(50.0, 20.0));
diff --git a/crates/ui-egui/src/proto_editor_tests.rs b/crates/ui-egui/src/proto_editor_tests.rs
index 2372c20e0..80d49616d 100644
--- a/crates/ui-egui/src/proto_editor_tests.rs
+++ b/crates/ui-egui/src/proto_editor_tests.rs
@@ -226,3 +226,104 @@ fn the_presenter_inspects_the_layer_under_the_pointer() {
     assert_eq!(presenter(&u)["inspected"], json!(a));
     assert_eq!(u.app.inspect()["presentOptions"]["inspect"], json!(true));
 }
+
+#[test]
+fn deleting_a_prototype_interaction_removes_the_interaction_not_the_component() {
+    let (s, _a, b, btn) = setup();
+    let mut u = Ui::new(s);
+    u.app.ui.right_tab = crate::RightTab::Prototype;
+    u.run("select.set", json!({"ids": [btn]}));
+    crate::proto_panel::open_editor(&u.ctx, Some((btn, 0)));
+    u.frames(1, Vec::new);
+
+    assert!(u.app.session.doc().unwrap().node(btn).is_some());
+    assert_eq!(u.app.session.doc().unwrap().node(btn).unwrap().interactions.len(), 1);
+    assert_eq!(crate::proto_panel::editor(&u.ctx), Some((btn, 0)));
+
+    // Pressing Delete when an interaction is selected should delete the interaction, NOT the component.
+    u.key(pos2(100.0, 100.0), egui::Key::Delete);
+
+    assert!(u.app.session.doc().unwrap().node(btn).is_some(), "Bug #767 regression: component was deleted when deleting prototype interaction!");
+    assert_eq!(u.app.session.doc().unwrap().node(btn).unwrap().interactions.len(), 0, "the interaction should be removed");
+    assert_eq!(crate::proto_panel::editor(&u.ctx), None);
+
+    // Re-add interaction and test Backspace as well.
+    u.run("proto.interaction.add", json!({"id": btn, "dest": b}));
+    assert_eq!(u.app.session.doc().unwrap().node(btn).unwrap().interactions.len(), 1);
+    crate::proto_panel::open_editor(&u.ctx, Some((btn, 0)));
+    u.frames(1, Vec::new);
+    u.key(pos2(100.0, 100.0), egui::Key::Backspace);
+    assert!(u.app.session.doc().unwrap().node(btn).is_some());
+    assert_eq!(u.app.session.doc().unwrap().node(btn).unwrap().interactions.len(), 0);
+    assert_eq!(crate::proto_panel::editor(&u.ctx), None);
+
+    // When NO interaction is active, Delete deletes the component as normal.
+    u.key(pos2(100.0, 100.0), egui::Key::Delete);
+    assert!(u.app.session.doc().unwrap().node(btn).is_none(), "when no interaction is selected, Delete removes the layer");
+}
+
+/// Edit ▸ Delete from the menu bar does the same as the Delete key (#767).
+#[test]
+fn edit_delete_from_the_menu_removes_the_open_interaction_not_the_layer() {
+    let (s, _a, _b, btn) = setup();
+    let mut u = Ui::new(s);
+    u.app.ui.right_tab = crate::RightTab::Prototype;
+    u.run("select.set", json!({"ids": [btn]}));
+    crate::proto_panel::open_editor(&u.ctx, Some((btn, 0)));
+    u.frames(1, Vec::new);
+    crate::menus::invoke(&mut u.app, "edit.delete");
+    let doc = u.app.session.doc().unwrap();
+    assert!(doc.node(btn).is_some_and(|n| n.interactions.is_empty()), "the interaction goes, the layer stays");
+    assert_eq!(crate::proto_panel::editor(&u.ctx), None);
+    crate::menus::invoke(&mut u.app, "edit.delete");
+    assert!(u.app.session.doc().unwrap().node(btn).is_none(), "with no interaction open, Edit ▸ Delete deletes the layer");
+}
+
+#[test]
+fn escape_closes_prototype_editor_without_deselecting_layer() {
+    let (s, a, _b, btn) = setup();
+    let mut u = Ui::new(s);
+    u.app.ui.right_tab = crate::RightTab::Prototype;
+    u.run("select.set", json!({"ids": [btn]}));
+    crate::proto_panel::open_editor(&u.ctx, Some((btn, 0)));
+    u.frames(1, Vec::new);
+
+    assert_eq!(crate::proto_panel::editor(&u.ctx), Some((btn, 0)));
+    assert_eq!(u.app.session.selection(), vec![btn]);
+
+    // First Escape closes the interaction editor; layer remains selected.
+    u.key(pos2(100.0, 100.0), egui::Key::Escape);
+    assert_eq!(crate::proto_panel::editor(&u.ctx), None);
+    assert_eq!(u.app.session.selection(), vec![btn], "layer remains selected");
+
+    // Second Escape steps out to parent frame.
+    u.key(pos2(100.0, 100.0), egui::Key::Escape);
+    assert_eq!(u.app.session.selection(), vec![a], "steps out to parent frame");
+
+    // Third Escape deselects all.
+    u.key(pos2(100.0, 100.0), egui::Key::Escape);
+    assert!(u.app.session.selection().is_empty(), "selection cleared on third escape");
+}
+
+/// After a click in the Pages list, Delete that removes an interaction ends the list's hold on the
+/// keyboard: with the layer deselected afterwards, Delete doesn't take the page (#859).
+#[test]
+fn deleting_an_interaction_ends_the_pages_list_focus() {
+    let (s, _a, _b, btn) = setup();
+    let mut u = Ui::new(s);
+    let first = u.app.session.page().unwrap();
+    u.run("page.add", json!({}));
+    u.run("page.select", json!({"id": first}));
+    // As after a click on the page's row (layers_keys_tests clicks the real row).
+    u.app.ui.pages_focus = u.app.session.ds().ok().map(|d| d.uid);
+    u.app.ui.right_tab = crate::RightTab::Prototype;
+    u.run("select.set", json!({"ids": [btn]}));
+    crate::proto_panel::open_editor(&u.ctx, Some((btn, 0)));
+    u.frames(1, Vec::new);
+    u.key(pos2(100.0, 100.0), egui::Key::Delete);
+    assert_eq!(u.app.session.doc().unwrap().node(btn).unwrap().interactions.len(), 0);
+    assert!(u.app.ui.pages_focus.is_none());
+    u.run("select.none", json!({}));
+    u.key(pos2(100.0, 100.0), egui::Key::Delete);
+    assert_eq!(u.app.session.doc().unwrap().pages.len(), 2, "the page stays");
+}
diff --git a/crates/ui-egui/src/proto_panel.rs b/crates/ui-egui/src/proto_panel.rs
index 47312e991..747dbaf6a 100644
--- a/crates/ui-egui/src/proto_panel.rs
+++ b/crates/ui-egui/src/proto_panel.rs
@@ -40,6 +40,39 @@ pub fn editor(ctx: &egui::Context) -> Option<(NodeId, usize)> {
     ctx.data(|d| d.get_temp(editor_id()))
 }
 
+/// Delete the selected interaction (when one is active in the Prototype tab).
+/// Returns true if an interaction was deleted.
+pub fn delete_selected_interaction(app: &mut FigApp, ctx: &egui::Context) -> bool {
+    if app.ui.right_tab != crate::RightTab::Prototype {
+        return false;
+    }
+    let Some((node, index)) = editor(ctx) else { return false };
+    let Ok(ds) = app.session.ds() else { return false };
+    if ds.doc.node(node).and_then(|n| n.interactions.get(index)).is_none() {
+        open_editor(ctx, None);
+        return false;
+    }
+    open_editor(ctx, None);
+    // Delete went to the interaction, so a later one doesn't go to the Pages list.
+    app.ui.pages_focus = None;
+    let ids = targets_for(app, node);
+    app.run("proto.interaction.remove", json!({"ids": ids, "index": index}));
+    true
+}
+
+/// Close the interaction editor if open. Returns true if it was open.
+pub fn close_editor(ctx: &egui::Context) -> bool {
+    if capturing(ctx) || crate::variable_ui::picker_open(ctx) {
+        return false;
+    }
+    if editor(ctx).is_some() {
+        open_editor(ctx, None);
+        true
+    } else {
+        false
+    }
+}
+
 const TRIGGERS: [&str; 10] = [
     tr_noop("On click"),
     tr_noop("On drag"),
@@ -607,8 +640,6 @@ fn interactions(app: &mut FigApp, ui: &mut Ui, doc: &Document, page: NodeId, nod
 #[allow(clippy::too_many_arguments)]
 fn editor_popover(app: &mut FigApp, ctx: &egui::Context, doc: &Document, page: NodeId, node: NodeId, k: usize, it: &Interaction, at: Pos2) {
     let t = Tokens::get(ctx);
-    // Escape in a field (it cancels the edit) doesn't close the editor.
-    let typing = ctx.egui_wants_keyboard_input();
     let width = 280.0;
     let screen = ctx.content_rect();
     let pos = pos2(at.x - width, at.y.min(screen.max.y - 420.0).max(screen.min.y + 48.0));
@@ -652,8 +683,7 @@ fn editor_popover(app: &mut FigApp, ctx: &egui::Context, doc: &Document, page: N
                 });
             });
     });
-    let escape = ctx.input(|i| i.key_pressed(egui::Key::Escape)) && !typing && !capturing(ctx) && !crate::variable_ui::picker_open(ctx);
-    if close || escape {
+    if close {
         open_editor(ctx, None);
     }
 }
@@ -735,7 +765,7 @@ fn trigger_rows(app: &mut FigApp, ui: &mut Ui, node: NodeId, k: usize, it: &Inte
                 let id = capture_id().with("field");
                 ui.painter().rect_filled(r, CornerRadius::same(5), t.field);
                 if cap {
-                    ui.painter().rect_stroke(r, CornerRadius::same(5), Stroke::new(1.0, t.accent), StrokeKind::Inside);
+                    ui.painter().rect_stroke(r, CornerRadius::same(5), Stroke::new(1.0, ACCENT), StrokeKind::Inside);
                     ui.memory_mut(|m| m.request_focus(id));
                     let _ = ui.interact(r, id, Sense::focusable_noninteractive());
                     let pressed = ui.input(|i| {
@@ -896,7 +926,20 @@ pub(crate) fn action_fields(app: &mut FigApp, ui: &mut Ui, doc: &Document, page:
                     let w = ((ui.available_width() - 6.0) / 2.0).max(36.0);
                     for (i, (name, key)) in [("X", "proto_ov_x"), ("Y", "proto_ov_y")].into_iter().enumerate() {
                         let shown = offset.and_then(|o| o.get(i).copied());
-                        let Some(e) = widgets::number_field_bindable(ui, slot.id(key), Lead::Text(name), shown, "", w, 1.0, None, tr("Auto")).0
+                        // "Auto" is no offset (right below the layer), not 0: the word isn't taken
+                        // as a value here.
+                        let Some(e) = widgets::number_field_bindable(
+                            ui,
+                            slot.id(key),
+                            Lead::Text(name),
+                            shown,
+                            "",
+                            w,
+                            1.0,
+                            None,
+                            widgets::Empty::Text(tr("Auto")),
+                        )
+                        .0
                         else {
                             continue;
                         };
@@ -1020,7 +1063,7 @@ fn animation_rows(app: &mut FigApp, ui: &mut Ui, node: NodeId, k: usize, it: &In
                     let w = ui.available_width().max(200.0);
                     let (r, rr) = ui.allocate_exact_size(vec2(w, 26.0), Sense::click());
                     if rr.hovered() {
-                        ui.painter().rect_filled(r, CornerRadius::same(5), ACCENT);
+                        ui.painter().rect_filled(r, CornerRadius::same(5), t.menu_hover);
                     }
                     let col = if rr.hovered() { Color32::WHITE } else { t.text };
                     curve(ui.painter(), Rect::from_min_size(pos2(r.min.x + 6.0, r.min.y + 4.0), vec2(28.0, 18.0)), *e, col, None);
diff --git a/crates/ui-egui/src/proto_responsive_tests.rs b/crates/ui-egui/src/proto_responsive_tests.rs
index fc9ccda21..f0ead8e98 100644
--- a/crates/ui-egui/src/proto_responsive_tests.rs
+++ b/crates/ui-egui/src/proto_responsive_tests.rs
@@ -69,8 +69,8 @@ fn without_a_device_a_responsive_frame_fills_the_window_at_100_percent() {
     let mut u = Ui::new(s);
     u.run("proto.present", json!({"start": w}));
     let p = presenter(&u);
-    // The window is 1440×900; the bar takes 40.
-    assert_eq!(size(&p["frameSize"]), (1440.0, 860.0), "{p}");
+    // The window is 1440×900; the title and tab bars take 80.
+    assert_eq!(size(&p["frameSize"]), (1440.0, 820.0), "{p}");
     assert_eq!(p["zoom"], json!(1.0));
     assert_eq!(size(&p["panRange"]), (0.0, 0.0));
     // Z has nothing to cycle: the size options don't apply.
diff --git a/crates/ui-egui/src/resources_tests.rs b/crates/ui-egui/src/resources_tests.rs
new file mode 100644
index 000000000..428690985
--- /dev/null
+++ b/crates/ui-egui/src/resources_tests.rs
@@ -0,0 +1,67 @@
+//! The toolbar's Resources button and Shift+I open the Assets panel (#710), from a collapsed
+//! sidebar and from the version history too.
+
+use egui::accesskit::Role;
+use egui::{Event, Key, Modifiers, Pos2, pos2};
+use figcraft_engine::Session;
+
+use crate::LeftTab;
+use crate::layers_drag_tests::Ui;
+
+fn click(u: &mut Ui, p: Pos2) {
+    u.button(p, true);
+    u.button(p, false);
+    u.frame(vec![]);
+}
+
+fn shift_i(u: &mut Ui) {
+    let modifiers = Modifiers::SHIFT;
+    u.frame(vec![
+        Event::Key { key: Key::I, physical_key: None, pressed: true, repeat: false, modifiers },
+        Event::Key { key: Key::I, physical_key: None, pressed: false, repeat: false, modifiers },
+    ]);
+    u.frame(vec![]);
+}
+
+/// The middle of the toolbar's Resources button, found in the AccessKit tree.
+fn resources_button(u: &mut Ui) -> Pos2 {
+    u.ctx.enable_accesskit();
+    u.frame(vec![]);
+    let out = u.frame_output(vec![]);
+    let nodes = out.platform_output.accesskit_update.expect("an AccessKit update").nodes;
+    let n = nodes.iter().map(|(_, n)| n).find(|n| n.role() == Role::Button && n.label() == Some("Resources")).expect("Resources");
+    let b = n.bounds().expect("bounds");
+    pos2(((b.x0 + b.x1) / 2.0) as f32, ((b.y0 + b.y1) / 2.0) as f32)
+}
+
+fn assets_shown(u: &Ui) -> bool {
+    u.app.ui.left_tab == LeftTab::Assets && !u.app.ui.left_collapsed && !u.app.ui.versions.open
+}
+
+/// The three states the sidebar can be in when Resources is asked for.
+fn starts() -> Vec<(&'static str, Ui)> {
+    let shown = Ui::new(Session::new());
+    let mut collapsed = Ui::new(Session::new());
+    collapsed.app.ui.left_collapsed = true;
+    let mut versions = Ui::new(Session::new());
+    crate::versions::open(&mut versions.app);
+    vec![("layers", shown), ("collapsed", collapsed), ("version history", versions)]
+}
+
+#[test]
+fn the_resources_button_opens_the_assets_panel() {
+    for (name, mut u) in starts() {
+        let at = resources_button(&mut u);
+        click(&mut u, at);
+        assert!(assets_shown(&u), "{name}: the Assets panel is open");
+    }
+}
+
+#[test]
+fn shift_i_opens_the_assets_panel() {
+    for (name, mut u) in starts() {
+        u.frame(vec![]);
+        shift_i(&mut u);
+        assert!(assets_shown(&u), "{name}: the Assets panel is open");
+    }
+}
diff --git a/crates/ui-egui/src/right.rs b/crates/ui-egui/src/right.rs
index 10847896e..6738f3004 100644
--- a/crates/ui-egui/src/right.rs
+++ b/crates/ui-egui/src/right.rs
@@ -11,7 +11,7 @@ use crate::i18n::{tr, trf, trn};
 use crate::icons::{self, Icon};
 use crate::list_drag::{ListDrag, move_flags, remove_flags};
 use crate::style_picker::{self, StyleSlot};
-use crate::theme::{ACCENT, Tokens, regular, semibold};
+use crate::theme::{Tokens, regular, semibold};
 use crate::widgets::{self, Edit, FIELD_H, FieldEdit, Lead, PAD};
 use crate::{FigApp, RightTab};
 
@@ -84,12 +84,12 @@ pub fn right_panel(app: &mut FigApp, ui: &mut Ui) {
     // Top bar: people (you and the others in a live session), present, share.
     let (top, _) = ui.allocate_exact_size(vec2(w, 48.0), Sense::hover());
     // As wide as its label needs (longer in some languages).
-    let label = ui.painter().layout_no_wrap(tr("Share").to_string(), semibold(11.5), Color32::WHITE);
+    let label = ui.painter().layout_no_wrap(tr("Share").to_string(), semibold(11.5), t.accent_on);
     let sw = (label.size().x + 24.0).max(56.0);
     let share = Rect::from_min_size(pos2(top.max.x - 14.0 - sw, top.center().y - 16.0), vec2(sw, 32.0));
     let sresp = ui.interact(share, ui.id().with("share"), Sense::click()).tip(tr("Share: live session, export"));
-    ui.painter().rect_filled(share, CornerRadius::same(6), if sresp.hovered() { t.accent_hover } else { ACCENT });
-    ui.painter().galley(share.center() - label.size() / 2.0, label, Color32::WHITE);
+    ui.painter().rect_filled(share, CornerRadius::same(6), if sresp.hovered() { t.accent_hover } else { t.accent });
+    ui.painter().galley(share.center() - label.size() / 2.0, label, t.accent_on);
     crate::live::share_popover(app, &sresp);
     // Play presents; its chevron opens the play menu (present, or preview in a pane).
     let play = Rect::from_min_size(pos2(share.min.x - 50.0, top.center().y - 14.0), vec2(42.0, 28.0));
@@ -135,6 +135,9 @@ pub fn right_panel(app: &mut FigApp, ui: &mut Ui) {
         }
         ui.painter().galley(pos2(r.min.x + 8.0, r.center().y - galley.size().y / 2.0), galley, if active { t.text } else { t.text_secondary });
         if resp.clicked() {
+            if app.ui.right_tab != tab {
+                crate::proto_panel::open_editor(ui.ctx(), None);
+            }
             app.ui.right_tab = tab;
         }
         x = r.max.x + 2.0;
@@ -281,13 +284,15 @@ pub fn menu_row(ui: &mut Ui, label: &str, shortcut: &str, art_w: f32, art: impl
     a11y::own_focus(&resp);
     let hovered = resp.hovered() || resp.has_focus();
     if hovered {
-        ui.painter().rect_filled(r, CornerRadius::same(5), ACCENT);
+        ui.painter().rect_filled(r, CornerRadius::same(5), t.menu_hover);
     }
-    let col = if hovered { Color32::WHITE } else { t.text };
+    // These menus sit on the theme's popup fill (white in the light theme), not on the dark
+    // `t.menu` of the menu bar: the theme's text, white only on the green highlight (#972).
+    let col = if hovered { t.menu_text } else { t.text };
     ui.painter().galley(pos2(r.min.x + MENU_PAD, r.center().y - text.size().y / 2.0), text, col);
     if let Some(k) = keys {
         let at = pos2(r.max.x - MENU_PAD - k.size().x, r.center().y - k.size().y / 2.0);
-        ui.painter().galley(at, k, if hovered { Color32::WHITE } else { t.text_secondary });
+        ui.painter().galley(at, k, if hovered { t.menu_text } else { t.text_secondary });
     }
     art(ui.painter(), r, col);
     resp
@@ -380,6 +385,7 @@ fn design(app: &mut FigApp, ui: &mut Ui) {
     widgets::separator(ui);
     effects(app, ui, &doc, &sel);
     widgets::separator(ui);
+    crate::selection_colors::section(app, ui, &doc, &sel);
     if sel.iter().all(|i| doc.node(*i).is_some_and(|n| n.kind.is_frame_like())) {
         grids(app, ui, &doc, &sel);
         widgets::separator(ui);
@@ -656,7 +662,7 @@ fn position_fields(app: &mut FigApp, ui: &mut Ui, doc: &Document, sel: &[NodeId]
     });
     widgets::sublabels(ui, tr("Rotation"), None);
     row(ui, 32.0, |ui| {
-        let e = widgets::number_field_mixed(ui, Id::new("pos_rot"), Lead::Icon(Icon::CornerRadius, tr("Rotation")), rot, "°", col, 1.0);
+        let e = widgets::number_field_mixed(ui, Id::new("pos_rot"), Lead::Icon(Icon::Angle, tr("Rotation")), rot, "°", col, 1.0);
         app.field_of(&ids, "rotation", e, rot_of, |v| json!(v));
         let items = [
             (Icon::Rotate, tr("Rotate 90° right")),
@@ -875,44 +881,32 @@ fn appearance(app: &mut FigApp, ui: &mut Ui, doc: &Document, sel: &[NodeId]) {
     });
     if indep_ok && ui.data(|d| d.get_temp::<bool>(Id::new("indep_corners"))).unwrap_or(false) {
         let radii = common(doc, sel, |n| n.corners.radii);
-        let keys = [
-            ("topLeftRadius", tr("Top left radius")),
-            ("topRightRadius", tr("Top right radius")),
-            ("bottomRightRadius", tr("Bottom right radius")),
-            ("bottomLeftRadius", tr("Bottom left radius")),
+        // `k` indexes `radii` ([top left, top right, bottom right, bottom left]); the fields sit
+        // where their corners are: top left, top right / bottom left, bottom right.
+        let corners = [
+            ("topLeftRadius", tr("Top left radius"), Icon::CornerTopLeft, 0),
+            ("topRightRadius", tr("Top right radius"), Icon::CornerTopRight, 1),
+            ("bottomLeftRadius", tr("Bottom left radius"), Icon::CornerBottomLeft, 3),
+            ("bottomRightRadius", tr("Bottom right radius"), Icon::CornerBottomRight, 2),
         ];
-        row(ui, 32.0, |ui| {
-            for (k, (key, name)) in keys.iter().enumerate().take(2) {
-                let e = crate::variable_ui::number_field(
-                    app,
-                    ui,
-                    &ids,
-                    key,
-                    Id::new(("corner", k)),
-                    Lead::Icon(Icon::CornerRadius, name),
-                    radii.map(|r| r[k]),
-                    "",
-                    col,
-                );
-                app.field(&ids, key, e, |v| json!(v.max(0.0)));
-            }
-        });
-        row(ui, 32.0, |ui| {
-            for (k, (key, name)) in keys.iter().enumerate().skip(2) {
-                let e = crate::variable_ui::number_field(
-                    app,
-                    ui,
-                    &ids,
-                    key,
-                    Id::new(("corner", k)),
-                    Lead::Icon(Icon::CornerRadius, name),
-                    radii.map(|r| r[k]),
-                    "",
-                    col,
-                );
-                app.field(&ids, key, e, |v| json!(v.max(0.0)));
-            }
-        });
+        for pair in corners.chunks(2) {
+            row(ui, 32.0, |ui| {
+                for (key, name, icon, k) in pair {
+                    let e = crate::variable_ui::number_field(
+                        app,
+                        ui,
+                        &ids,
+                        key,
+                        Id::new(("corner", *k)),
+                        Lead::Icon(*icon, name),
+                        radii.map(|r| r[*k]),
+                        "",
+                        col,
+                    );
+                    app.field(&ids, key, e, |v| json!(v.max(0.0)));
+                }
+            });
+        }
         let sm = common(doc, sel, |n| (n.corners.smoothing * 100.0).round());
         widgets::sublabels(ui, tr("Corner smoothing"), None);
         row(ui, 32.0, |ui| {
@@ -957,8 +951,8 @@ fn variable_modes(app: &mut FigApp, ui: &mut Ui, doc: &Document, sel: &[NodeId])
     // The collection's name, then a wider mode picker ("Auto (Light)") across both field columns.
     let col = widgets::col_width(ui.available_width());
     let (name_w, pick_w) = ((col * 0.7).round(), (col * 1.3).round());
-    // Auto resolves from the parent of the first selected layer.
-    let parent_modes = sel.first().and_then(|i| doc.node(*i)).and_then(|n| n.parent).map(|p| doc.modes_for(p)).unwrap_or_default();
+    // Auto resolves as for the first selected layer: from its parent, or an instance's main.
+    let parent_modes = sel.first().map(|i| doc.inherited_modes(*i)).unwrap_or_default();
     let mut group = None;
     for r in &rows {
         let c = r.coll;
@@ -1101,7 +1095,12 @@ fn paints(app: &mut FigApp, ui: &mut Ui, doc: &Document, sel: &[NodeId], fills:
         empty,
     ) {
         if i == 1 {
-            app.run(if fills { "fill.add" } else { "stroke.add" }, json!({"ids": ids}));
+            // The new paint goes on top; open its picker. A mixed selection has no one index to edit.
+            if app.run(if fills { "fill.add" } else { "stroke.add" }, json!({"ids": ids})).is_some()
+                && let Some(l) = &list
+            {
+                app.ui.picker = Some(crate::colorpicker::PickerTarget::Paint { fills, index: l.len(), ids: ids.clone() });
+            }
         } else {
             style_picker::open(app, ui, &ids, slot);
         }
@@ -1881,7 +1880,7 @@ fn effect_settings(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId], i: usize, e: &
             row(ui, 32.0, |ui| {
                 let ed = widgets::number_field(ui, Id::new(("fx_gl", i)), Lead::Text(tr("Light|glass")), Some(g.light_angle.round()), "°", half, 1.0);
                 edit(app, ed, &|v| with(&|gl| gl.light_angle = v.clamp(-180.0, 180.0)));
-                let ed = widgets::number_field(ui, Id::new(("fx_gi", i)), Lead::None, pct(g.light_intensity), "%", half, 1.0);
+                let ed = widgets::number_field(ui, Id::new(("fx_gi", i)), Lead::Text(tr("Intensity")), pct(g.light_intensity), "%", half, 1.0);
                 edit(app, ed, &|v| with(&|gl| gl.light_intensity = unit(v)));
             });
             row(ui, 32.0, |ui| {
@@ -2047,8 +2046,13 @@ fn grid_settings(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId], list: &[LayoutGr
             // 0 is Auto for fixed-size columns (rows); a stretched grid has at least one.
             let count = (!auto_count(g)).then(|| f64::from(g.count.max(1)));
             let key = format!("layoutGrids/{i}/count");
-            let e =
-                crate::variable_ui::number_field_or(app, ui, ids, &key, Id::new(("grid_field", "count", i)), count, col, tr("Auto"), Lead::None, "");
+            let id = Id::new(("grid_field", "count", i));
+            // A stretched grid has at least one band, so 0 (Auto) isn't a count it can take.
+            let e = if g.align == GridAlign::Stretch {
+                crate::variable_ui::number_field_or(app, ui, ids, &key, id, count, col, "", Lead::None, "")
+            } else {
+                crate::variable_ui::number_field_auto(app, ui, ids, &key, id, count, col, Lead::None, "")
+            };
             app.field_run(e, "node.set", |v| {
                 set(&|x| x.count = if x.align == GridAlign::Stretch { v.round().clamp(1.0, 1000.0) } else { v.round().clamp(0.0, 1000.0) } as u32)
             });
@@ -2081,11 +2085,17 @@ fn grid_settings(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId], list: &[LayoutGr
         let span = if cols { tr("Width") } else { tr("Height") };
         match g.align {
             GridAlign::Stretch => {
-                widgets::sublabels(ui, tr("Margin"), Some(tr("Gutter")));
+                widgets::sublabels(ui, span, Some(tr("Margin")));
                 row(ui, 32.0, |ui| {
+                    // The frame, divided by the count: shown as Auto and not editable.
+                    ui.add_enabled_ui(false, |ui| {
+                        let auto = widgets::Empty::Text(tr("Auto"));
+                        widgets::number_field_bindable(ui, Id::new(("grid_field", "size", i)), Lead::Named(span), None, "", col, 1.0, None, auto)
+                    });
                     field(app, ui, "offset", g.offset, &offset);
-                    field(app, ui, "gutter", g.gutter, &gutter);
                 });
+                widgets::sublabels(ui, tr("Gutter"), None);
+                row(ui, 32.0, |ui| field(app, ui, "gutter", g.gutter, &gutter));
             }
             GridAlign::Center => {
                 widgets::sublabels(ui, span, Some(tr("Gutter")));
diff --git a/crates/ui-egui/src/save_as_tests.rs b/crates/ui-egui/src/save_as_tests.rs
new file mode 100644
index 000000000..8817ab1c8
--- /dev/null
+++ b/crates/ui-egui/src/save_as_tests.rs
@@ -0,0 +1,320 @@
+//! Native Save as accepts both file formats; .fig copies preserve native save state.
+
+use std::path::PathBuf;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::{Arc, Mutex};
+
+use figcraft_engine::Session;
+use serde_json::json;
+
+use crate::dialogs::file_saved;
+use crate::{DialogFuture, FigApp, Services};
+
+type Picks = Arc<Mutex<Vec<(String, String, Vec<String>)>>>;
+
+struct Picker {
+    path: Option<PathBuf>,
+    picks: Picks,
+}
+
+impl Services for Picker {
+    fn pick_save(&mut self, title: &str, name: &str, exts: &[&str]) -> DialogFuture {
+        self.picks.lock().unwrap().push((title.into(), name.into(), exts.iter().map(|e| (*e).into()).collect()));
+        Box::pin(std::future::ready(self.path.take()))
+    }
+}
+
+struct Temp(PathBuf);
+
+impl Temp {
+    fn new() -> Self {
+        static NEXT: AtomicU64 = AtomicU64::new(0);
+        let stamp = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos();
+        let path = std::env::temp_dir().join(format!("figcraft-save-as-{}-{stamp}-{}", std::process::id(), NEXT.fetch_add(1, Ordering::Relaxed)));
+        std::fs::create_dir(&path).unwrap();
+        Self(path)
+    }
+
+    fn path(&self, name: &str) -> PathBuf {
+        self.0.join(name)
+    }
+}
+
+impl Drop for Temp {
+    fn drop(&mut self) {
+        if let Ok(files) = std::fs::read_dir(&self.0) {
+            for file in files.flatten() {
+                let _ = std::fs::remove_file(file.path());
+            }
+        }
+        let _ = std::fs::remove_dir(&self.0);
+    }
+}
+
+fn session() -> Session {
+    let mut s = Session::new();
+    s.doc_mut().unwrap().name = "Prototype".into();
+    s.execute("shape.rectangle", &json!({"width": 100, "height": 80})).unwrap();
+    s
+}
+
+fn picker(path: Option<PathBuf>) -> (Picker, Picks) {
+    let picks = Picks::default();
+    (Picker { path, picks: picks.clone() }, picks)
+}
+
+fn app(path: Option<PathBuf>) -> (FigApp, Picks) {
+    let (picker, picks) = picker(path);
+    (FigApp::new(session(), Box::new(picker)), picks)
+}
+
+fn toast(app: &FigApp) -> &str {
+    &app.ui.toast.as_ref().unwrap().0
+}
+
+fn expected_picker() -> Vec<(String, String, Vec<String>)> {
+    vec![("Save as".into(), "Prototype.figcraft".into(), vec!["figcraft".into(), "fig".into()])]
+}
+
+#[test]
+fn save_as_menu_and_first_save_open_the_platform_picker_directly_with_both_extensions() {
+    for action in ["direct", "menu", "first"] {
+        let (mut app, picks) = app(None);
+        let before = app.session.doc().unwrap().clone();
+        match action {
+            "direct" => app.save_as_dialog(),
+            "menu" => crate::menus::invoke(&mut app, "file.saveAs"),
+            "first" => app.save(),
+            _ => panic!("unknown save action {action}"),
+        }
+        app.poll_dialog(&egui::Context::default());
+        assert_eq!(*picks.lock().unwrap(), expected_picker());
+        assert_eq!(app.session.doc().unwrap(), &before);
+        assert!(app.session.ds().unwrap().path.is_none());
+        assert!(app.session.ds().unwrap().is_dirty());
+        assert!(app.ui.toast.is_none());
+    }
+}
+
+#[test]
+fn a_pathless_engine_request_uses_the_same_platform_picker() {
+    let (mut app, picks) = app(None);
+    let before = app.session.doc().unwrap().clone();
+    assert!(app.run("file.saveAs", json!({})).is_none(), "the engine requests the UI and refuses a pathless programmatic save");
+    app.poll_dialog(&egui::Context::default());
+    assert_eq!(*picks.lock().unwrap(), expected_picker());
+    assert_eq!(app.session.doc().unwrap(), &before);
+    assert!(app.session.ds().unwrap().path.is_none());
+    assert!(app.session.ds().unwrap().is_dirty());
+}
+
+#[test]
+fn native_paths_and_an_extensionless_default_save_native_files_and_show_the_written_name() {
+    let temp = Temp::new();
+    for (chosen, written) in [("native", "native.figcraft"), ("saved.figcraft", "saved.figcraft"), ("upper.FIGCRAFT", "upper.FIGCRAFT")] {
+        let (mut app, picks) = app(Some(temp.path(chosen)));
+        app.save_as_dialog();
+        app.poll_dialog(&egui::Context::default());
+        let path = temp.path(written);
+        assert_eq!(*picks.lock().unwrap(), expected_picker());
+        assert!(path.is_file());
+        assert_eq!(app.session.ds().unwrap().path.as_deref(), path.to_str());
+        assert!(!app.session.ds().unwrap().is_dirty());
+        assert_eq!(toast(&app), format!("Saved {written}"));
+        let mut reopened = Session::empty();
+        reopened.execute("file.open", &json!({"path": path})).unwrap();
+        assert_eq!(reopened.doc().unwrap().nodes().count(), app.session.doc().unwrap().nodes().count());
+        assert_eq!(reopened.doc().unwrap().name, "Prototype");
+    }
+}
+
+#[test]
+fn returned_fig_paths_export_real_copies_without_changing_native_save_state() {
+    let temp = Temp::new();
+    for name in ["copy.fig", "upper.FIG"] {
+        let path = temp.path(name);
+        let (mut app, picks) = app(Some(path.clone()));
+        let native = temp.path("working.figcraft").to_string_lossy().into_owned();
+        app.session.ds_mut().unwrap().path = Some(native.clone());
+        let before = app.session.doc().unwrap().clone();
+        app.save_as_dialog();
+        app.poll_dialog(&egui::Context::default());
+        assert_eq!(*picks.lock().unwrap(), expected_picker());
+        assert!(path.is_file());
+        assert_eq!(app.session.doc().unwrap(), &before);
+        assert_eq!(app.session.ds().unwrap().path.as_deref(), Some(native.as_str()));
+        assert!(app.session.ds().unwrap().is_dirty());
+        assert_eq!(toast(&app), format!("Exported {name}"));
+        let mut reopened = Session::empty();
+        reopened.execute("file.open", &json!({"path": path})).unwrap();
+        assert_eq!(reopened.doc().unwrap().nodes().count(), before.nodes().count());
+    }
+}
+
+#[test]
+fn a_fig_copy_reports_actual_engine_warnings_and_keeps_the_original_content() {
+    let temp = Temp::new();
+    let (mut app, _) = app(Some(temp.path("comments.fig")));
+    app.run("comment.add", json!({"x": 10, "y": 20, "text": "Synthetic comment"})).unwrap();
+    let before = app.session.doc().unwrap().clone();
+    app.save_as_dialog();
+    app.poll_dialog(&egui::Context::default());
+    assert!(temp.path("comments.fig").is_file());
+    assert_eq!(toast(&app), "Exported comments.fig; 1 kind of content was left out");
+    assert_eq!(app.session.doc().unwrap(), &before);
+    assert_eq!(app.session.doc().unwrap().comments.len(), 1);
+    assert!(app.session.ds().unwrap().path.is_none());
+    assert!(app.session.ds().unwrap().is_dirty());
+}
+
+#[test]
+fn cancelling_the_platform_dialog_preserves_document_selection_path_and_dirty_state() {
+    let (mut app, picks) = app(None);
+    app.session.ds_mut().unwrap().path = Some("working.figcraft".into());
+    let before = app.session.doc().unwrap().clone();
+    let selection = app.session.ds().unwrap().selection.clone();
+    app.save_as_dialog();
+    app.poll_dialog(&egui::Context::default());
+    assert_eq!(*picks.lock().unwrap(), expected_picker());
+    assert_eq!(app.session.doc().unwrap(), &before);
+    assert_eq!(app.session.ds().unwrap().selection, selection);
+    assert_eq!(app.session.ds().unwrap().path.as_deref(), Some("working.figcraft"));
+    assert!(app.session.ds().unwrap().is_dirty());
+    assert!(app.ui.toast.is_none());
+}
+
+#[test]
+fn unsupported_extensions_are_rejected_without_overwriting_the_chosen_file() {
+    let temp = Temp::new();
+    for name in ["wrong.svg", "wrong.png"] {
+        let path = temp.path(name);
+        std::fs::write(&path, b"existing document").unwrap();
+        let (mut app, _) = app(Some(path.clone()));
+        let before = app.session.doc().unwrap().clone();
+        app.save_as_dialog();
+        app.poll_dialog(&egui::Context::default());
+        assert_eq!(std::fs::read(&path).unwrap(), b"existing document");
+        assert_eq!(app.session.doc().unwrap(), &before);
+        assert!(app.session.ds().unwrap().path.is_none());
+        assert!(app.session.ds().unwrap().is_dirty());
+        assert_eq!(toast(&app), "Use the .figcraft or .fig extension.");
+    }
+}
+
+#[test]
+fn adding_the_default_extension_never_overwrites_another_existing_path_without_confirmation() {
+    let temp = Temp::new();
+    let path = temp.path("existing.figcraft");
+    std::fs::write(&path, b"existing document").unwrap();
+    let (mut app, _) = app(Some(temp.path("existing")));
+    app.save_as_dialog();
+    app.poll_dialog(&egui::Context::default());
+    assert_eq!(std::fs::read(&path).unwrap(), b"existing document");
+    assert!(!temp.path("existing").exists());
+    assert!(app.session.ds().unwrap().path.is_none());
+    assert!(app.session.ds().unwrap().is_dirty());
+    assert_eq!(toast(&app), "A .figcraft file with this name already exists. Choose its full name to confirm replacement.");
+}
+
+#[test]
+fn fig_save_results_report_the_actual_name_and_plural_warning_count_without_marking_native_state_saved() {
+    let (mut app, _) = app(None);
+    let before = app.session.doc().unwrap().clone();
+    app.session.ds_mut().unwrap().path = Some("working.figcraft".into());
+    file_saved(&mut app, &json!({"format": "fig", "path": "written.fig", "warnings": ["synthetic warning", "another synthetic warning"]}));
+    assert_eq!(toast(&app), "Exported written.fig; 2 kinds of content were left out");
+    assert_eq!(app.session.doc().unwrap(), &before);
+    assert_eq!(app.session.ds().unwrap().path.as_deref(), Some("working.figcraft"));
+    assert!(app.session.ds().unwrap().is_dirty());
+}
+
+#[test]
+fn save_with_a_native_path_keeps_using_it_without_a_dialog() {
+    let temp = Temp::new();
+    let (mut app, picks) = app(None);
+    let path = temp.path("working.figcraft");
+    app.run("file.saveAs", json!({"path": path})).unwrap();
+    app.run("shape.rectangle", json!({"width": 10, "height": 20})).unwrap();
+    assert!(app.session.ds().unwrap().is_dirty());
+    app.save();
+    assert!(picks.lock().unwrap().is_empty());
+    assert_eq!(app.session.ds().unwrap().path.as_deref(), path.to_str());
+    assert!(!app.session.ds().unwrap().is_dirty());
+    assert_eq!(toast(&app), "Saved");
+}
+
+#[test]
+fn saving_legacy_fig_paths_keeps_the_success_toast_and_original_source_bytes() {
+    for legacy_name in ["legacy.fig", "legacy.FIG"] {
+        for destination in ["corrected.figcraft", "copy.fig"] {
+            let temp = Temp::new();
+            let target = temp.path(destination);
+            let legacy = temp.path(legacy_name);
+            let (mut app, picks) = app(Some(target.clone()));
+            let original = temp.path("original.figcraft");
+            app.run("file.saveAs", json!({"path": original})).unwrap();
+            std::fs::rename(&original, &legacy).unwrap();
+            let legacy_path = legacy.to_string_lossy().into_owned();
+            app.session.ds_mut().unwrap().path = Some(legacy_path.clone());
+            app.run("shape.rectangle", json!({"width": 10, "height": 20})).unwrap();
+            let before = app.session.doc().unwrap().clone();
+            let legacy_bytes = std::fs::read(&legacy).unwrap();
+            app.save();
+            app.poll_dialog(&egui::Context::default());
+            assert_eq!(*picks.lock().unwrap(), expected_picker());
+            assert_eq!(std::fs::read(&legacy).unwrap(), legacy_bytes);
+            assert!(target.is_file());
+            assert!(app.ui.last_error.is_none());
+            assert_eq!(app.session.doc().unwrap(), &before);
+            if destination == "corrected.figcraft" {
+                assert_eq!(toast(&app), "Saved corrected.figcraft");
+                assert_eq!(app.session.ds().unwrap().path.as_deref(), target.to_str());
+                assert!(!app.session.ds().unwrap().is_dirty());
+            } else {
+                assert_eq!(toast(&app), "Exported copy.fig");
+                assert_eq!(app.session.ds().unwrap().path.as_deref(), Some(legacy_path.as_str()));
+                assert!(app.session.ds().unwrap().is_dirty());
+            }
+        }
+    }
+}
+
+#[test]
+fn failed_writes_surface_the_engine_error_and_keep_the_document_dirty() {
+    let temp = Temp::new();
+    for extension in ["figcraft", "fig"] {
+        let path = temp.path(&format!("missing/copy.{extension}"));
+        let (mut app, _) = app(Some(path.clone()));
+        let before = app.session.doc().unwrap().clone();
+        app.save_as_dialog();
+        app.poll_dialog(&egui::Context::default());
+        assert!(!path.exists());
+        assert_eq!(app.session.doc().unwrap(), &before);
+        assert!(app.session.ds().unwrap().path.is_none());
+        assert!(app.session.ds().unwrap().is_dirty());
+        assert_eq!(app.ui.last_error.as_deref(), Some(toast(&app)));
+        assert!(!toast(&app).starts_with("Saved") && !toast(&app).starts_with("Exported"));
+    }
+}
+
+#[test]
+fn an_empty_destination_is_rejected_without_writing_or_changing_save_state() {
+    let (mut app, _) = app(Some(PathBuf::new()));
+    let before = app.session.doc().unwrap().clone();
+    app.save_as_dialog();
+    app.poll_dialog(&egui::Context::default());
+    assert_eq!(app.session.doc().unwrap(), &before);
+    assert!(app.session.ds().unwrap().path.is_none());
+    assert!(app.session.ds().unwrap().is_dirty());
+    assert_eq!(toast(&app), "Use the .figcraft or .fig extension.");
+}
+
+#[test]
+fn save_as_with_no_document_never_opens_a_dialog() {
+    let (picker, picks) = picker(None);
+    let mut app = FigApp::new(Session::empty(), Box::new(picker));
+    app.save_as_dialog();
+    app.poll_dialog(&egui::Context::default());
+    assert!(picks.lock().unwrap().is_empty());
+    assert!(app.ui.toast.is_none());
+}
diff --git a/crates/ui-egui/src/selection_colors.rs b/crates/ui-egui/src/selection_colors.rs
new file mode 100644
index 000000000..f96fc6092
--- /dev/null
+++ b/crates/ui-egui/src/selection_colors.rs
@@ -0,0 +1,276 @@
+//! Selection colors lives below Effects. A picker edits frozen paint slots, so color groups
+//! merging while scrubbing cannot accidentally recolor other objects.
+
+use std::sync::Arc;
+
+use egui::{Id, Ui};
+use figcraft_color::Color;
+use figcraft_doc::{Document, NodeId, StyleKind};
+use figcraft_engine::selection_colors::{PaintTarget, SelectionColor, collect};
+use serde_json::json;
+
+use crate::a11y::Tip;
+use crate::colorpicker::PickerTarget;
+use crate::i18n::tr;
+use crate::icons::{self, Icon};
+use crate::theme::Tokens;
+use crate::{FigApp, widgets};
+
+#[derive(Clone)]
+struct Cache {
+    document: u64,
+    doc: Arc<Document>,
+    ids: Vec<NodeId>,
+    colors: Arc<Vec<SelectionColor>>,
+}
+
+fn colors(ui: &Ui, document: u64, doc: &Arc<Document>, ids: &[NodeId], interacting: bool) -> Arc<Vec<SelectionColor>> {
+    let key = Id::new("selection_colors_cache");
+    if let Some(cache) = ui.data(|d| d.get_temp::<Cache>(key))
+        && cache.document == document
+        && cache.ids == ids
+        && (interacting || Arc::ptr_eq(&cache.doc, doc))
+    {
+        return cache.colors;
+    }
+    // A drag replaces the document snapshot every frame. Keep its existing rows until the
+    // gesture ends; a cold cache or a changed document/selection waits too. Engine commands
+    // still discover and change the complete selection, independently of this panel cache.
+    if interacting {
+        return Arc::new(Vec::new());
+    }
+    let colors = Arc::new(collect(doc, ids));
+    ui.data_mut(|d| d.insert_temp(key, Cache { document, doc: doc.clone(), ids: ids.to_vec(), colors: colors.clone() }));
+    colors
+}
+
+pub(crate) fn open_picker(app: &mut FigApp, targets: Vec<PaintTarget>) {
+    let Ok(ds) = app.session.ds() else { return };
+    app.ui.picker = Some(PickerTarget::SelectionColor { targets, selection: ds.selection.clone(), document: ds.uid });
+}
+
+pub fn section(app: &mut FigApp, ui: &mut Ui, doc: &Arc<Document>, ids: &[NodeId]) {
+    let Ok(ds) = app.session.ds() else { return };
+    let interacting = ds.interaction.is_some();
+    let colors = colors(ui, ds.uid, doc, ids, interacting);
+    if colors.len() < 2 {
+        return;
+    }
+    let t = Tokens::get(ui.ctx());
+    widgets::section_header(ui, tr("Selection colors"), &[], false);
+    // Bound the panel's height; a document with many distinct colors stays scrollable.
+    ui.add_enabled_ui(!interacting, |ui| {
+        egui::ScrollArea::vertical().id_salt("selection_colors_rows").max_height(240.0).show_rows(ui, 32.0, colors.len(), |ui, range| {
+            for group in &colors[range] {
+                ui.push_id((&group.targets, "selection_color"), |ui| {
+                    crate::right::row(ui, 32.0, |ui| {
+                        let swatch = widgets::swatch(ui, &group.paint, 24.0).tip(tr("Edit colour"));
+                        if swatch.clicked() {
+                            open_picker(app, group.targets.clone());
+                        }
+                        let width = (ui.available_width() - 116.0).max(40.0);
+                        let linked_name = group
+                            .style
+                            .as_ref()
+                            .and_then(|id| doc.style(id).map(|s| s.name.as_str()))
+                            .or_else(|| group.variable.as_ref().and_then(|id| doc.variables.get(id).map(|v| v.name.as_str())));
+                        if let Some(name) = linked_name {
+                            if widgets::dropdown(ui, name, width, None).clicked() {
+                                open_picker(app, group.targets.clone());
+                            }
+                        } else if let Some(color) = group.paint.solid_color() {
+                            if let Some(hex) = widgets::text_field_named(ui, ui.id().with("hex"), &color.to_hex(), width, tr("Color")) {
+                                if let Some(color) = Color::from_hex(&hex) {
+                                    let mut paint = group.paint.clone();
+                                    paint.kind = figcraft_color::PaintKind::Solid { color: color.with_alpha(1.0) };
+                                    if color.a < 1.0 {
+                                        paint.opacity = color.a;
+                                    }
+                                    app.run("selection.setPaint", json!({"targets": group.targets, "paint": paint}));
+                                } else {
+                                    app.toast(tr("Invalid color"));
+                                }
+                            }
+                        } else {
+                            let response = widgets::dropdown(ui, &widgets::paint_name(&group.paint), width, None);
+                            if response.clicked() {
+                                open_picker(app, group.targets.clone());
+                            }
+                        }
+                        let alpha = format!("{}%", figcraft_doc::trim_num(f64::from(group.paint.opacity) * 100.0));
+                        if let Some(value) = widgets::text_field_named(ui, ui.id().with("opacity"), &alpha, 44.0, tr("Opacity"))
+                            && let Ok(value) = value.trim().trim_end_matches('%').parse::<f32>()
+                            && value.is_finite()
+                        {
+                            let mut paint = group.paint.clone();
+                            paint.opacity = (value / 100.0).clamp(0.0, 1.0);
+                            app.run("selection.setPaint", json!({"targets": group.targets, "paint": paint}));
+                        }
+                        let styles = icons::button(ui, Icon::Styles, 24.0, false, tr("Color styles"));
+                        crate::right::menu_popup(&styles).show(|ui| {
+                            let mut any = false;
+                            for style in &doc.styles {
+                                if !matches!(style.kind, StyleKind::Paint { .. }) {
+                                    continue;
+                                }
+                                any = true;
+                                if crate::right::menu_item(ui, &style.name, "") {
+                                    app.run("selection.applyColorStyle", json!({"targets": group.targets, "style": style.id}));
+                                    app.ui.picker = None;
+                                    ui.close();
+                                }
+                            }
+                            if !any {
+                                widgets::label(ui, tr("No color styles"), t.text_secondary);
+                            }
+                        });
+                        if icons::button(ui, Icon::Move, 24.0, false, tr("Select layers with this color")).clicked() {
+                            app.run("selection.selectColor", json!({"targets": group.targets}));
+                        }
+                    });
+                });
+            }
+        });
+    });
+    ui.add_space(8.0);
+    widgets::separator(ui);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::NoServices;
+    use egui::{Event, Pos2, RawInput, Rect, Shape, vec2};
+    use figcraft_engine::Session;
+
+    struct Panel {
+        ctx: egui::Context,
+        app: FigApp,
+        time: f64,
+    }
+
+    impl Panel {
+        fn new() -> (Self, NodeId, NodeId) {
+            let mut s = Session::new();
+            let mut ids = Vec::new();
+            for color in ["#ff0000", "#0000ff"] {
+                let value = s.execute("shape.rectangle", &json!({"width":40,"height":40,"props":{"fill":color}})).unwrap();
+                ids.push(NodeId(value["id"].as_u64().unwrap()));
+            }
+            s.execute("select.set", &json!({"ids":ids})).unwrap();
+            let mut p = Self { ctx: egui::Context::default(), app: FigApp::new(s, Box::new(NoServices)), time: 0.0 };
+            crate::theme::install_fonts(&p.ctx, false, 0);
+            crate::theme::apply(&p.ctx, crate::theme::Tokens::light());
+            for _ in 0..3 {
+                p.frame(vec![]);
+            }
+            (p, ids[0], ids[1])
+        }
+        fn frame(&mut self, events: Vec<Event>) -> Vec<(String, Pos2)> {
+            self.time += 1.0 / 60.0;
+            let input = RawInput {
+                screen_rect: Some(Rect::from_min_size(Pos2::ZERO, vec2(280.0, 600.0))),
+                time: Some(self.time),
+                events,
+                ..Default::default()
+            };
+            let mut output = self.ctx.run_ui(input, |ui| {
+                let ds = self.app.session.ds().unwrap();
+                let doc = ds.doc.clone();
+                let ids = ds.selection.clone();
+                section(&mut self.app, ui, &doc, &ids);
+            });
+            output.textures_delta.clear();
+            fn texts(shape: &Shape, out: &mut Vec<(String, Pos2)>) {
+                match shape {
+                    Shape::Text(t) => out.push((t.galley.text().to_string(), t.pos + t.galley.size() / 2.0)),
+                    Shape::Vec(v) => {
+                        for s in v {
+                            texts(s, out)
+                        }
+                    }
+                    _ => {}
+                }
+            }
+            let mut text = Vec::new();
+            for s in &output.shapes {
+                texts(&s.shape, &mut text);
+            }
+            text
+        }
+        fn click(&mut self, pos: Pos2) {
+            for pressed in [true, false] {
+                self.frame(vec![
+                    Event::PointerMoved(pos),
+                    Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() },
+                ]);
+            }
+        }
+    }
+
+    #[test]
+    fn selection_colors_panel_opens_the_existing_picker_and_hides_for_one_color() {
+        let (mut p, a, b) = Panel::new();
+        let texts = p.frame(vec![]);
+        assert!(texts.iter().any(|(s, _)| s == "Selection colors"));
+        let red = texts.iter().find(|(s, _)| s == "FF0000").unwrap().1;
+        p.click(Pos2::new(28.0, red.y));
+        let Some(PickerTarget::SelectionColor { targets, .. }) = &p.app.ui.picker else { panic!("the swatch must open its picker") };
+        assert_eq!(targets.iter().map(|t| t.id).collect::<Vec<_>>(), [a]);
+        p.app.run("fill.set", json!({"id":b,"color":"#ff0000"}));
+        assert!(!p.frame(vec![]).iter().any(|(s, _)| s == "Selection colors"));
+    }
+
+    #[test]
+    fn panel_keeps_cached_colors_during_interaction_and_refreshes_after_commit() {
+        let (mut p, a, _) = Panel::new();
+        let key = Id::new("selection_colors_cache");
+        let before = p.ctx.data(|d| d.get_temp::<Cache>(key)).unwrap();
+        p.app.session.begin_interaction("Color").unwrap();
+        for hex in ["#00ff00", "#ffff00", "#00ffff"] {
+            p.app.run("fill.set", json!({"id":a,"color":hex}));
+            p.frame(vec![]);
+            let during = p.ctx.data(|d| d.get_temp::<Cache>(key)).unwrap();
+            assert!(Arc::ptr_eq(&before.colors, &during.colors), "a live edit must not rediscover paints");
+        }
+        p.app.session.commit_interaction().unwrap();
+        let texts = p.frame(vec![]);
+        assert!(texts.iter().any(|(s, _)| s == "00FFFF"));
+        let after = p.ctx.data(|d| d.get_temp::<Cache>(key)).unwrap();
+        assert!(!Arc::ptr_eq(&before.colors, &after.colors));
+    }
+
+    #[test]
+    fn panel_defers_discovery_without_a_matching_cache_during_interaction() {
+        let (mut p, a, _) = Panel::new();
+        let key = Id::new("selection_colors_cache");
+        p.ctx.data_mut(|d| d.remove::<Cache>(key));
+        p.app.session.begin_interaction("Color").unwrap();
+        p.app.run("fill.set", json!({"id":a,"color":"#00ff00"}));
+        assert!(!p.frame(vec![]).iter().any(|(s, _)| s == "Selection colors"));
+        assert!(p.ctx.data(|d| d.get_temp::<Cache>(key)).is_none());
+        p.app.session.cancel_interaction().unwrap();
+        assert!(p.frame(vec![]).iter().any(|(s, _)| s == "FF0000"));
+    }
+
+    #[test]
+    fn select_color_button_selects_only_the_matching_layers() {
+        let (mut p, a, _) = Panel::new();
+        let red = p.frame(vec![]).into_iter().find(|(s, _)| s == "FF0000").unwrap().1;
+        p.click(Pos2::new(252.0, red.y));
+        assert_eq!(p.app.session.selection(), [a]);
+        assert!(p.app.ui.last_error.is_none());
+    }
+
+    #[test]
+    fn panel_displays_the_linked_style_name_and_the_other_color() {
+        let (mut p, a, b) = Panel::new();
+        p.app.run("style.create", json!({"type":"paint","name":"Brand","value":"#ff0000"}));
+        p.app.run("style.apply", json!({"id":a,"style":"Brand","target":"fill"}));
+        let texts = p.frame(vec![]);
+        assert!(texts.iter().any(|(s, _)| s == "Brand"));
+        assert!(texts.iter().any(|(s, _)| s == "0000FF"));
+        let colors = collect(p.app.session.doc().unwrap(), &[a, b]);
+        assert_eq!(colors.len(), 2);
+    }
+}
diff --git a/crates/ui-egui/src/selection_spacing.rs b/crates/ui-egui/src/selection_spacing.rs
new file mode 100644
index 000000000..3a39955ac
--- /dev/null
+++ b/crates/ui-egui/src/selection_spacing.rs
@@ -0,0 +1,434 @@
+//! Smart-selection fields and handles. Geometry and document edits belong to the engine.
+use std::sync::Arc;
+
+use egui::{CursorIcon, Id, Pos2, Rect, Stroke, Ui, vec2};
+use figcraft_doc::{Document, NodeId};
+use figcraft_engine::selection_reorder::ReorderLayout;
+use figcraft_engine::selection_spacing::{Axis, SelectionSpacing, selection_spacing};
+use serde_json::json;
+
+use crate::FigApp;
+use crate::handles::{PINK, pink_label};
+use crate::i18n::tr;
+use crate::icons::Icon;
+use crate::widgets::{self, Lead};
+
+#[derive(Clone)]
+struct LayoutCache {
+    document: u64,
+    page: NodeId,
+    doc: Arc<Document>,
+    ids: Vec<NodeId>,
+    frame: u64,
+    layout: Arc<SelectionSpacing>,
+    reorder: Option<Arc<ReorderLayout>>,
+}
+
+fn layout(app: &FigApp, ctx: &egui::Context, ids: &[NodeId]) -> Arc<SelectionSpacing> {
+    let Ok(ds) = app.session.ds() else { return Arc::new(SelectionSpacing::default()) };
+    let key = Id::new("selection_spacing_layout");
+    let frame = ctx.cumulative_frame_nr();
+    if let Some(mut cache) = ctx.data(|d| d.get_temp::<LayoutCache>(key))
+        && cache.document == ds.uid
+        && cache.page == ds.page
+        && cache.ids == ids
+        && (cache.frame == frame || Arc::ptr_eq(&cache.doc, &ds.doc))
+    {
+        if cache.frame != frame {
+            cache.frame = frame;
+            ctx.data_mut(|d| d.insert_temp(key, cache.clone()));
+        }
+        return cache.layout;
+    }
+    // Panel, input and drawing share one calculation per frame. If a command changes the
+    // document during this frame, refresh next frame; unchanged snapshots also reuse it then.
+    let layout = Arc::new(selection_spacing(&ds.doc, ids));
+    let reorder = ReorderLayout::new(&ds.doc, ids).map(Arc::new);
+    ctx.data_mut(|d| {
+        d.insert_temp(
+            key,
+            LayoutCache { document: ds.uid, page: ds.page, doc: ds.doc.clone(), ids: ids.to_vec(), frame, layout: layout.clone(), reorder },
+        );
+    });
+    layout
+}
+fn reorder_layout(app: &FigApp, ctx: &egui::Context, ids: &[NodeId]) -> Option<Arc<ReorderLayout>> {
+    layout(app, ctx, ids);
+    ctx.data(|d| d.get_temp::<LayoutCache>(Id::new("selection_spacing_layout"))).and_then(|c| c.reorder)
+}
+
+fn drag_id() -> Id {
+    Id::new("selection_spacing_drag")
+}
+
+/// The reorder ring of a layer with world bounds `b`: its centre on screen and hit radius. The
+/// radius is 8 px, at most a quarter of the layer's smaller side on screen, so most of a small
+/// layer still drags the selection; a layer under 16 px on screen has no ring.
+fn ring(app: &FigApp, b: figcraft_geom::Rect) -> Option<(Pos2, f32)> {
+    let zoom = app.session.ds().map_or(1.0, |d| d.view.zoom);
+    let side = ((b.x1 - b.x0).min(b.y1 - b.y0) * zoom) as f32;
+    (side >= 16.0).then(|| (app.to_screen((b.x0 + b.x1) * 0.5, (b.y0 + b.y1) * 0.5), (side / 4.0).min(8.0)))
+}
+
+#[derive(Clone)]
+enum Action {
+    Spacing { axis: Axis, value: f64, last_value: Option<f64> },
+    Reorder { layout: Arc<ReorderLayout>, source: NodeId, target: NodeId, swap: bool },
+}
+
+#[derive(Clone)]
+struct Drag {
+    ids: Vec<NodeId>,
+    action: Action,
+    start: Pos2,
+    uid: u64,
+    page: NodeId,
+    moved: bool,
+}
+
+fn start_drag(app: &mut FigApp, ctx: &egui::Context, ids: Vec<NodeId>, p: Pos2, action: Action) {
+    let label = match action {
+        Action::Spacing { .. } => tr("Spacing"),
+        Action::Reorder { .. } => tr("Reorder selection"),
+    };
+    if app.session.begin_interaction(label).is_ok()
+        && let Ok(ds) = app.session.ds()
+    {
+        let drag = Drag { ids, action, start: p, uid: ds.uid, page: ds.page, moved: false };
+        app.ui.layers_focus = false;
+        app.ui.pages_focus = None;
+        app.ui.key_box = None;
+        ctx.memory_mut(|m| {
+            if let Some(f) = m.focused() {
+                m.surrender_focus(f);
+            }
+        });
+        ctx.data_mut(|d| d.insert_temp(drag_id(), drag));
+    }
+}
+
+pub fn panel(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId]) {
+    let layout = layout(app, ui.ctx(), ids);
+    if layout.horizontal.is_none() && layout.vertical.is_none() {
+        return;
+    }
+    widgets::sublabels(ui, tr("Spacing"), None);
+    let col = widgets::col_width(ui.available_width());
+    crate::right::row(ui, 32.0, |ui| {
+        for (axis, key, icon, tip) in [
+            (&layout.horizontal, "horizontal", Icon::DistributeH, tr("Horizontal spacing")),
+            (&layout.vertical, "vertical", Icon::DistributeV, tr("Vertical spacing")),
+        ] {
+            let Some(axis) = axis else { continue };
+            let edit = widgets::number_field(ui, Id::new(("selection_spacing", key)), Lead::Icon(icon, tip), axis.value, "", col, 1.0);
+            app.field_run(edit, "arrange.spacing", |v| json!({"ids":ids,key:v.clamp(-1e6,1e6),"fromGesture":true}));
+        }
+    });
+}
+
+#[derive(Clone)]
+struct Handle {
+    value: f64,
+    center: Pos2,
+    hit: Rect,
+}
+
+fn bounds(doc: &Document, ids: &[NodeId]) -> Option<figcraft_geom::Rect> {
+    ids.iter().filter_map(|id| doc.world_bounds(*id)).reduce(|a, b| a.union(b))
+}
+
+fn handles(app: &FigApp, axis: &Axis) -> Vec<Handle> {
+    let Ok(doc) = app.session.doc() else { return vec![] };
+    let cross = |b: figcraft_geom::Rect| if axis.vertical { (b.x0, b.x1) } else { (b.y0, b.y1) };
+    let mut out = Vec::new();
+    for pair in axis.tracks.windows(2) {
+        let Some((a, b)) = pair.first().zip(pair.get(1)) else { continue };
+        let (Some(ab), Some(bb)) = (bounds(doc, &a.ids), bounds(doc, &b.ids)) else { continue };
+        let gap = axis.start(bb) - axis.end(ab);
+        let middle = (axis.start(bb) + axis.end(ab)) * 0.5;
+        // Intersect neighbouring tracks' cross-axis spans in a sweep: one handle per row/cell,
+        // without comparing every object in a large column to every object in the next one.
+        let mut aa: Vec<_> = a.ids.iter().filter_map(|id| doc.world_bounds(*id)).map(cross).collect();
+        let mut bs: Vec<_> = b.ids.iter().filter_map(|id| doc.world_bounds(*id)).map(cross).collect();
+        aa.sort_by(|a, b| a.0.total_cmp(&b.0));
+        bs.sort_by(|a, b| a.0.total_cmp(&b.0));
+        let (mut i, mut j) = (0, 0);
+        while let (Some(a), Some(b)) = (aa.get(i), bs.get(j)) {
+            let (lo, hi) = (a.0.max(b.0), a.1.min(b.1));
+            if hi > lo {
+                let c = (lo + hi) * 0.5;
+                let center = if axis.vertical { app.to_screen(c, middle) } else { app.to_screen(middle, c) };
+                let size = if axis.vertical { vec2(24.0, 10.0) } else { vec2(10.0, 24.0) };
+                out.push(Handle { value: gap, center, hit: Rect::from_center_size(center, size) });
+            }
+            if a.1 <= b.1 {
+                i += 1;
+            } else {
+                j += 1;
+            }
+        }
+    }
+    out
+}
+
+fn available(app: &FigApp) -> bool {
+    app.ui.right_tab == crate::RightTab::Design
+        && app.ui.picker.is_none()
+        && app.session.tool.tool == figcraft_engine::ToolId::Move
+        && !app.session.tool.busy()
+        && app.session.ds().is_ok_and(|d| d.text_edit.is_none() && d.vector_edit.is_none())
+}
+
+pub fn cancel(app: &mut FigApp, ctx: &egui::Context) -> bool {
+    let drag = ctx.data(|d| d.get_temp::<Drag>(drag_id()));
+    if let Some(drag) = &drag {
+        figcraft_engine::selection_spacing::cancel_gesture(&mut app.session, drag.uid);
+        ctx.data_mut(|d| d.remove::<Drag>(drag_id()));
+    }
+    drag.is_some()
+}
+
+/// Retire handles when another document, page, tool or editing context takes over.
+pub fn sync(app: &mut FigApp, ctx: &egui::Context) {
+    if let Some(drag) = ctx.data(|d| d.get_temp::<Drag>(drag_id())) {
+        let same = app.session.ds().is_ok_and(|d| d.uid == drag.uid && d.page == drag.page && d.selection == drag.ids && d.interaction.is_some());
+        if !same || !available(app) {
+            cancel(app, ctx);
+        }
+    }
+}
+
+/// Called before canvas pointer dispatch, also when the pointer leaves the canvas/window.
+pub fn input(app: &mut FigApp, ctx: &egui::Context, pos: Option<Pos2>, hovered: bool, space: bool) -> bool {
+    let dragging = ctx.data(|d| d.get_temp::<Drag>(drag_id()));
+    if let Some(mut drag) = dragging {
+        let same = app.session.ds().is_ok_and(|d| d.uid == drag.uid && d.page == drag.page && d.selection == drag.ids && d.interaction.is_some());
+        if !same {
+            cancel(app, ctx);
+            return true;
+        }
+        let down = ctx.input(|i| i.pointer.primary_down());
+        if let Some(p) = pos {
+            match &mut drag.action {
+                Action::Spacing { axis, value: original, last_value } => {
+                    let zoom = app.session.ds().map_or(1.0, |d| d.view.zoom).max(1e-6);
+                    let distance = if axis.vertical { p.y - drag.start.y } else { p.x - drag.start.x };
+                    drag.moved |= distance.abs() >= 3.0;
+                    if drag.moved {
+                        let value = ctx
+                            .input(|i| {
+                                let quantum = if i.modifiers.alt {
+                                    0.1
+                                } else if i.modifiers.shift {
+                                    10.0
+                                } else {
+                                    1.0
+                                };
+                                ((*original + f64::from(distance) / zoom) / quantum).round() * quantum
+                            })
+                            .clamp(-1e6, 1e6);
+                        let key = if axis.vertical { "vertical" } else { "horizontal" };
+                        if *last_value != Some(value) {
+                            match app.session.execute("arrange.spacing", &json!({"ids":drag.ids,key:value,"fromGesture":true})) {
+                                Ok(_) => *last_value = Some(value),
+                                Err(e) => app.toast(e.to_string()),
+                            }
+                        }
+                    }
+                }
+                Action::Reorder { layout, source, target, swap } if app.canvas.rect.contains(p) => {
+                    drag.moved |= p.distance(drag.start) >= 3.0;
+                    // Hit original slots, never the moving preview: otherwise a stationary
+                    // pointer could alternate between two permutations on successive frames.
+                    let nearest = layout
+                        .slots
+                        .iter()
+                        .min_by(|a, b| {
+                            let center = |b: figcraft_geom::Rect| app.to_screen((b.x0 + b.x1) * 0.5, (b.y0 + b.y1) * 0.5);
+                            center(a.1).distance_sq(p).total_cmp(&center(b.1).distance_sq(p))
+                        })
+                        .map(|(id, _)| *id)
+                        .unwrap_or(*source);
+                    let swapping = ctx.input(|i| i.modifiers.command);
+                    if drag.moved && (nearest != *target || swapping != *swap) {
+                        match app
+                            .session
+                            .execute("arrange.reorder", &json!({"ids":drag.ids,"source":source,"target":nearest,"swap":swapping,"fromGesture":true}))
+                        {
+                            Ok(_) => {
+                                *target = nearest;
+                                *swap = swapping;
+                            }
+                            Err(e) => app.toast(e.to_string()),
+                        }
+                    }
+                }
+                // A release over a panel or outside the window commits the last canvas
+                // preview; the release's sentinel coordinates must not select a new slot.
+                Action::Reorder { .. } => {}
+            }
+        }
+        ctx.set_cursor_icon(match &drag.action {
+            Action::Spacing { axis, .. } if axis.vertical => CursorIcon::ResizeVertical,
+            Action::Spacing { .. } => CursorIcon::ResizeHorizontal,
+            Action::Reorder { .. } => CursorIcon::Grabbing,
+        });
+        if !down {
+            let _ = app.session.commit_interaction();
+            ctx.data_mut(|d| d.remove::<Drag>(drag_id()));
+        } else {
+            ctx.data_mut(|d| d.insert_temp(drag_id(), drag));
+        }
+        return true;
+    }
+    if !hovered || space || !available(app) {
+        return false;
+    }
+    let Some(p) = pos else { return false };
+    let ids = app.session.selection();
+    if let Some(reorder) = reorder_layout(app, ctx, &ids) {
+        for (id, b) in &reorder.slots {
+            if ring(app, *b).is_some_and(|(center, r)| center.distance(p) <= r) {
+                ctx.set_cursor_icon(CursorIcon::Grab);
+                if ctx.input(|i| i.pointer.primary_pressed()) {
+                    let source = *id;
+                    start_drag(app, ctx, ids, p, Action::Reorder { layout: reorder, source, target: source, swap: false });
+                }
+                return true;
+            }
+        }
+    }
+    if ctx.input(|i| i.modifiers.command) {
+        return false;
+    }
+    let layout = layout(app, ctx, &ids);
+    for axis in [layout.horizontal.as_ref(), layout.vertical.as_ref()].into_iter().flatten() {
+        for h in handles(app, axis) {
+            if !h.hit.contains(p) {
+                continue;
+            }
+            ctx.set_cursor_icon(if axis.vertical { CursorIcon::ResizeVertical } else { CursorIcon::ResizeHorizontal });
+            if ctx.input(|i| i.pointer.primary_pressed()) {
+                start_drag(app, ctx, ids, p, Action::Spacing { axis: axis.clone(), value: h.value, last_value: axis.value });
+            }
+            return true;
+        }
+    }
+    false
+}
+
+pub fn draw(app: &FigApp, painter: &egui::Painter) {
+    let ctx = painter.ctx();
+    let drag = ctx.data(|d| d.get_temp::<Drag>(drag_id()));
+    if !available(app) && drag.is_none() {
+        return;
+    }
+    let Ok(ds) = app.session.ds() else { return };
+    let hover = ctx.input(|i| i.pointer.hover_pos());
+    let Some(b) = bounds(&ds.doc, &ds.selection) else { return };
+    let rect = Rect::from_two_pos(app.to_screen(b.x0, b.y0), app.to_screen(b.x1, b.y1)).expand(12.0);
+    if drag.is_none() && !hover.is_some_and(|p| rect.contains(p)) {
+        return;
+    }
+    let reorder = match drag.as_ref().map(|d| &d.action) {
+        Some(Action::Reorder { layout, .. }) => Some(layout.clone()),
+        Some(Action::Spacing { .. }) => None,
+        None => reorder_layout(app, ctx, &ds.selection),
+    };
+    if let Some(layout) = reorder {
+        for (id, _) in &layout.slots {
+            let Some((center, r)) = ds.doc.world_bounds(*id).and_then(|b| ring(app, b)) else { continue };
+            let hot = hover.is_some_and(|p| center.distance(p) <= r);
+            let active = matches!(drag.as_ref().map(|d| &d.action), Some(Action::Reorder { source, .. }) if source == id);
+            if active {
+                painter.circle_filled(center, 4.5, PINK);
+            } else {
+                painter.circle_stroke(center, 4.5, Stroke::new(if hot { 2.5 } else { 1.5 }, PINK));
+            }
+        }
+    }
+    if let Some(Drag { action: Action::Reorder { layout, target, .. }, moved: true, .. }) = &drag {
+        if let Some((_, b)) = layout.slots.iter().find(|(id, _)| id == target) {
+            let rect = Rect::from_two_pos(app.to_screen(b.x0, b.y0), app.to_screen(b.x1, b.y1)).expand(3.0);
+            painter.rect_stroke(rect, 0, Stroke::new(2.0, crate::theme::ACCENT), egui::StrokeKind::Outside);
+        }
+        return;
+    }
+    let axes = if let Some(Drag { action: Action::Spacing { axis, .. }, .. }) = &drag {
+        vec![axis.clone()]
+    } else {
+        let layout = layout(app, ctx, &ds.selection);
+        [layout.horizontal.clone(), layout.vertical.clone()].into_iter().flatten().collect()
+    };
+    for axis in axes {
+        for h in handles(app, &axis) {
+            let hot = hover.is_some_and(|p| h.hit.contains(p)) || drag.is_some();
+            let by = if axis.vertical { vec2(10.0, 0.0) } else { vec2(0.0, 10.0) };
+            painter.line_segment([h.center - by, h.center + by], Stroke::new(if hot { 3.0 } else { 2.0 }, PINK));
+            if hot {
+                let at = h.center + if axis.vertical { vec2(18.0, 0.0) } else { vec2(0.0, -22.0) };
+                pink_label(painter, widgets::fmt_num(h.value), at);
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod cache_tests {
+    use super::*;
+    use crate::NoServices;
+    use figcraft_engine::Session;
+
+    fn setup() -> (FigApp, egui::Context, Vec<NodeId>) {
+        let mut session = Session::new();
+        let mut ids = Vec::new();
+        for x in [0, 80, 160] {
+            ids.push(NodeId(session.execute("shape.rectangle", &json!({"x":x,"width":50,"height":50})).unwrap()["id"].as_u64().unwrap()));
+        }
+        session.execute("select.set", &json!({"ids":ids})).unwrap();
+        (FigApp::new(session, Box::new(NoServices)), egui::Context::default(), ids)
+    }
+
+    #[test]
+    fn layout_is_shared_within_a_frame_and_refreshed_after_a_document_edit() {
+        let (mut app, ctx, ids) = setup();
+        let mut cached = None;
+        let mut output = ctx.run_ui(Default::default(), |_| {
+            let first = layout(&app, &ctx, &ids);
+            assert_eq!(first.horizontal.as_ref().unwrap().value, Some(30.0));
+            assert!(Arc::ptr_eq(&first, &layout(&app, &ctx, &ids)));
+            cached = Some(first);
+        });
+        output.textures_delta.clear();
+        let mut output = ctx.run_ui(Default::default(), |_| {
+            let first = layout(&app, &ctx, &ids);
+            assert!(Arc::ptr_eq(cached.as_ref().unwrap(), &first), "unchanged frames reuse the calculation");
+            app.set_props(&[ids[1]], json!({"x":90}));
+            assert!(Arc::ptr_eq(&first, &layout(&app, &ctx, &ids)), "a mid-frame edit waits until the next frame");
+        });
+        output.textures_delta.clear();
+        let mut output = ctx.run_ui(Default::default(), |_| {
+            let next = layout(&app, &ctx, &ids);
+            assert!(!Arc::ptr_eq(cached.as_ref().unwrap(), &next));
+            assert_eq!(next.horizontal.as_ref().unwrap().value, None);
+            assert!(Arc::ptr_eq(&next, &layout(&app, &ctx, &ids)));
+        });
+        output.textures_delta.clear();
+    }
+
+    #[test]
+    fn a_selection_or_document_switch_invalidates_the_layout() {
+        let (mut app, ctx, ids) = setup();
+        let mut output = ctx.run_ui(Default::default(), |_| {
+            let all = layout(&app, &ctx, &ids);
+            let subset = layout(&app, &ctx, &ids[..2]);
+            assert!(!Arc::ptr_eq(&all, &subset));
+            assert_eq!(subset.horizontal.as_ref().unwrap().tracks.len(), 2);
+            app.session.execute("file.new", &json!({})).unwrap();
+            let other = layout(&app, &ctx, &ids[..2]);
+            assert!(!Arc::ptr_eq(&subset, &other));
+            assert!(other.horizontal.is_none() && other.vertical.is_none());
+        });
+        output.textures_delta.clear();
+    }
+}
diff --git a/crates/ui-egui/src/selection_spacing_tests.rs b/crates/ui-egui/src/selection_spacing_tests.rs
new file mode 100644
index 000000000..2ee44742f
--- /dev/null
+++ b/crates/ui-egui/src/selection_spacing_tests.rs
@@ -0,0 +1,361 @@
+//! Real field and canvas gestures for #402; distances are checked in the engine document.
+use crate::layers_drag_tests::Ui;
+use egui::{Event, Id, Key, Modifiers, Pos2, vec2};
+use figcraft_doc::NodeId;
+use figcraft_engine::Session;
+use serde_json::json;
+
+fn scene(grid: bool) -> (Ui, Vec<NodeId>) {
+    let mut s = Session::new();
+    let mut ids = vec![];
+    for row in 0..if grid { 2 } else { 1 } {
+        for col in 0..3 {
+            let id = NodeId(
+                s.execute("shape.rectangle", &json!({"x":100+col*80,"y":100+row*100,"width":50,"height":60})).unwrap()["id"].as_u64().unwrap(),
+            );
+            ids.push(id);
+        }
+    }
+    s.execute("select.set", &json!({"ids":ids})).unwrap();
+    let u = Ui::new(s);
+    (u, ids)
+}
+fn xy(u: &Ui, id: NodeId) -> (f64, f64) {
+    let b = u.app.session.doc().unwrap().world_bounds(id).unwrap();
+    (b.x0, b.y0)
+}
+fn key(u: &mut Ui, k: Key) {
+    u.frame(vec![
+        Event::Key { key: k, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE },
+        Event::Key { key: k, physical_key: None, pressed: false, repeat: false, modifiers: Modifiers::NONE },
+    ]);
+    u.frame(vec![]);
+}
+fn drag(u: &mut Ui, p: Pos2, by: egui::Vec2, release: bool) {
+    u.frame(vec![Event::PointerMoved(p)]);
+    u.button(p, true);
+    for i in 1..=4 {
+        u.frame(vec![Event::PointerMoved(p + by * i as f32 / 4.)]);
+    }
+    if release {
+        u.button(p + by, false);
+        u.frame(vec![]);
+    }
+}
+
+#[test]
+fn spacing_fields_type_scrub_and_keep_one_undo_step() {
+    let (mut u, ids) = scene(true);
+    let field = Id::new(("selection_spacing", "horizontal"));
+    let p = u.ctx.read_response(field.with("field")).unwrap().rect.center();
+    let history = u.app.session.undo_depth().0;
+    u.button(p, true);
+    u.button(p, false);
+    u.frame(vec![]);
+    u.frame(vec![Event::Text("45.5".into())]);
+    key(&mut u, Key::Enter);
+    assert_eq!(xy(&u, ids[1]), (195.5, 100.));
+    assert_eq!(xy(&u, ids[4]), (195.5, 200.));
+    assert_eq!(u.app.session.undo_depth().0, history + 1);
+    u.app.run("edit.undo", json!({}));
+    u.frame(vec![]);
+    let lead = u.ctx.read_response(field.with("lead")).unwrap().rect.center();
+    drag(&mut u, lead, vec2(16., 0.), true);
+    assert_eq!(xy(&u, ids[1]), (196., 100.));
+    assert_eq!(u.app.session.undo_depth().0, history + 1);
+    u.app.run("edit.undo", json!({}));
+    assert_eq!(xy(&u, ids[1]), (180., 100.));
+}
+
+#[test]
+fn canvas_gap_drag_keeps_selection_and_undo_redo_for_both_grid_axes() {
+    for (vertical, point) in [(false, (165., 130.)), (true, (125., 180.))] {
+        let (mut u, ids) = scene(true);
+        let before = u.app.session.undo_depth().0;
+        let p = u.app.to_screen(point.0, point.1);
+        let output = u.frame_output(vec![Event::PointerMoved(p)]);
+        assert_eq!(output.platform_output.cursor_icon, if vertical { egui::CursorIcon::ResizeVertical } else { egui::CursorIcon::ResizeHorizontal });
+        let z = u.app.session.ds().unwrap().view.zoom as f32;
+        drag(&mut u, p, if vertical { vec2(0., 20. * z) } else { vec2(20. * z, 0.) }, true);
+        assert_eq!(u.app.session.selection(), ids);
+        assert_eq!(xy(&u, ids[1]), if vertical { (180., 100.) } else { (200., 100.) });
+        assert_eq!(xy(&u, ids[3]), if vertical { (100., 220.) } else { (100., 200.) });
+        assert_eq!(u.app.session.undo_depth().0, before + 1);
+        u.app.run("edit.undo", json!({}));
+        assert_eq!(xy(&u, ids[4]), (180., 200.));
+        u.app.run("edit.redo", json!({}));
+        assert_eq!(xy(&u, ids[4]), if vertical { (180., 220.) } else { (200., 200.) });
+    }
+}
+
+#[test]
+fn escape_rolls_back_and_an_outside_release_finishes_the_gesture() {
+    let (mut u, ids) = scene(false);
+    let before = u.app.session.undo_depth().0;
+    // A canvas handle takes the keyboard from a previously focused panel field.
+    let field = u.ctx.read_response(Id::new(("selection_spacing", "horizontal")).with("field")).unwrap().rect.center();
+    u.button(field, true);
+    u.button(field, false);
+    u.frame(vec![]);
+    let p = u.app.to_screen(165., 130.);
+    let z = u.app.session.ds().unwrap().view.zoom as f32;
+    drag(&mut u, p, vec2(20. * z, 0.), false);
+    assert_eq!(xy(&u, ids[1]), (200., 100.));
+    key(&mut u, Key::Escape);
+    u.button(p + vec2(20. * z, 0.), false);
+    u.frame(vec![]);
+    assert_eq!(xy(&u, ids[1]), (180., 100.));
+    assert_eq!(u.app.session.undo_depth().0, before);
+    assert_eq!(u.app.session.selection(), ids);
+    drag(&mut u, p, vec2(20. * z, 0.), false);
+    // Leave the window while held; releasing with no pointer position still commits once.
+    u.frame(vec![Event::PointerGone]);
+    u.frame(vec![Event::PointerButton {
+        pos: Pos2::new(-1., -1.),
+        button: egui::PointerButton::Primary,
+        pressed: false,
+        modifiers: Modifiers::NONE,
+    }]);
+    u.frame(vec![]);
+    assert_eq!(u.app.session.undo_depth().0, before + 1);
+    assert!(u.app.session.ds().unwrap().interaction.is_none());
+}
+
+#[test]
+fn switching_documents_cancels_only_the_spacing_documents_gesture() {
+    let (mut u, ids) = scene(false);
+    let p = u.app.to_screen(165., 130.);
+    let z = u.app.session.ds().unwrap().view.zoom as f32;
+    drag(&mut u, p, vec2(20. * z, 0.), false);
+    u.app.run("file.new", json!({}));
+    u.app.session.begin_interaction("Unrelated").unwrap();
+    u.frame(vec![]);
+    assert!(u.app.session.ds().unwrap().interaction.is_some());
+    u.app.session.active = 0;
+    assert_eq!(xy(&u, ids[1]), (180., 100.));
+    assert!(u.app.session.ds().unwrap().interaction.is_none());
+}
+
+#[test]
+fn handle_click_is_a_noop_and_modifiers_can_be_held_before_pressing() {
+    let (mut u, ids) = scene(false);
+    let p = u.app.to_screen(165., 130.);
+    let before = u.app.session.undo_depth().0;
+    u.frame(vec![Event::PointerMoved(p)]);
+    u.button(p, true);
+    u.button(p, false);
+    u.frame(vec![]);
+    assert_eq!(u.app.session.undo_depth().0, before);
+    for (modifiers, delta, gap) in [(Modifiers::SHIFT, 17., 50.), (Modifiers::ALT, 17.25, 47.3)] {
+        let (mut u, ids) = scene(false);
+        let p = u.app.to_screen(165., 130.);
+        let z = u.app.session.ds().unwrap().view.zoom as f32;
+        u.frame_with(vec![Event::PointerMoved(p)], modifiers);
+        u.frame_with(vec![Event::PointerButton { pos: p, button: egui::PointerButton::Primary, pressed: true, modifiers }], modifiers);
+        for k in 1..=4 {
+            u.frame_with(vec![Event::PointerMoved(p + vec2(delta * z * k as f32 / 4., 0.))], modifiers);
+        }
+        u.frame_with(
+            vec![Event::PointerButton { pos: p + vec2(delta * z, 0.), button: egui::PointerButton::Primary, pressed: false, modifiers }],
+            modifiers,
+        );
+        u.frame(vec![]);
+        assert!((xy(&u, ids[1]).0 - 150. - gap).abs() < 1e-6);
+    }
+    assert_eq!(xy(&u, ids[1]), (180., 100.));
+}
+
+#[test]
+fn undo_while_dragging_cancels_the_gesture_without_undoing_an_earlier_edit() {
+    let (mut u, ids) = scene(false);
+    let before = u.app.session.undo_depth().0;
+    let p = u.app.to_screen(165., 130.);
+    let z = u.app.session.ds().unwrap().view.zoom as f32;
+    drag(&mut u, p, vec2(20. * z, 0.), false);
+    let m = Modifiers::COMMAND;
+    u.frame_with(
+        vec![
+            Event::Key { key: Key::Z, physical_key: None, pressed: true, repeat: false, modifiers: m },
+            Event::Key { key: Key::Z, physical_key: None, pressed: false, repeat: false, modifiers: m },
+        ],
+        m,
+    );
+    u.button(p + vec2(20. * z, 0.), false);
+    u.frame(vec![]);
+    assert_eq!(u.app.session.undo_depth().0, before);
+    assert_eq!(xy(&u, ids[1]), (180., 100.));
+    assert_eq!(u.app.session.selection(), ids);
+}
+
+#[test]
+fn stationary_gap_drag_does_not_change_the_document_again() {
+    let (mut u, ids) = scene(false);
+    let p = u.app.to_screen(165., 130.);
+    let z = u.app.session.ds().unwrap().view.zoom as f32;
+    drag(&mut u, p, vec2(20. * z, 0.), false);
+    assert_eq!(xy(&u, ids[1]), (200., 100.));
+    let revision = u.app.session.ds().unwrap().revision;
+    let doc = u.app.session.ds().unwrap().doc.clone();
+    for _ in 0..5 {
+        u.frame(vec![]);
+        u.frame(vec![Event::PointerMoved(p + vec2(20.2 * z, 0.))]);
+    }
+    assert_eq!(u.app.session.ds().unwrap().revision, revision);
+    assert!(std::sync::Arc::ptr_eq(&doc, &u.app.session.ds().unwrap().doc));
+    u.button(p + vec2(20.2 * z, 0.), false);
+    assert_eq!(xy(&u, ids[1]), (200., 100.));
+}
+
+#[test]
+fn reorder_ring_drag_inserts_across_grid_rows_as_one_undo_step() {
+    let (mut u, ids) = scene(true);
+    let before = u.app.session.undo_depth().0;
+    let p = u.app.to_screen(125., 130.);
+    let target = u.app.to_screen(205., 230.);
+    let output = u.frame_output(vec![Event::PointerMoved(p)]);
+    assert_eq!(output.platform_output.cursor_icon, egui::CursorIcon::Grab);
+    drag(&mut u, p, target - p, true);
+    assert_eq!(xy(&u, ids[0]), (180., 200.));
+    assert_eq!(xy(&u, ids[3]), (260., 100.));
+    assert_eq!(u.app.session.selection(), ids);
+    assert_eq!(u.app.session.undo_depth().0, before + 1);
+    u.app.run("edit.undo", json!({}));
+    assert_eq!(xy(&u, ids[0]), (100., 100.));
+    u.app.run("edit.redo", json!({}));
+    assert_eq!(xy(&u, ids[0]), (180., 200.));
+}
+
+#[test]
+fn reorder_ring_escape_click_and_returning_home_make_no_undo_step() {
+    for action in [0, 1, 2] {
+        let (mut u, ids) = scene(false);
+        let history = u.app.session.undo_depth().0;
+        let before = u.app.session.doc().unwrap().clone();
+        let p = u.app.to_screen(125., 130.);
+        let target = u.app.to_screen(285., 130.);
+        u.frame(vec![Event::PointerMoved(p)]);
+        if action == 0 {
+            u.button(p, true);
+        } else {
+            drag(&mut u, p, target - p, false);
+            assert_eq!(xy(&u, ids[0]), (260., 100.));
+            if action == 1 {
+                key(&mut u, Key::Escape);
+            } else {
+                u.frame(vec![Event::PointerMoved(p)]);
+            }
+        }
+        u.button(p, false);
+        u.frame(vec![]);
+        assert_eq!(u.app.session.doc().unwrap(), &before);
+        assert_eq!(u.app.session.undo_depth().0, history);
+        assert_eq!(u.app.session.selection(), ids);
+        assert!(u.app.session.ds().unwrap().interaction.is_none());
+    }
+}
+
+#[test]
+fn command_drag_swaps_and_a_stationary_pointer_keeps_the_preview() {
+    let (mut u, ids) = scene(true);
+    let p = u.app.to_screen(125., 130.);
+    let target = u.app.to_screen(205., 230.);
+    // The modifier can already be down when the handle is pressed.
+    let m = Modifiers::COMMAND;
+    u.frame_with(vec![Event::PointerMoved(p)], m);
+    u.frame_with(vec![Event::PointerButton { pos: p, button: egui::PointerButton::Primary, pressed: true, modifiers: m }], m);
+    u.frame_with(vec![Event::PointerMoved(target)], m);
+    assert_eq!(xy(&u, ids[0]), (180., 200.));
+    assert_eq!(xy(&u, ids[4]), (100., 100.));
+    assert_eq!(xy(&u, ids[1]), (180., 100.));
+    let snapshot = u.app.session.ds().unwrap().doc.clone();
+    for _ in 0..5 {
+        u.frame_with(vec![], m);
+    }
+    assert!(std::sync::Arc::ptr_eq(&snapshot, &u.app.session.ds().unwrap().doc));
+    // Changing modifiers without moving the pointer switches to insertion.
+    u.frame(vec![]);
+    assert_eq!(xy(&u, ids[1]), (100., 100.));
+    assert_eq!(xy(&u, ids[4]), (100., 200.));
+    u.button(target, false);
+}
+
+#[test]
+fn switching_documents_during_reordering_rolls_back_its_owner() {
+    let (mut u, ids) = scene(false);
+    let before = u.app.session.doc().unwrap().clone();
+    let p = u.app.to_screen(125., 130.);
+    let target = u.app.to_screen(285., 130.);
+    drag(&mut u, p, target - p, false);
+    u.app.run("file.new", json!({}));
+    u.app.session.begin_interaction("Unrelated").unwrap();
+    u.frame(vec![]);
+    assert!(u.app.session.ds().unwrap().interaction.is_some());
+    u.app.session.active = 0;
+    assert_eq!(u.app.session.doc().unwrap(), &before);
+    assert_eq!(u.app.session.selection(), ids);
+}
+
+#[test]
+fn reorder_release_outside_window_commits_and_undo_while_dragging_cancels() {
+    for undo in [false, true] {
+        let (mut u, ids) = scene(false);
+        let history = u.app.session.undo_depth().0;
+        let p = u.app.to_screen(125., 130.);
+        let target = u.app.to_screen(285., 130.);
+        drag(&mut u, p, target - p, false);
+        if undo {
+            let m = Modifiers::COMMAND;
+            u.frame_with(vec![Event::Key { key: Key::Z, physical_key: None, pressed: true, repeat: false, modifiers: m }], m);
+        }
+        u.frame(vec![Event::PointerGone]);
+        u.button(Pos2::new(-1., -1.), false);
+        u.frame(vec![]);
+        assert_eq!(u.app.session.undo_depth().0, history + usize::from(!undo));
+        assert_eq!(xy(&u, ids[0]), if undo { (100., 100.) } else { (260., 100.) });
+        assert!(u.app.session.ds().unwrap().interaction.is_none());
+    }
+}
+
+#[test]
+fn an_externally_finished_reorder_cannot_resume_on_later_pointer_motion() {
+    let (mut u, ids) = scene(false);
+    let p = u.app.to_screen(125., 130.);
+    let target = u.app.to_screen(285., 130.);
+    drag(&mut u, p, target - p, false);
+    u.app.session.commit_interaction().unwrap();
+    let history = u.app.session.undo_depth().0;
+    let committed = u.app.session.doc().unwrap().clone();
+    let middle = u.app.to_screen(205., 130.);
+    u.frame(vec![Event::PointerMoved(middle)]);
+    u.button(middle, false);
+    u.frame(vec![]);
+    assert_eq!(u.app.session.doc().unwrap(), &committed);
+    assert_eq!(u.app.session.undo_depth().0, history);
+    assert_eq!(xy(&u, ids[0]), (260., 100.));
+}
+
+#[test]
+fn small_layers_on_screen_have_no_reorder_ring_and_drag_the_selection_from_their_middle() {
+    let mut u = Ui::new(Session::new());
+    let z = u.app.session.ds().unwrap().view.zoom;
+    // 12 px squares 36 px apart on screen: a regular row, too small for rings.
+    let ids: Vec<NodeId> = (0..3)
+        .map(|col| {
+            let p = json!({"x": (100. + f64::from(col) * 36.) / z, "y": 100. / z, "width": 12. / z, "height": 12. / z});
+            NodeId(u.app.session.execute("shape.rectangle", &p).unwrap()["id"].as_u64().unwrap())
+        })
+        .collect();
+    u.app.session.execute("select.set", &json!({"ids": ids})).unwrap();
+    let before: Vec<_> = ids.iter().map(|id| xy(&u, *id)).collect();
+    let p = u.app.to_screen(before[0].0 + 6. / z, before[0].1 + 6. / z);
+    let output = u.frame_output(vec![Event::PointerMoved(p)]);
+    assert_ne!(output.platform_output.cursor_icon, egui::CursorIcon::Grab);
+    drag(&mut u, p, vec2(0., 60.), true);
+    let after: Vec<_> = ids.iter().map(|id| xy(&u, *id)).collect();
+    assert!(after[0].1 > before[0].1, "the selection moved: {before:?} -> {after:?}");
+    assert!(
+        before.iter().zip(&after).all(|(b, a)| (a.0 - b.0).abs() < 1e-6 && (a.1 - b.1 - (after[0].1 - before[0].1)).abs() < 1e-6),
+        "all together, in order"
+    );
+    assert_eq!(u.app.session.selection(), ids);
+}
diff --git a/crates/ui-egui/src/shortcuts.rs b/crates/ui-egui/src/shortcuts.rs
index d5bfb1568..4d44115a0 100644
--- a/crates/ui-egui/src/shortcuts.rs
+++ b/crates/ui-egui/src/shortcuts.rs
@@ -94,33 +94,47 @@ fn cached_tip(label: &'static str, key: Option<&'static str>) -> &'static str {
 
 /// Run the shortcuts this frame's keys press. `typing`: a field had the keyboard when the frame
 /// began.
-pub fn handle(app: &mut FigApp, ctx: &Context, typing: bool) {
+/// `swallowed`: what this frame's Cmd/Ctrl+V chords the shell swallowed ask for ([`swallowed_paste`]).
+pub fn handle(app: &mut FigApp, ctx: &Context, typing: bool, swallowed: Swallowed) {
     note_platform(ctx);
-    // Text fields in panels own the keyboard (also the key that ends their editing).
+    // A save asked for from a field last frame: the field has committed by now.
+    if let Some(id) = app.ui.after_field.take() {
+        run_binding(app, id);
+    }
+    // Text fields in panels own the keyboard (also the key that ends their editing), except for
+    // the save shortcuts.
     if typing || crate::a11y::field_focused(ctx) || app.ui.palette.is_some() {
+        if app.ui.palette.is_none() {
+            save_from_field(app, ctx);
+        }
         return;
     }
     let events: Vec<Event> = ctx.input(|i| i.events.clone());
-    if events.is_empty() {
-        return;
-    }
+    // Every frame while editing, even one without input: a frame without the IME output turns the
+    // platform's IME off, which drops the composition (macOS then types plain letters).
     let editing = app.session.ds().map(|d| d.text_edit.is_some()).unwrap_or(false);
     if editing {
         text_keys(app, ctx, &events);
         return;
     }
-    // An image-only clipboard brings no paste event, just the key: paste from the key then.
+    if events.is_empty() {
+        return;
+    }
+    // An image-only clipboard brings no paste event: paste from the key then. The browser sends
+    // the press; the desktop shell swallows it and sends only the release.
     let paste_event = events.iter().any(|e| matches!(e, Event::Paste(_)));
-    let paste_key = events.iter().any(|e| matches!(e, Event::Key { key: Key::V, pressed: true, repeat: false, modifiers, .. } if modifiers.command && !modifiers.shift && !modifiers.alt));
-    if paste_key && !paste_event {
-        crate::menus::paste(app, None);
+    let paste_key = events.iter().any(|e| matches!(e, Event::Key { key: Key::V, pressed: true, repeat: false, modifiers, .. } if modifiers.command && v_binding(*modifiers) == Some("edit.paste")));
+    match swallowed.run.or((paste_key && !paste_event).then_some("edit.paste")) {
+        Some("edit.paste") => crate::menus::paste(app, None, None),
+        Some(id) => run_binding(app, id),
+        None => {}
     }
     let now = ctx.input(|i| i.time);
     for ev in &events {
         match ev {
             Event::Copy => crate::menus::invoke(app, "edit.copy"),
             Event::Cut => crate::menus::invoke(app, "edit.cut"),
-            Event::Paste(text) => crate::menus::paste(app, Some(text)),
+            Event::Paste(text) if !swallowed.drop_text => crate::menus::paste(app, Some(text), None),
             Event::Key { key, physical_key, pressed: true, modifiers, repeat }
                 if key_event(app, *key, *physical_key, *modifiers, *repeat, now, ctx) =>
             {
@@ -131,11 +145,115 @@ pub fn handle(app: &mut FigApp, ctx: &Context, typing: bool) {
     }
 }
 
+/// Commands whose shortcut works while a panel field has the keyboard: they don't edit text, and
+/// a file that can't be saved from a field looks like a file that can't be saved (#1157).
+const FROM_A_FIELD: [&str; 2] = ["file.save", "file.saveAs"];
+
+/// Cmd/Ctrl+S (or Shift+Cmd/Ctrl+S) pressed in a panel field: the field lets go of the keyboard,
+/// which commits what was typed as clicking away does, and the save runs next frame, after that
+/// commit.
+fn save_from_field(app: &mut FigApp, ctx: &Context) {
+    let id = ctx.input(|i| {
+        i.events.iter().find_map(|e| match e {
+            Event::Key { key, physical_key, pressed: true, repeat: false, modifiers } if modifiers.command => {
+                lookup(keymap::Context::Canvas, *key, *physical_key, *modifiers).map(|b| b.id).filter(|id| FROM_A_FIELD.contains(id))
+            }
+            _ => None,
+        })
+    });
+    if let Some(id) = id {
+        ctx.memory_mut(|m| {
+            if let Some(f) = m.focused() {
+                m.surrender_focus(f);
+            }
+        });
+        app.ui.after_field = Some(id);
+        ctx.request_repaint();
+    }
+}
+
+/// The command Cmd/Ctrl+V runs with `m` held too: `edit.paste`, `edit.pasteOver` (Shift),
+/// `edit.pasteProperties` (Alt), or `None` for a chord nothing is bound to. The keymap decides,
+/// whether the key press arrived (browser) or only a paste event and the release (desktop).
+fn v_binding(m: Modifiers) -> Option<&'static str> {
+    lookup(keymap::Context::Canvas, Key::V, Some(Key::V), Modifiers { command: true, ..m }).map(|b| b.id)
+}
+
+/// What this frame's Cmd/Ctrl+V chords ask for when the desktop shell swallowed their press
+/// ([`swallowed_paste`]).
+#[derive(Clone, Copy, Default)]
+pub struct Swallowed {
+    /// The command to run ([`v_binding`]).
+    pub run: Option<&'static str>,
+    /// This frame's paste event belongs to another command or an unbound chord: its text isn't
+    /// pasted.
+    pub drop_text: bool,
+}
+
+/// egui-winit swallows every Cmd/Ctrl+V press, Shift or Alt held or not, and sends a paste event
+/// only when the clipboard holds text. So a chord brings a paste event (text) or just its release
+/// (an image, or nothing). The browser sends the press as well, which runs the command itself.
+/// Call at the start of every frame: it reads the raw events, which keys consumed by panels or the
+/// presenter still carry.
+pub fn swallowed_paste(app: &mut FigApp, ctx: &Context) -> Swallowed {
+    let ui = &mut app.ui;
+    let mut out = Swallowed::default();
+    ctx.input(|i| {
+        for ev in &i.raw.events {
+            match ev {
+                Event::ModifiersChanged(m) => ui.held = *m,
+                // Without Cmd/Ctrl held it's another paste key (Shift+Insert, a Paste key).
+                Event::Paste(_) if ui.held.command => {
+                    let id = v_binding(ui.held);
+                    if id != Some("edit.paste") {
+                        out.drop_text = true;
+                        // Held down, the chord repeats its paste event: run once, as keys do.
+                        if !ui.v_pressed && !ui.paste_event {
+                            out.run = out.run.or(id);
+                        }
+                    }
+                    ui.paste_event = true;
+                }
+                Event::Paste(_) => ui.paste_event = true,
+                Event::Key { key: Key::V, pressed: true, .. } => ui.v_pressed = true,
+                Event::Key { key: Key::V, pressed: false, modifiers, .. } => {
+                    // Cmd was down when V went down, maybe let go first. A V held while the window
+                    // was away comes back as a release alone: without Cmd held, that's no paste.
+                    if !ui.v_pressed && !ui.paste_event && (modifiers.command || !ui.refocused) {
+                        out.run = out.run.or(v_binding(*modifiers));
+                    }
+                    ui.v_pressed = false;
+                    ui.paste_event = false;
+                    ui.refocused = false;
+                }
+                // The other keys that paste (Shift+Insert, a Paste key) end their paste event.
+                Event::Key { key: Key::Insert | Key::Paste, pressed: false, .. } => ui.paste_event = false,
+                // Keys let go in another window never come back as releases.
+                Event::WindowFocused(false) => {
+                    ui.v_pressed = false;
+                    ui.paste_event = false;
+                    ui.held = Modifiers::NONE;
+                }
+                Event::WindowFocused(true) => ui.refocused = true,
+                _ => {}
+            }
+        }
+    });
+    out
+}
+
 /// Run the command a shortcut is bound to, with the keyboard's own twists (Escape steps out
 /// before it deselects, Delete ends a pen path, Enter edits the selected text or vector).
 pub fn run_binding(app: &mut FigApp, id: &str) {
+    // Dev Mode places and edits nothing: Enter selects children.
+    let dev = app.ui.right_tab == crate::RightTab::Inspect;
     match id {
         "select.none" => {
+            if let Some(ctx) = &app.ui_context
+                && crate::proto_panel::close_editor(ctx)
+            {
+                return;
+            }
             if let Err(e) = app.session.escape() {
                 app.toast(e.to_string());
             }
@@ -145,15 +263,21 @@ pub fn run_binding(app: &mut FigApp, id: &str) {
             let _ = app.session.pen_finish();
         }
         // Enter with a shape or frame tool chosen places one in the middle of the view.
-        "select.children" if app.session.tool.tool.draws_shape() => {
+        "select.children" if !dev && app.session.tool.tool.draws_shape() => {
             app.run("tool.place", json!({}));
         }
-        "select.children" if enter_text(app) => {}
+        "select.children" if !dev && enter_text(app) => {}
         _ => crate::menus::invoke(app, id),
     }
 }
 
 fn key_event(app: &mut FigApp, key: Key, physical: Option<Key>, m: Modifiers, repeat: bool, now: f64, ctx: &Context) -> bool {
+    if key == Key::Escape && crate::proto_panel::close_editor(ctx) {
+        return true;
+    }
+    if key == Key::Escape && crate::selection_spacing::cancel(app, ctx) {
+        return true;
+    }
     if key_box(app, key, m) {
         return true;
     }
@@ -161,6 +285,10 @@ fn key_event(app: &mut FigApp, key: Key, physical: Option<Key>, m: Modifiers, re
     if matches!(key, Key::Backspace | Key::Delete) && m.is_none() && app.ui.picker.is_some() && crate::handles::remove_selected_stop(app, ctx) {
         return true;
     }
+    // An interaction selected in the Prototype tab: Delete removes that interaction, not the component.
+    if matches!(key, Key::Backspace | Key::Delete) && m.is_none() && crate::proto_panel::delete_selected_interaction(app, ctx) {
+        return true;
+    }
     // Vector edit mode and the shape builder have their own keys (tools, nudging points, delete,
     // join, Enter to finish); the rest fall through.
     match app.session.tool_key(key.name(), m.shift, m.alt, m.command) {
@@ -177,6 +305,9 @@ fn key_event(app: &mut FigApp, key: Key, physical: Option<Key>, m: Modifiers, re
             return true;
         }
         if !repeat || matches!(b.id, "edit.undo" | "edit.redo" | "view.zoomIn" | "view.zoomOut") {
+            if matches!(b.id, "edit.undo" | "edit.redo") && crate::selection_spacing::cancel(app, ctx) {
+                return true;
+            }
             run_binding(app, b.id);
         }
         return true;
@@ -185,7 +316,8 @@ fn key_event(app: &mut FigApp, key: Key, physical: Option<Key>, m: Modifiers, re
     if app.ui.layers_focus && !m.command && !m.alt && crate::layers::key_nav(app, key, m.shift) {
         return true;
     }
-    // Arrow nudges; with nothing selected the arrows pan the view.
+    // Arrow nudges, Alt held too (measuring stays on while the selection moves); with nothing
+    // selected the arrows pan the view.
     let (dx, dy) = match key {
         Key::ArrowLeft => (-1.0, 0.0),
         Key::ArrowRight => (1.0, 0.0),
@@ -193,9 +325,11 @@ fn key_event(app: &mut FigApp, key: Key, physical: Option<Key>, m: Modifiers, re
         Key::ArrowDown => (0.0, 1.0),
         _ => (0.0, 0.0),
     };
-    if (dx, dy) != (0.0, 0.0) && !m.alt {
+    if (dx, dy) != (0.0, 0.0) {
         if app.session.selection().is_empty() {
             app.run("view.pan", json!({"dx": dx, "dy": dy, "big": m.shift}));
+        } else if crate::menus::dev_mode_refuses(app, "transform.nudge") {
+            // Dev Mode: said so, nothing moves.
         } else if m.command {
             // Cmd/Ctrl+arrows resize: right/down grow, left/up shrink.
             app.run("transform.nudgeSize", json!({"dw": dx, "dh": dy, "big": m.shift}));
@@ -207,9 +341,9 @@ fn key_event(app: &mut FigApp, key: Key, physical: Option<Key>, m: Modifiers, re
     if m.is_none() && !repeat && opacity_digit(app, key, now) {
         return true;
     }
-    // Enter while the pen is drawing finishes it.
+    // Enter while the pen is drawing ends the path as Escape does.
     if key == Key::Enter && app.session.tool.pen.is_some() {
-        let _ = app.session.pen_finish();
+        let _ = app.session.pen_end();
         return true;
     }
     false
@@ -292,6 +426,9 @@ pub fn opacity_digit(app: &mut FigApp, key: Key, now: f64) -> bool {
     if !app.session.prefs.number_keys_opacity || app.session.selection().is_empty() {
         return false;
     }
+    if crate::menus::dev_mode_refuses(app, "object.opacityKeys") {
+        return true;
+    }
     let first = app.ui.opacity_digit.take().filter(|(_, t)| now - t <= OPACITY_CHAIN_SECS).map(|(d, _)| d);
     let digits = match first {
         Some(f) => format!("{f}{d}"),
@@ -318,6 +455,15 @@ fn enter_text(app: &mut FigApp) -> bool {
         return false;
     }
     let Some(id) = sel.first().copied() else { return false };
+    // A board object (a sticky, a shape with text, a label): type in its text.
+    match figcraft_engine::board::edit_text(&mut app.session, id) {
+        Ok(true) => return true,
+        Ok(false) => {}
+        Err(e) => {
+            app.toast(e.to_string());
+            return true;
+        }
+    }
     let kind = app.session.doc().ok().and_then(|d| d.node(id)).map(|n| (matches!(n.kind, figcraft_doc::NodeKind::Text(_)), n.kind.is_shape()));
     match kind {
         Some((true, _)) => {
@@ -368,6 +514,10 @@ fn text_keys(app: &mut FigApp, ctx: &Context, events: &[Event]) {
                 }
             }
             Event::Key { key, physical_key, pressed: true, modifiers: m, .. } => {
+                // Keys during a composition are the IME's (Enter picks a candidate, Escape cancels).
+                if app.session.ds().is_ok_and(|d| d.text_edit.as_ref().is_some_and(|te| te.preedit.is_some())) {
+                    continue;
+                }
                 if (m.command || m.alt || m.ctrl) && text_shortcut(app, *key, *physical_key, *m) {
                     skip_text = true;
                     continue;
@@ -452,7 +602,8 @@ fn ime_output(app: &FigApp, ctx: &Context) {
     ctx.output_mut(|o| {
         o.ime = Some(egui::output::IMEOutput {
             purpose: egui::IMEPurpose::Normal,
-            rect: app.canvas.rect,
+            // The desktop places the candidate window by `rect` (the web by `cursor_rect`).
+            rect: cursor_rect,
             cursor_rect,
             should_interrupt_composition: false,
         })
diff --git a/crates/ui-egui/src/shortcuts_tests.rs b/crates/ui-egui/src/shortcuts_tests.rs
index cd0f0ea58..5c1e06fab 100644
--- a/crates/ui-egui/src/shortcuts_tests.rs
+++ b/crates/ui-egui/src/shortcuts_tests.rs
@@ -188,3 +188,12 @@ fn shortcuts_panel_opens_switches_tabs_and_searches() {
     u.app.run("help.shortcuts", json!({}));
     assert!(!u.app.ui.shortcuts_panel, "the command toggles it");
 }
+
+#[test]
+fn shortcuts_panel_does_not_show_on_the_home_screen() {
+    let mut u = Ui::new(Session::empty());
+    u.app.ui.home = true;
+    u.app.ui.shortcuts_panel = true;
+    u.frame(vec![]);
+    assert!(!u.app.ui.shortcuts_panel, "the panel closes on the home screen");
+}
diff --git a/crates/ui-egui/src/style_picker.rs b/crates/ui-egui/src/style_picker.rs
index 966ea4828..227130003 100644
--- a/crates/ui-egui/src/style_picker.rs
+++ b/crates/ui-egui/src/style_picker.rs
@@ -482,7 +482,7 @@ fn style_grid(ui: &mut Ui, list: &[(&Style, Key)], applied: Option<&Key>, editab
                     None => preview(ui, r, s, StyleSlot::Fill),
                 }
                 if applied == Some(key) {
-                    ui.painter().rect_stroke(r.expand(2.0), CornerRadius::same(5), Stroke::new(2.0, t.accent), egui::StrokeKind::Inside);
+                    ui.painter().rect_stroke(r.expand(2.0), CornerRadius::same(5), Stroke::new(2.0, crate::theme::ACCENT), egui::StrokeKind::Inside);
                 } else if resp.hovered() && !text {
                     ui.painter().rect_stroke(r.expand(2.0), CornerRadius::same(4), Stroke::new(1.0, t.menu_text), egui::StrokeKind::Inside);
                 }
@@ -909,7 +909,7 @@ pub fn show(app: &mut FigApp, ctx: &egui::Context) {
     // Clicks in the colour picker editing this picker's style, or in a menu the editor opened,
     // keep it open.
     let picker_rect =
-        app.ui.picker.as_ref().filter(|t| matches!(t, PickerTarget::Style { .. })).and(ctx.memory(|m| m.area_rect(Id::new("color_picker"))));
+        app.ui.picker.as_ref().filter(|t| matches!(t, PickerTarget::Style { .. })).and(ctx.memory(|m| m.area_rect(crate::colorpicker::window_id())));
     // So do clicks in the variable picker binding one of its fields (Escape closes that first).
     let variables = crate::variable_ui::picker_rect(ctx);
     let in_popup = egui::Popup::is_any_open(ctx) || variables.is_some();
diff --git a/crates/ui-egui/src/style_picker_tests.rs b/crates/ui-egui/src/style_picker_tests.rs
index becc42ce4..ad2c29710 100644
--- a/crates/ui-egui/src/style_picker_tests.rs
+++ b/crates/ui-egui/src/style_picker_tests.rs
@@ -164,6 +164,34 @@ fn chars_linked_to_several_styles_show_mixed() {
     assert_eq!(text_link(&app, &doc, &[t]), None);
 }
 
+#[test]
+fn a_click_in_the_colour_picker_keeps_the_style_editor_open() {
+    use crate::layers_drag_tests::Ui;
+    let mut s = Session::new();
+    s.execute("style.create", &json!({"type": "paint", "name": "Brand", "value": [{"type": "solid", "color": "#0D99FF"}]})).unwrap();
+    let mut u = Ui::new(s);
+    open_for_selection(&mut u.app, StyleSlot::Fill, Some("Brand"));
+    for _ in 0..3 {
+        u.frame(vec![]);
+    }
+    let id = u.app.session.doc().unwrap().style("Brand").unwrap().id.clone();
+    u.app.ui.picker = Some(crate::colorpicker::PickerTarget::Style { id, index: 0 });
+    for _ in 0..3 {
+        u.frame(vec![]);
+    }
+    let cp = u.ctx.memory(|m| m.area_rect(crate::colorpicker::window_id())).expect("colour picker shows");
+    let p = cp.center();
+    u.button(p, true);
+    u.button(p, false);
+    u.frame(vec![]);
+    assert!(u.app.ui.style_picker.is_some(), "the style editor stays open while the colour picker is used");
+    assert!(
+        matches!(u.app.ui.picker, Some(crate::colorpicker::PickerTarget::Style { .. })),
+        "the colour picker stays open too: {:?}",
+        u.app.ui.picker
+    );
+}
+
 #[test]
 fn local_style_drops_move_into_the_folder_above() {
     let st = |id: &str, name: &str| Style {
diff --git a/crates/ui-egui/src/tabs.rs b/crates/ui-egui/src/tabs.rs
index 27ff085c8..521fd05c3 100644
--- a/crates/ui-egui/src/tabs.rs
+++ b/crates/ui-egui/src/tabs.rs
@@ -3,37 +3,110 @@
 //! window buttons; the window's edges resize it.
 
 use egui::{Align2, Color32, CornerRadius, Rect, Sense, Stroke, Ui, pos2, vec2};
+use figcraft_doc::NodeId;
 use serde_json::json;
 
 use crate::a11y::Tip;
 use crate::i18n::{tr, trf};
 use crate::icons::{self, Icon};
+use crate::present::{PresentTab, Presenter};
 use crate::theme::{Tokens, regular};
 use crate::{FigApp, TitleBar};
 
 pub const HEIGHT: f32 = 40.0;
+const MIN_TAB_WIDTH: f32 = 96.0;
+const OVERFLOW_WIDTH: f32 = 32.0;
+const OPEN_TIME: f64 = 0.18;
+
+/// Which tabs were open last frame and when the newly opened ones appeared. It is updated in place
+/// in egui's memory; it only allocates when the set of tabs changes.
+#[derive(Clone, Default)]
+struct TabMotion {
+    initialized: bool,
+    known: Vec<u64>,
+    opening: Vec<(u64, f64)>,
+}
+
+impl TabMotion {
+    /// Track tabs added since the previous frame and expire their animations.
+    fn begin_frame(&mut self, current: impl Iterator<Item = u64> + Clone, now: f64, reduce_motion: bool) {
+        if !self.known.iter().copied().eq(current.clone()) {
+            if self.initialized && !reduce_motion {
+                for uid in current.clone().filter(|uid| !self.known.contains(uid)) {
+                    self.opening.push((uid, now));
+                }
+            }
+            self.known = current.collect();
+        }
+        self.initialized = true;
+        if reduce_motion {
+            self.opening.clear();
+        } else {
+            let known = &self.known;
+            self.opening.retain(|(uid, started)| known.contains(uid) && now - *started < OPEN_TIME);
+        }
+    }
+}
+
+/// The entering tab's progress among `opening` (from [`TabMotion`]), or 1 when it is not animating.
+fn open_progress(opening: &[(u64, f64)], uid: u64, now: f64) -> f32 {
+    opening.iter().find(|(u, _)| *u == uid).map_or(1.0, |(_, started)| ((now - started) / OPEN_TIME).clamp(0.0, 1.0) as f32)
+}
+
+struct TabLayout {
+    first: usize,
+    widths: Vec<f32>,
+    overflow: bool,
+}
+
+/// Shrink open tabs before moving the excess into the overflow menu.
+fn tab_layout(preferred: &[f32], available: f32, active: Option<usize>) -> TabLayout {
+    let count = preferred.len();
+    let overflow = count as f32 * MIN_TAB_WIDTH > available;
+    let visible = if overflow { ((available - OVERFLOW_WIDTH).max(0.0) / MIN_TAB_WIDTH).floor() as usize } else { count }.min(count);
+    let first = active.unwrap_or(0).saturating_sub(visible / 2).min(count - visible);
+    let mut widths = preferred[first..first + visible].to_vec();
+    let budget = (available - if overflow { OVERFLOW_WIDTH } else { 0.0 }).max(0.0);
+    let mut excess = (widths.iter().sum::<f32>() - budget).max(0.0);
+    while excess > 0.01 {
+        let flexible = widths.iter().filter(|w| **w > MIN_TAB_WIDTH + 0.01).count();
+        if flexible == 0 {
+            break;
+        }
+        let share = excess / flexible as f32;
+        let mut removed = 0.0;
+        for width in &mut widths {
+            let shrink = (*width - MIN_TAB_WIDTH).max(0.0).min(share);
+            *width -= shrink;
+            removed += shrink;
+        }
+        excess -= removed;
+    }
+    TabLayout { first, widths, overflow }
+}
+
+/// Final document index and insertion marker for a tab dropped among the visible tabs.
+fn tab_drop_position(visible: &[(usize, Rect)], from: usize, pointer_x: f32) -> Option<(usize, f32)> {
+    let others: Vec<_> = visible.iter().copied().filter(|(index, _)| *index != from).collect();
+    let slot = others.partition_point(|(_, rect)| rect.center().x < pointer_x);
+    if let Some(&(index, rect)) = others.get(slot) {
+        Some((index - usize::from(from < index), rect.min.x))
+    } else {
+        let &(index, rect) = others.last()?;
+        Some((index + usize::from(from > index), rect.max.x))
+    }
+}
 
 pub fn tab_bar(app: &mut FigApp, ui: &mut Ui) {
     let t = Tokens::get(ui.ctx());
     egui::Panel::top("tab_bar").exact_size(HEIGHT).frame(egui::Frame::NONE.fill(t.tab_bar)).show(ui, |ui| {
         let rect = ui.max_rect();
-        // Empty space moves the window (first, so the tabs and buttons on top take their clicks).
-        if app.ui.title_bar != TitleBar::Native {
-            let drag = ui.interact(rect, ui.id().with("titlebar_drag"), Sense::click_and_drag());
-            if drag.drag_started() {
-                ui.ctx().send_viewport_cmd(egui::ViewportCommand::StartDrag);
-            }
-            if drag.double_clicked() {
-                let max = ui.input(|i| i.viewport().maximized.unwrap_or(false));
-                ui.ctx().send_viewport_cmd(egui::ViewportCommand::Maximized(!max));
-            }
-        }
-        let buttons_w = if app.ui.title_bar == TitleBar::Custom { window_buttons(ui, rect) } else { 0.0 };
+        let buttons_w = if app.ui.title_bar == TitleBar::Custom { window_buttons(app, ui, rect) } else { 0.0 };
         let mut x = rect.min.x + if app.ui.title_bar == TitleBar::Inset { 76.0 } else { 8.0 };
         // Home.
         let hr = Rect::from_min_size(pos2(x, rect.min.y), vec2(44.0, HEIGHT));
         let hresp = ui.interact(hr, ui.id().with("home"), Sense::click()).tip(tr("Home"));
-        let home_active = app.ui.home || !app.has_files();
+        let home_active = (app.ui.home || !app.has_files()) && app.ui.present.is_none();
         crate::a11y::tab(&hresp, tr("Home"), home_active);
         if home_active {
             ui.painter().rect_filled(hr, CornerRadius::ZERO, t.tab_active);
@@ -42,32 +115,80 @@ pub fn tab_bar(app: &mut FigApp, ui: &mut Ui) {
         }
         icons::paint(ui.painter(), Rect::from_center_size(hr.center(), vec2(16.0, 16.0)), Icon::Home, t.icon);
         if hresp.clicked() {
+            pause_present(app);
             app.ui.home = true;
         }
         x += 44.0;
         ui.painter().line_segment([pos2(x, rect.min.y), pos2(x, rect.max.y)], Stroke::new(1.0, t.border));
+        let document_tabs: Vec<usize> = app.session.docs.iter().enumerate().filter_map(|(i, d)| app.shows(d.uid).then_some(i)).collect();
+        let now = ui.input(|input| input.time);
+        let motion_id = ui.id().with("tab_motion");
+        let current_uids = document_tabs.iter().filter_map(|&i| app.session.docs.get(i).map(|d| d.uid));
+        let reduce_motion = app.reduce_motion();
+        // Cloning `opening` is free while nothing animates (an empty Vec).
+        let opening = ui.ctx().data_mut(|data| {
+            let motion = data.get_temp_mut_or_default::<TabMotion>(motion_id);
+            motion.begin_frame(current_uids, now, reduce_motion);
+            motion.opening.clone()
+        });
+        let preferred: Vec<f32> = document_tabs
+            .iter()
+            .map(|&i| {
+                let d = &app.session.docs[i];
+                let mark_w = if live_mark(app, d.uid).is_some() { 18.0 } else { 0.0 };
+                let dot_w = if d.is_dirty() && mark_w > 0.0 { 12.0 } else { 0.0 };
+                (regular(12.0).size * 0.6 * d.doc.name.chars().count() as f32 + 64.0 + mark_w + dot_w).clamp(120.0, 220.0)
+            })
+            .collect();
+        // Leave the new-tab button, theme toggle, window controls and a draggable gap free.
+        let room = (rect.max.x - buttons_w - 70.0 - x - 34.0).max(0.0);
+        let present_pref: Vec<f32> = app.ui.presents.iter().map(present_tab_width).collect();
+        let present_on = app.ui.present.as_ref().and(app.ui.present_active);
+        let active_present = present_on.and_then(|id| app.ui.presents.iter().position(|p| p.id == id));
+        let present_layout = tab_layout(&present_pref, present_room(room, &present_pref, !document_tabs.is_empty()), active_present);
+        let present_used = present_layout.widths.iter().sum::<f32>() + if present_layout.overflow { OVERFLOW_WIDTH } else { 0.0 };
+        let available = (room - present_used).max(0.0);
+        let active_tab = document_tabs.iter().position(|&i| i == app.session.active);
+        let layout = tab_layout(&preferred, available, active_tab);
+        let mut tab_rects = Vec::with_capacity(layout.widths.len());
+        let mut tab_x = x;
+        for &width in &layout.widths {
+            tab_rects.push(Rect::from_min_size(pos2(tab_x, rect.min.y), vec2(width, HEIGHT)));
+            tab_x += width;
+        }
         let mut switch = None;
         let mut close = None;
         // A tab dragged off the strip, or "Open in new window", moves to a window of its own.
         let mut detach = None;
+        let mut dragging = None;
+        let mut dropped = None;
         let several = !ui.ctx().embed_viewports();
-        for (i, d) in app.session.docs.iter().enumerate().filter(|(_, d)| app.shows(d.uid)) {
-            let active = i == app.session.active && !app.ui.home;
-            let name = d.doc.name.clone();
+        for (slot, &w) in layout.widths.iter().enumerate() {
+            let i = document_tabs[layout.first + slot];
+            let d = &app.session.docs[i];
+            let active = i == app.session.active && !app.ui.home && app.ui.present.is_none();
+            let name = &d.doc.name;
             // In a live session: a mark after the name says whether others get in.
             let live = live_mark(app, d.uid);
             let mark_w = if live.is_some() { 18.0 } else { 0.0 };
-            // (A file in a session is rarely saved here: its unsaved dot gets room beside the mark.)
             let dirty = d.is_dirty();
-            let dot_w = if dirty && live.is_some() { 12.0 } else { 0.0 };
-            let w = (regular(12.0).size * 0.6 * name.chars().count() as f32 + 64.0 + mark_w + dot_w).clamp(120.0, 220.0);
-            let r = Rect::from_min_size(pos2(x, rect.min.y), vec2(w, HEIGHT));
-            let resp = ui.interact(r, ui.id().with(("tab", d.uid)), if several { Sense::click_and_drag() } else { Sense::click() });
-            if resp.drag_stopped()
+            let r = tab_rects[slot];
+            let body_r = Rect::from_min_max(r.min, pos2(r.max.x - 32.0, r.max.y));
+            let close_r = Rect::from_min_max(body_r.right_top(), r.max);
+            let resp = ui.interact(body_r, ui.id().with(("tab", d.uid)), Sense::click_and_drag());
+            let cresp = ui.interact(close_r, ui.id().with(("tabclose", d.uid)), Sense::click()).tip(tr("Close tab"));
+            if (resp.dragged() || resp.drag_stopped())
                 && let Some(p) = ui.input(|inp| inp.pointer.latest_pos())
-                && (p.y - rect.center().y).abs() > HEIGHT * 2.0
             {
-                detach = Some((i, Some(p)));
+                if resp.drag_stopped() {
+                    if several && (p.y - rect.center().y).abs() > HEIGHT * 2.0 {
+                        detach = Some((i, Some(p)));
+                    } else if (rect.min.y - 12.0..=rect.max.y + 12.0).contains(&p.y) {
+                        dropped = Some((i, p.x));
+                    }
+                } else {
+                    dragging = Some((i, p));
+                }
             }
             if several {
                 resp.context_menu(|ui| {
@@ -79,49 +200,52 @@ pub fn tab_bar(app: &mut FigApp, ui: &mut Ui) {
                 });
             }
             let label = match live {
-                Some(true) => trf("{name}, in a live session", &[("name", &name)]),
-                Some(false) => trf("{name}, online, open only to you", &[("name", &name)]),
+                Some(true) => trf("{name}, in a live session", &[("name", name)]),
+                Some(false) => trf("{name}, online, open only to you", &[("name", name)]),
                 None => name.clone(),
             };
             let resp = if live.is_some() { resp.on_hover_text(&label) } else { resp };
             crate::a11y::tab(&resp, &label, active);
+            let progress = open_progress(&opening, d.uid, now);
+            let paint_r = r.translate(vec2(-28.0 * (1.0 - progress).powi(2), 0.0));
+            let painter = ui.painter().with_clip_rect(r);
             if active {
-                ui.painter().rect_filled(r, CornerRadius::ZERO, t.tab_active);
-            } else if resp.hovered() {
-                ui.painter().rect_filled(r, CornerRadius::ZERO, t.hover);
+                painter.rect_filled(paint_r, CornerRadius::ZERO, t.tab_active.linear_multiply(progress));
+            } else if resp.hovered() || cresp.hovered() {
+                painter.rect_filled(paint_r, CornerRadius::ZERO, t.hover.linear_multiply(progress));
             }
             icons::paint(
-                ui.painter(),
-                Rect::from_center_size(pos2(r.min.x + 18.0, r.center().y), vec2(14.0, 14.0)),
-                Icon::Logo,
-                crate::theme::ACCENT,
+                &painter,
+                Rect::from_center_size(pos2(paint_r.min.x + 18.0, paint_r.center().y), vec2(14.0, 14.0)),
+                icons::file_mark(d.doc.kind),
+                crate::theme::ACCENT.linear_multiply(progress),
             );
             // The unsaved-changes dot follows the name on screen, whichever way the name reads.
             let shown = crate::bidi::paint_name(
-                ui.painter(),
-                pos2(r.min.x + 32.0, r.center().y),
-                &name,
+                &painter,
+                pos2(paint_r.min.x + 32.0, paint_r.center().y),
+                name,
                 regular(12.0),
-                t.text,
-                w - mark_w - if dirty { 72.0 } else { 60.0 },
+                t.text.linear_multiply(progress),
+                (w - mark_w - if dirty { 72.0 } else { 60.0 }).max(0.0),
             );
             if let Some(shared) = live {
-                let at = Rect::from_center_size(pos2(r.max.x - 38.0, r.center().y), vec2(14.0, 14.0));
-                icons::paint(ui.painter(), at, crate::online::mark(shared), if shared { t.success } else { t.icon_secondary });
+                let at = Rect::from_center_size(pos2(paint_r.max.x - 38.0, paint_r.center().y), vec2(14.0, 14.0));
+                icons::paint(&painter, at, crate::online::mark(shared), if shared { t.success } else { t.icon_secondary }.linear_multiply(progress));
             }
             if dirty {
-                ui.painter().text(pos2(shown.max.x + 4.0, r.center().y), Align2::LEFT_CENTER, "•", regular(12.0), t.text);
+                painter.text(pos2(shown.max.x + 4.0, paint_r.center().y), Align2::LEFT_CENTER, "•", regular(12.0), t.text.linear_multiply(progress));
             }
-            let cr = Rect::from_center_size(pos2(r.max.x - 16.0, r.center().y), vec2(18.0, 18.0));
-            if resp.hovered() || active {
-                let cresp = ui.interact(cr, ui.id().with(("tabclose", d.uid)), Sense::click()).tip(tr("Close tab"));
+            let cr = Rect::from_center_size(close_r.center() + vec2(paint_r.min.x - r.min.x, 0.0), vec2(18.0, 18.0));
+            // The close target never overlaps the draggable body, including on inactive tabs.
+            if resp.hovered() || cresp.hovered() || active {
                 if cresp.hovered() {
-                    ui.painter().rect_filled(cr, CornerRadius::same(4), t.pressed);
-                }
-                icons::paint(ui.painter(), cr.shrink(4.0), Icon::Close, t.icon_secondary);
-                if cresp.clicked() {
-                    close = Some(i);
+                    painter.rect_filled(cr, CornerRadius::same(4), t.pressed.linear_multiply(progress));
                 }
+                icons::paint(&painter, cr.shrink(4.0), Icon::Close, t.icon_secondary.linear_multiply(progress));
+            }
+            if cresp.clicked() {
+                close = Some(i);
             }
             if resp.clicked() && close.is_none() {
                 switch = Some(i);
@@ -132,6 +256,76 @@ pub fn tab_bar(app: &mut FigApp, ui: &mut Ui) {
             x += w;
             ui.painter().line_segment([pos2(x, rect.min.y + 10.0), pos2(x, rect.max.y - 10.0)], Stroke::new(1.0, t.border));
         }
+        let visible: Vec<(usize, Rect)> = tab_rects.iter().copied().enumerate().map(|(slot, r)| (document_tabs[layout.first + slot], r)).collect();
+        if let Some((from, p)) = dragging
+            && (rect.min.y - 12.0..=rect.max.y + 12.0).contains(&p.y)
+            && let Some((_, at)) = tab_drop_position(&visible, from, p.x)
+        {
+            ui.painter().line_segment([pos2(at, rect.min.y + 5.0), pos2(at, rect.max.y - 5.0)], Stroke::new(3.0, crate::theme::ACCENT));
+        }
+        let reorder = dropped.and_then(|(from, at)| tab_drop_position(&visible, from, at).map(|(to, _)| (from, to)));
+        if layout.overflow {
+            let r = Rect::from_min_size(pos2(x, rect.min.y), vec2(OVERFLOW_WIDTH, HEIGHT));
+            let resp = ui.interact(r, ui.id().with("tab_overflow"), Sense::click()).tip(tr("Open files"));
+            crate::a11y::menu_button(&resp, tr("Open files"), crate::a11y::menu_open(&resp));
+            if resp.hovered() {
+                ui.painter().rect_filled(r, CornerRadius::ZERO, t.hover);
+            }
+            icons::paint(ui.painter(), Rect::from_center_size(r.center(), vec2(14.0, 14.0)), Icon::Chevron, t.icon);
+            crate::right::menu_popup(&resp).show(|ui| {
+                egui::ScrollArea::vertical().max_height(400.0).show(ui, |ui| {
+                    for &i in &document_tabs {
+                        let Some(d) = app.session.docs.get(i) else { continue };
+                        let on = i == app.session.active && !app.ui.home && app.ui.present.is_none();
+                        let label = if d.is_dirty() { format!("{} •", d.doc.name) } else { d.doc.name.clone() };
+                        if crate::right::menu_check(ui, on, &label, "") {
+                            switch = Some(i);
+                            ui.close();
+                        }
+                    }
+                });
+            });
+            x += OVERFLOW_WIDTH;
+        }
+        // Presentations live in their own tabs. Switching back to the design keeps the player
+        // state (current screen, navigation history and scroll position) for the return trip.
+        let mut to_present = None;
+        let mut close_present_tab = None;
+        for (tab, &w) in app.ui.presents.iter().skip(present_layout.first).zip(&present_layout.widths) {
+            let active = present_on == Some(tab.id);
+            let (clicked, closed) = present_tab(ui, &t, tab, Rect::from_min_size(pos2(x, rect.min.y), vec2(w, HEIGHT)), active);
+            if clicked && !active {
+                to_present = Some(tab.id);
+            }
+            if closed {
+                close_present_tab = Some(tab.id);
+            }
+            x += w;
+            ui.painter().line_segment([pos2(x, rect.min.y + 10.0), pos2(x, rect.max.y - 10.0)], Stroke::new(1.0, t.border));
+        }
+        if present_layout.overflow {
+            let r = Rect::from_min_size(pos2(x, rect.min.y), vec2(OVERFLOW_WIDTH, HEIGHT));
+            let resp = ui.interact(r, ui.id().with("present_overflow"), Sense::click()).tip(tr("Open presentations"));
+            crate::a11y::menu_button(&resp, tr("Open presentations"), crate::a11y::menu_open(&resp));
+            if resp.hovered() {
+                ui.painter().rect_filled(r, CornerRadius::ZERO, t.hover);
+            }
+            icons::paint(ui.painter(), Rect::from_center_size(r.center(), vec2(14.0, 14.0)), Icon::Chevron, t.icon);
+            crate::right::menu_popup(&resp).show(|ui| {
+                egui::ScrollArea::vertical().max_height(400.0).show(ui, |ui| {
+                    for tab in &app.ui.presents {
+                        let on = present_on == Some(tab.id);
+                        if crate::right::menu_check(ui, on, &present_tab_name(tab), "") {
+                            if !on {
+                                to_present = Some(tab.id);
+                            }
+                            ui.close();
+                        }
+                    }
+                });
+            });
+            x += OVERFLOW_WIDTH;
+        }
         // New tab.
         let nr = Rect::from_center_size(pos2(x + 20.0, rect.center().y), vec2(28.0, 28.0));
         let nresp = ui.interact(nr, ui.id().with("newtab"), Sense::click()).tip(crate::shortcuts::tip(tr("New design file"), "file.new"));
@@ -140,6 +334,7 @@ pub fn tab_bar(app: &mut FigApp, ui: &mut Ui) {
         }
         icons::paint(ui.painter(), nr.shrink(7.0), Icon::Plus, t.icon);
         if nresp.clicked() {
+            pause_present(app);
             app.run("file.new", json!({}));
             app.ui.home = false;
         }
@@ -154,10 +349,28 @@ pub fn tab_bar(app: &mut FigApp, ui: &mut Ui) {
             let cmd = if app.ui.dark { "view.themeLight" } else { "view.themeDark" };
             app.run(cmd, json!({}));
         }
+        // Only the free space drags the window. A full-bar drag target steals tab drags.
+        if app.ui.title_bar != TitleBar::Native && x + 34.0 < theme_r.min.x {
+            let free = Rect::from_min_max(pos2(x + 34.0, rect.min.y), pos2(theme_r.min.x, rect.max.y));
+            let drag = ui.interact(free, ui.id().with("titlebar_drag"), Sense::click_and_drag());
+            if drag.drag_started() {
+                ui.ctx().send_viewport_cmd(egui::ViewportCommand::StartDrag);
+            }
+            if drag.double_clicked() {
+                let max = ui.input(|i| i.viewport().maximized.unwrap_or(false));
+                ui.ctx().send_viewport_cmd(egui::ViewportCommand::Maximized(!max));
+            }
+        }
         if let Some(i) = switch {
+            pause_present(app);
             app.run("doc.switch", json!({"index": i}));
             app.ui.home = false;
         }
+        if let Some(id) = close_present_tab {
+            close_present(app, id);
+        } else if let Some(id) = to_present {
+            show_present(app, id);
+        }
         if let Some((i, at)) = detach {
             // Where the pointer let go, on the screen.
             let at = at.and_then(|p| ui.input(|inp| inp.viewport().inner_rect).map(|r| r.min + p.to_vec2() - vec2(60.0, HEIGHT / 2.0)));
@@ -165,6 +378,11 @@ pub fn tab_bar(app: &mut FigApp, ui: &mut Ui) {
                 app.toast(e);
             }
         }
+        if let Some((from, to)) = reorder
+            && from != to
+        {
+            app.run("file.moveTab", json!({"from": from, "to": to}));
+        }
         if let Some(i) = close {
             // A branch tab's edits live on in its main file: closing it loses nothing.
             let dirty = app.session.docs.get(i).is_some_and(|d| d.is_dirty() && d.branch_of.is_none());
@@ -181,11 +399,172 @@ pub fn tab_bar(app: &mut FigApp, ui: &mut Ui) {
                 app.run("file.close", json!({"index": i}));
             }
         }
-        let _ = Color32::TRANSPARENT;
-        let _ = Align2::LEFT_TOP;
+        if !opening.is_empty() {
+            ui.ctx().request_repaint();
+        }
     });
 }
 
+/// One presentation tab in `r`: whether it was clicked and whether it was closed (its X or a
+/// middle click).
+fn present_tab(ui: &mut Ui, t: &Tokens, tab: &PresentTab, r: Rect, active: bool) -> (bool, bool) {
+    let label = present_tab_name(tab);
+    let body_r = Rect::from_min_max(r.min, pos2(r.max.x - 32.0, r.max.y));
+    let close_r = Rect::from_min_max(body_r.right_top(), r.max);
+    let resp = ui.interact(body_r, ui.id().with(("presentation_tab", tab.id)), Sense::click()).tip(tr("Present"));
+    let cresp = ui.interact(close_r, ui.id().with(("presentation_close", tab.id)), Sense::click()).tip(tr("Close preview"));
+    crate::a11y::tab(&resp, &label, active);
+    let hovered = resp.hovered() || cresp.hovered();
+    if active {
+        ui.painter().rect_filled(r, CornerRadius::ZERO, t.tab_active);
+    } else if hovered {
+        ui.painter().rect_filled(r, CornerRadius::ZERO, t.hover);
+    }
+    icons::paint(ui.painter(), Rect::from_center_size(pos2(r.min.x + 19.0, r.center().y), vec2(14.0, 14.0)), Icon::Play, t.icon);
+    crate::bidi::paint_name(ui.painter(), pos2(r.min.x + 34.0, r.center().y), &label, regular(12.0), t.text, r.width() - 62.0);
+    if hovered || active {
+        let cr = Rect::from_center_size(close_r.center(), vec2(18.0, 18.0));
+        if cresp.hovered() {
+            ui.painter().rect_filled(cr, CornerRadius::same(4), t.pressed);
+        }
+        icons::paint(ui.painter(), cr.shrink(4.0), Icon::Close, t.icon_secondary);
+    }
+    let closed = cresp.clicked() || resp.middle_clicked() || cresp.middle_clicked();
+    (resp.clicked(), closed)
+}
+
+/// The part of the strip's free `room` the presentation tabs may use: all they want, but at most
+/// half of it while file tabs share the strip, so they shrink or overflow before covering controls.
+fn present_room(room: f32, preferred: &[f32], files: bool) -> f32 {
+    preferred.iter().sum::<f32>().min(if files { room / 2.0 } else { room })
+}
+
+fn present_tab_width(tab: &PresentTab) -> f32 {
+    (regular(12.0).size * 0.6 * present_tab_name(tab).chars().count() as f32 + 64.0).clamp(140.0, 260.0)
+}
+
+/// "file - page", or the file alone when the page has no name.
+fn present_tab_name(tab: &PresentTab) -> String {
+    if tab.page_name.is_empty() { tab.file.clone() } else { format!("{} - {}", tab.file, tab.page_name) }
+}
+
+/// The presentation tabs for `ui.inspect`: each one's name and whether it is on screen.
+pub fn present_tabs_inspect(app: &FigApp) -> serde_json::Value {
+    let on_screen = |id| app.ui.present.is_some() && app.ui.present_active == Some(id);
+    app.ui.presents.iter().map(|t| json!({"name": present_tab_name(t), "active": on_screen(t.id)})).collect()
+}
+
+/// The presenter on screen, else the paused one of the active presentation tab.
+pub fn shown_or_paused(app: &FigApp) -> Option<&Presenter> {
+    app.ui.present.as_ref().or_else(|| {
+        let id = app.ui.present_active?;
+        app.ui.presents.iter().find(|t| t.id == id)?.pres.as_ref()
+    })
+}
+
+/// The index of the open file with `uid`, when a file tab shows it.
+fn owner(app: &FigApp, uid: u64) -> Option<usize> {
+    app.session.docs.iter().position(|d| d.uid == uid && app.shows(uid))
+}
+
+/// The presentation on screen plays the file in front (or no tab holds it). Only then may it read
+/// and change that file.
+pub fn present_owner_active(app: &FigApp) -> bool {
+    let Some(tab) = app.ui.present_active.and_then(|id| app.ui.presents.iter().find(|t| t.id == id)) else { return true };
+    owner(app, tab.doc_uid).is_some_and(|i| i == app.session.active)
+}
+
+/// Puts the presenter on screen back into its tab, where it keeps its state.
+fn pause_present(app: &mut FigApp) {
+    let Some(p) = app.ui.present.take() else { return };
+    let id = app.ui.present_active;
+    if let Some(t) = app.ui.presents.iter_mut().find(|t| Some(t.id) == id) {
+        t.pres = Some(p);
+    }
+}
+
+/// Presents from `start`: the tab of its page in this file shows again (from `start` when that
+/// changed), else a new tab opens.
+pub fn open_present(app: &mut FigApp, start: NodeId) {
+    let Ok(ds) = app.session.ds() else { return };
+    let (uid, path) = (ds.uid, ds.path.clone());
+    let page = ds.doc.page_of(start).unwrap_or(ds.page);
+    let file = ds.doc.name.clone();
+    let page_name = ds.doc.node(page).map(|n| n.name.clone()).unwrap_or_default();
+    let mut pres = Presenter::new(start);
+    pres.view = app.ui.present_view;
+    let same = |t: &&PresentTab| t.page == page && (t.doc_uid == uid || (path.is_some() && t.path == path));
+    if let Some(id) = app.ui.presents.iter().find(same).map(|t| t.id) {
+        show_present(app, id);
+        if app.ui.present.as_ref().is_some_and(|p| p.start() != start) {
+            app.ui.present = Some(pres);
+        }
+        return;
+    }
+    pause_present(app);
+    let id = app.ui.present_next;
+    app.ui.present_next += 1;
+    app.ui.presents.push(PresentTab { id, pres: None, doc_uid: uid, path, page, file, page_name });
+    app.ui.present = Some(pres);
+    app.ui.present_active = Some(id);
+    app.ui.home = false;
+}
+
+/// Brings tab `id` to the front and its file too, when that file is open.
+fn show_present(app: &mut FigApp, id: u64) {
+    app.ui.home = false;
+    if app.ui.present.is_some() && app.ui.present_active == Some(id) {
+        return;
+    }
+    pause_present(app);
+    let Some(tab) = app.ui.presents.iter_mut().find(|t| t.id == id) else { return };
+    let Some(p) = tab.pres.take() else { return };
+    let uid = tab.doc_uid;
+    if let Some(i) = owner(app, uid).filter(|i| *i != app.session.active) {
+        app.run("doc.switch", json!({"index": i}));
+    }
+    app.ui.present = Some(p);
+    app.ui.present_active = Some(id);
+}
+
+/// Closes tab `id`. If it was on screen, its file comes to the front, or Home when it is closed.
+pub fn close_present(app: &mut FigApp, id: u64) {
+    let Some(k) = app.ui.presents.iter().position(|t| t.id == id) else { return };
+    let tab = app.ui.presents.remove(k);
+    if app.ui.present_active != Some(id) {
+        return;
+    }
+    app.ui.present_active = None;
+    if app.ui.present.take().is_none() {
+        return;
+    }
+    match owner(app, tab.doc_uid) {
+        Some(i) => {
+            if i != app.session.active {
+                app.run("doc.switch", json!({"index": i}));
+            }
+            app.ui.home = false;
+        }
+        None => app.ui.home = true,
+    }
+}
+
+/// A file that opens again has a new uid. Find it by its path to give its tabs back.
+pub fn relink_presents(app: &mut FigApp) {
+    let docs = &app.session.docs;
+    for t in &mut app.ui.presents {
+        let found = docs.iter().find(|d| d.uid == t.doc_uid).or_else(|| docs.iter().find(|d| t.path.is_some() && d.path == t.path));
+        if let Some(d) = found {
+            t.doc_uid = d.uid;
+            t.path = d.path.clone();
+            t.file = d.doc.name.clone();
+            if let Some(n) = d.doc.node(t.page) {
+                t.page_name = n.name.clone();
+            }
+        }
+    }
+}
+
 /// What the tab of document `uid` says about its live session: others get in (`true`: a session
 /// this app hosts or joined, a file shared online), only you do (`false`: a file of yours on a
 /// server, not shared now), or it has none.
@@ -195,7 +574,7 @@ pub fn live_mark(app: &FigApp, uid: u64) -> Option<bool> {
 }
 
 /// Minimise, maximise/restore and close at the right end of the title bar; returns their width.
-fn window_buttons(ui: &mut Ui, bar: Rect) -> f32 {
+fn window_buttons(app: &mut FigApp, ui: &mut Ui, bar: Rect) -> f32 {
     const W: f32 = 46.0;
     let t = Tokens::get(ui.ctx());
     let max = ui.input(|i| i.viewport().maximized.unwrap_or(false));
@@ -223,7 +602,11 @@ fn window_buttons(ui: &mut Ui, bar: Rect) -> f32 {
         }
         icons::paint(ui.painter(), Rect::from_center_size(r.center(), vec2(14.0, 14.0)), icon, col);
         if resp.clicked() {
-            ui.ctx().send_viewport_cmd(cmd);
+            if close {
+                crate::windows::request_close(app, ui.ctx());
+            } else {
+                ui.ctx().send_viewport_cmd(cmd);
+            }
         }
     }
     W * 3.0
@@ -260,3 +643,66 @@ pub fn resize_edges(ctx: &egui::Context) {
         }
     });
 }
+
+#[cfg(test)]
+mod layout_tests {
+    use super::{MIN_TAB_WIDTH, OPEN_TIME, OVERFLOW_WIDTH, TabMotion, open_progress, present_room, tab_drop_position, tab_layout};
+    use egui::{Rect, pos2};
+
+    #[test]
+    fn many_presentation_tabs_stay_inside_their_share_of_the_strip() {
+        let preferred = vec![260.0; 8];
+        let room = 900.0;
+        let layout = tab_layout(&preferred, present_room(room, &preferred, true), Some(7));
+        assert!(layout.overflow);
+        assert!(layout.first <= 7 && 7 < layout.first + layout.widths.len());
+        assert!(layout.widths.iter().all(|&width| width >= MIN_TAB_WIDTH));
+        assert!(layout.widths.iter().sum::<f32>() + OVERFLOW_WIDTH <= room / 2.0 + 0.01);
+        assert_eq!(present_room(room, &preferred, false), room);
+        assert_eq!(present_room(room, &[200.0], true), 200.0);
+    }
+
+    #[test]
+    fn tabs_shrink_to_fit_before_overflowing() {
+        let preferred = vec![120.0; 10];
+        let layout = tab_layout(&preferred, 1100.0, Some(5));
+        assert!(!layout.overflow);
+        assert_eq!(layout.first, 0);
+        assert_eq!(layout.widths.len(), preferred.len());
+        assert!(layout.widths.iter().all(|&width| (width - 110.0).abs() < 0.01));
+    }
+
+    #[test]
+    fn excess_tabs_leave_room_for_overflow_and_keep_the_active_tab_visible() {
+        let preferred = vec![120.0; 24];
+        let available = 1100.0;
+        let layout = tab_layout(&preferred, available, Some(23));
+        assert!(layout.overflow);
+        assert!(layout.first <= 23 && 23 < layout.first + layout.widths.len());
+        assert!(layout.widths.iter().all(|&width| width >= MIN_TAB_WIDTH));
+        assert!(layout.widths.iter().sum::<f32>() + OVERFLOW_WIDTH <= available + 0.01);
+    }
+
+    #[test]
+    fn drop_position_places_a_tab_between_its_neighbors() {
+        let visible = (0..4)
+            .map(|index| (index, Rect::from_min_max(pos2(index as f32 * 120.0, 0.0), pos2((index + 1) as f32 * 120.0, 40.0))))
+            .collect::<Vec<_>>();
+        assert_eq!(tab_drop_position(&visible, 0, 330.0).map(|(to, _)| to), Some(2));
+        assert_eq!(tab_drop_position(&visible, 3, 30.0).map(|(to, _)| to), Some(0));
+    }
+
+    #[test]
+    fn new_tabs_animate_unless_motion_is_reduced() {
+        let mut motion = TabMotion::default();
+        motion.begin_frame([1].into_iter(), 0.0, false);
+        assert!(motion.opening.is_empty(), "the tabs open at start-up don't animate");
+        motion.begin_frame([1, 2].into_iter(), 1.0, false);
+        assert_eq!(open_progress(&motion.opening, 2, 1.0), 0.0);
+        assert_eq!(open_progress(&motion.opening, 1, 1.0), 1.0);
+        motion.begin_frame([1, 2].into_iter(), 1.0 + 2.0 * OPEN_TIME, false);
+        assert!(motion.opening.is_empty(), "the animation ends");
+        motion.begin_frame([1, 2, 3].into_iter(), 2.0, true);
+        assert!(motion.opening.is_empty(), "Reduce motion opens tabs at once");
+    }
+}
diff --git a/crates/ui-egui/src/theme.rs b/crates/ui-egui/src/theme.rs
index 080bce43d..611371cec 100644
--- a/crates/ui-egui/src/theme.rs
+++ b/crates/ui-egui/src/theme.rs
@@ -1,6 +1,6 @@
 //! Design tokens (UI3 light and dark) and fonts.
 
-use std::sync::Arc;
+use std::sync::{Arc, OnceLock};
 
 use egui::{Color32, Context, FontData, FontDefinitions, FontFamily, FontId, Stroke, TextStyle, Visuals};
 
@@ -14,6 +14,8 @@ pub struct Tokens {
     pub border_strong: Color32,
     pub text: Color32,
     pub text_secondary: Color32,
+    /// Dim text: disabled controls, placeholders, hints. At least 3:1 against the panels, fields
+    /// and selected rows, yet dimmer than `text_secondary`.
     pub text_tertiary: Color32,
     pub icon: Color32,
     pub icon_secondary: Color32,
@@ -23,6 +25,7 @@ pub struct Tokens {
     pub field_hover_border: Color32,
     pub accent: Color32,
     pub accent_hover: Color32,
+    pub accent_on: Color32,
     pub accent_text: Color32,
     pub selected_row: Color32,
     pub selected_row_child: Color32,
@@ -44,11 +47,42 @@ pub struct Tokens {
     pub focus: Color32,
 }
 
-pub const ACCENT: Color32 = Color32::from_rgb(0x0D, 0x99, 0xFF);
+/// FigCraft's brand green for solid surfaces.
+pub const BRAND: Color32 = Color32::from_rgb(0x02, 0xDA, 0x96);
+/// Contrast-safe green for thin selection outlines and white-on-green labels.
+/// It reaches 4.5:1 on white and 3:1 on the dark canvas.
+pub const ACCENT: Color32 = Color32::from_rgb(0x00, 0x87, 0x5F);
+/// Ink on the bright green brand surface (white would not have enough contrast).
+pub const ACCENT_ON: Color32 = Color32::from_rgb(0x07, 0x35, 0x2A);
+/// Id of the canvas overlays' green for this frame ([`set_canvas_page`]).
+const CANVAS_ACCENT: &str = "figcraft-canvas-accent";
+
+/// Remember the page colour the canvas shows. Its overlays (outlines, handles, arrows) take
+/// whichever green contrasts more with it: the bright one on a dark page, the darker on a light one.
+pub fn set_canvas_page(ctx: &Context, page: Color32) {
+    let pick = if c(BRAND).contrast(c(page)) > c(ACCENT).contrast(c(page)) { BRAND } else { ACCENT };
+    ctx.data_mut(|d| d.insert_temp(egui::Id::new(CANVAS_ACCENT), pick));
+}
+
+/// `x` (opaque) as a document colour, for its contrast with another.
+fn c(x: Color32) -> figcraft_color::Color {
+    figcraft_color::Color::new(f32::from(x.r()) / 255.0, f32::from(x.g()) / 255.0, f32::from(x.b()) / 255.0, 1.0)
+}
+
+/// The green for overlays drawn on the page ([`set_canvas_page`]); [`ACCENT`] before a page shows.
+pub fn canvas_accent(ctx: &Context) -> Color32 {
+    ctx.data(|d| d.get_temp(egui::Id::new(CANVAS_ACCENT))).unwrap_or(ACCENT)
+}
+
+/// A fill under white text: the darker green stands in for the bright one.
+pub fn under_white(c: Color32) -> Color32 {
+    if c == BRAND { ACCENT } else { c }
+}
+
 pub const COMPONENT: Color32 = Color32::from_rgb(0x97, 0x47, 0xFF);
 /// Handoff status badges (white text on these, in both themes).
-pub const DEV_READY: Color32 = Color32::from_rgb(0x14, 0xAE, 0x5C);
-pub const DEV_CHANGED: Color32 = Color32::from_rgb(0xD9, 0x7A, 0x06);
+pub const DEV_READY: Color32 = Color32::from_rgb(0x08, 0x7D, 0x4F);
+pub const DEV_CHANGED: Color32 = Color32::from_rgb(0xA7, 0x5B, 0x00);
 pub const DEV_COMPLETED: Color32 = Color32::from_rgb(0x6E, 0x6E, 0x73);
 
 impl Tokens {
@@ -63,23 +97,24 @@ impl Tokens {
             text: Color32::from_rgb(0x1E, 0x1E, 0x1E),
             // 4.7:1 on fields and hovered rows (#F5F5F5), 4.6:1 on selected rows: WCAG AA.
             text_secondary: Color32::from_rgb(0x6E, 0x6E, 0x6E),
-            text_tertiary: Color32::from_rgb(0xB3, 0xB3, 0xB3),
+            text_tertiary: Color32::from_rgb(0x8A, 0x8A, 0x8A),
             icon: Color32::from_rgb(0x1E, 0x1E, 0x1E),
             icon_secondary: Color32::from_rgb(0x75, 0x75, 0x75),
             hover: Color32::from_rgb(0xF5, 0xF5, 0xF5),
             pressed: Color32::from_rgb(0xE6, 0xE6, 0xE6),
             field: Color32::from_rgb(0xF5, 0xF5, 0xF5),
             field_hover_border: Color32::from_rgb(0xE6, 0xE6, 0xE6),
-            accent: ACCENT,
-            accent_hover: Color32::from_rgb(0x00, 0x7B, 0xE5),
-            // 5.2:1 on white, 4.6:1 on selected rows: WCAG AA for text.
-            accent_text: Color32::from_rgb(0x00, 0x6B, 0xD1),
-            selected_row: Color32::from_rgb(0xE5, 0xF4, 0xFF),
-            selected_row_child: Color32::from_rgb(0xF2, 0xF9, 0xFF),
+            accent: BRAND,
+            accent_hover: Color32::from_rgb(0x00, 0xAD, 0x78),
+            accent_on: ACCENT_ON,
+            // Darker green keeps links and labels legible on white and selected rows.
+            accent_text: Color32::from_rgb(0x00, 0x7A, 0x56),
+            selected_row: Color32::from_rgb(0xE0, 0xFB, 0xF1),
+            selected_row_child: Color32::from_rgb(0xF1, 0xFC, 0xF7),
             component: COMPONENT,
             component_row: Color32::from_rgb(0xF1, 0xE9, 0xFF),
             danger: Color32::from_rgb(0xF2, 0x48, 0x22),
-            success: Color32::from_rgb(0x14, 0xAE, 0x5C),
+            success: DEV_READY,
             warning: Color32::from_rgb(0xFF, 0xCD, 0x29),
             guide: Color32::from_rgb(0xF2, 0x48, 0x22),
             tab_bar: Color32::from_rgb(0xE8, 0xE8, 0xE8),
@@ -89,7 +124,7 @@ impl Tokens {
             menu_text: Color32::from_rgb(0xFF, 0xFF, 0xFF),
             menu_hover: ACCENT,
             menu_dim: Color32::from_rgb(0x9A, 0x9A, 0x9A),
-            focus: Color32::from_rgb(0x00, 0x6B, 0xD1),
+            focus: Color32::from_rgb(0x00, 0x7A, 0x56),
         }
     }
 
@@ -103,22 +138,23 @@ impl Tokens {
             border_strong: Color32::from_rgb(0x55, 0x55, 0x55),
             text: Color32::from_rgb(0xFF, 0xFF, 0xFF),
             text_secondary: Color32::from_rgb(0xB3, 0xB3, 0xB3),
-            text_tertiary: Color32::from_rgb(0x75, 0x75, 0x75),
+            text_tertiary: Color32::from_rgb(0x88, 0x88, 0x88),
             icon: Color32::from_rgb(0xF5, 0xF5, 0xF5),
             icon_secondary: Color32::from_rgb(0xB3, 0xB3, 0xB3),
             hover: Color32::from_rgb(0x38, 0x38, 0x38),
             pressed: Color32::from_rgb(0x44, 0x44, 0x44),
             field: Color32::from_rgb(0x38, 0x38, 0x38),
             field_hover_border: Color32::from_rgb(0x4D, 0x4D, 0x4D),
-            accent: ACCENT,
-            accent_hover: Color32::from_rgb(0x3D, 0xAD, 0xFF),
-            accent_text: Color32::from_rgb(0x7C, 0xC4, 0xF8),
-            selected_row: Color32::from_rgb(0x2A, 0x45, 0x5C),
-            selected_row_child: Color32::from_rgb(0x2D, 0x37, 0x41),
+            accent: BRAND,
+            accent_hover: Color32::from_rgb(0x52, 0xE9, 0xB7),
+            accent_on: ACCENT_ON,
+            accent_text: Color32::from_rgb(0x52, 0xE9, 0xB7),
+            selected_row: Color32::from_rgb(0x16, 0x42, 0x36),
+            selected_row_child: Color32::from_rgb(0x12, 0x37, 0x2D),
             component: Color32::from_rgb(0xD2, 0x7C, 0xFF),
             component_row: Color32::from_rgb(0x3E, 0x30, 0x52),
             danger: Color32::from_rgb(0xF2, 0x48, 0x22),
-            success: Color32::from_rgb(0x14, 0xAE, 0x5C),
+            success: DEV_READY,
             warning: Color32::from_rgb(0xFF, 0xCD, 0x29),
             guide: Color32::from_rgb(0xF2, 0x48, 0x22),
             tab_bar: Color32::from_rgb(0x1E, 0x1E, 0x1E),
@@ -128,7 +164,7 @@ impl Tokens {
             menu_text: Color32::from_rgb(0xFF, 0xFF, 0xFF),
             menu_hover: ACCENT,
             menu_dim: Color32::from_rgb(0x9A, 0x9A, 0x9A),
-            focus: ACCENT,
+            focus: BRAND,
         }
     }
 
@@ -186,7 +222,9 @@ fn visuals(t: Tokens) -> Visuals {
     v.window_corner_radius = egui::CornerRadius::same(13);
     v.menu_corner_radius = egui::CornerRadius::same(13);
     v.selection.bg_fill = t.accent.gamma_multiply(0.3);
-    v.selection.stroke = Stroke::new(1.0, t.accent);
+    // Also the colour of selected text on that highlight (and a focused text box's outline): the
+    // theme's readable green, not the darker one that sinks into the dark theme's highlight.
+    v.selection.stroke = Stroke::new(1.0, t.accent_text);
     v.hyperlink_color = t.accent_text;
     for w in [&mut v.widgets.inactive, &mut v.widgets.hovered, &mut v.widgets.active, &mut v.widgets.open, &mut v.widgets.noninteractive] {
         w.corner_radius = egui::CornerRadius::same(5);
@@ -202,10 +240,10 @@ fn visuals(t: Tokens) -> Visuals {
     v.widgets.hovered.bg_stroke = Stroke::new(1.0, t.field_hover_border);
     v.widgets.active.bg_fill = t.pressed;
     v.widgets.active.weak_bg_fill = t.pressed;
-    v.widgets.active.bg_stroke = Stroke::new(1.0, t.accent);
+    v.widgets.active.bg_stroke = Stroke::new(1.0, ACCENT);
     v.popup_shadow = egui::Shadow { offset: [0, 4], blur: 16, spread: 0, color: t.shadow };
     v.window_shadow = egui::Shadow { offset: [0, 8], blur: 24, spread: 0, color: t.shadow };
-    v.text_cursor.stroke = Stroke::new(1.0, t.accent);
+    v.text_cursor.stroke = Stroke::new(1.0, ACCENT);
     v
 }
 
@@ -226,7 +264,8 @@ pub fn on_dark<R>(ui: &mut egui::Ui, f: impl FnOnce(&mut egui::Ui) -> R) -> R {
     r
 }
 
-/// UI fonts: Inter (from the craft-fonts build input) when present, else egui's defaults; with
+/// UI fonts: Inter and the Archivo wordmark (from the craft-fonts build input) when present;
+/// otherwise egui's defaults. With
 /// `system`, also system faces for scripts those lack (Hebrew, joined Arabic) so names in them show,
 /// and faces for the CJK scripts in `cjk` ([`crate::cjk`]).
 pub fn install_fonts(ctx: &Context, system: bool, cjk: u8) {
@@ -252,8 +291,20 @@ pub fn install_fonts(ctx: &Context, system: bool, cjk: u8) {
     }
     semi.extend(fonts.families.get(&FontFamily::Proportional).cloned().unwrap_or_default());
     fonts.families.insert(FontFamily::Name("semibold".into()), semi);
+    // Keep the logo's typeface independent of UI text. System Archivo is used when available;
+    // releases with craft-fonts embed it so the wordmark does not depend on installation.
+    let archivo = find("Archivo", "SemiBold").map(FontData::from_static).or_else(|| {
+        system.then(|| figcraft_text::find_face("Archivo", "SemiBold")).flatten().filter(|face| face.family == "Archivo").map(|face| font_data(&face))
+    });
+    let mut brand = Vec::new();
+    if let Some(data) = archivo {
+        fonts.font_data.insert("archivo".into(), Arc::new(data));
+        brand.push("archivo".into());
+    }
+    brand.extend(fonts.families.get(&FontFamily::Name("semibold".into())).cloned().unwrap_or_default());
+    fonts.families.insert(FontFamily::Name("brand".into()), brand);
     // CJK and other scripts from craft-fonts as fallbacks (Noto Sans CJK only with FIGCRAFT_EMBED_CJK).
-    const BUILT_IN: [&str; 4] = ["Inter", "BIZ UDPGothic", "Noto Sans CJK SC", "Noto Sans Arabic"];
+    const BUILT_IN: [&str; 5] = ["Inter", "BIZ UDPGothic", "Noto Sans CJK SC", "Noto Sans Arabic", "Noto Sans Georgian"];
     let lang = crate::i18n::current().map_or("en", |l| l.code);
     // A Chinese UI draws Han in a Chinese face: the built-in Japanese one goes after the system faces.
     let late = |family: &str| family == "BIZ UDPGothic" && crate::cjk::language(lang) == crate::cjk::HAN;
@@ -273,7 +324,9 @@ pub fn install_fonts(ctx: &Context, system: bool, cjk: u8) {
                 .filter_map(|f| figcraft_text::find_face(f, "Regular"))
                 .any(|x| x.has_char(c))
         };
-        extra.extend(crate::bidi::script_fallbacks(&embedded));
+        let mut taken = Vec::new();
+        extra.extend(crate::bidi::script_fallbacks(&embedded, &mut taken));
+        extra.extend(key_symbol_fallbacks(&embedded, &mut taken));
         extra.extend(crate::cjk::faces(cjk, lang, &embedded).iter().map(|f| (format!("system-{}-{}", f.family, f.style), font_data(f))));
     }
     extra.extend(craft(true));
@@ -288,6 +341,38 @@ pub fn install_fonts(ctx: &Context, system: bool, cjk: u8) {
     ctx.set_fonts(fonts);
 }
 
+/// The glyphs macOS shortcuts are written with ([`figcraft_engine::keymap::display`]).
+const KEY_SYMBOLS: &str = "⌃⌥⇧⌘⌫↵⇥⇞⇟←→↑↓";
+/// System families that have them, in order of preference.
+const KEY_FAMILIES: [&str; 6] = ["Lucida Grande", "Apple Symbols", "Segoe UI Symbol", "DejaVu Sans", "Noto Sans Symbols 2", "FreeSans"];
+
+/// System faces for the shortcut glyphs the UI's own fonts lack (egui's default face has ⌘ but
+/// not ⌥ or ↵); `taken` as for [`system_fallbacks`].
+fn key_symbol_fallbacks(have: &dyn Fn(char) -> bool, taken: &mut Vec<Arc<figcraft_text::Face>>) -> Vec<(String, FontData)> {
+    system_fallbacks(KEY_SYMBOLS.chars(), &KEY_FAMILIES, have, taken)
+}
+
+/// System faces, the first of `families` that has each, for the `samples` neither the UI's own
+/// fonts (`have`) nor the faces already `taken` draw. Each face found joins `taken`, so a face that
+/// several lists name is added once.
+pub(crate) fn system_fallbacks(
+    samples: impl IntoIterator<Item = char>,
+    families: &[&str],
+    have: &dyn Fn(char) -> bool,
+    taken: &mut Vec<Arc<figcraft_text::Face>>,
+) -> Vec<(String, FontData)> {
+    let mut out = Vec::new();
+    for c in samples {
+        if have(c) || taken.iter().any(|f| f.has_char(c)) {
+            continue;
+        }
+        let Some(face) = figcraft_text::face_with_char(c, families) else { continue };
+        out.push((format!("system-{}-{}", face.family, face.style), font_data(&face)));
+        taken.push(face);
+    }
+    out
+}
+
 /// egui font data over a face's bytes, without copying them (CJK faces are 10–20 MB). Font
 /// database faces are never dropped, so a system face's shared bytes are kept for good: leaking
 /// one more reference to them costs a pointer and gives egui the `'static` slice it needs.
@@ -305,6 +390,40 @@ pub fn semibold(size: f32) -> FontId {
     FontId::new(size, FontFamily::Name("semibold".into()))
 }
 
+pub fn brand(size: f32) -> FontId {
+    FontId::new(size, FontFamily::Name("brand".into()))
+}
+
+/// The two-tone Archivo wordmark used in the home sidebar and About window.
+pub fn paint_wordmark(painter: &egui::Painter, left_center: egui::Pos2, size: f32, t: &Tokens) {
+    let font = brand(size);
+    let fig = painter.layout_no_wrap("Fig".into(), font.clone(), t.text);
+    let fig_width = fig.size().x;
+    painter.galley(egui::pos2(left_center.x, left_center.y - fig.size().y / 2.0), fig, t.text);
+    painter.text(egui::pos2(left_center.x + fig_width, left_center.y), egui::Align2::LEFT_CENTER, "Craft", font, t.accent_text);
+}
+
+/// Paint the owner's original chameleon icon from the existing app asset.
+pub fn paint_app_icon(ui: &egui::Ui, rect: egui::Rect) {
+    static ICON: OnceLock<Option<egui::ColorImage>> = OnceLock::new();
+    let image = ICON.get_or_init(|| {
+        let rgba = image::load_from_memory(include_bytes!("../../../assets/app-icon/figcraft-64.png")).ok()?.to_rgba8();
+        Some(egui::ColorImage::from_rgba_unmultiplied([rgba.width() as usize, rgba.height() as usize], rgba.as_raw()))
+    });
+    let Some(image) = image else {
+        ui.painter().rect_filled(rect, egui::CornerRadius::same(5), BRAND);
+        crate::icons::paint(ui.painter(), rect.shrink(rect.width() * 0.22), crate::icons::Icon::Logo, ACCENT_ON);
+        return;
+    };
+    let id = egui::Id::new("figcraft_original_app_icon");
+    let texture = ui.ctx().data(|data| data.get_temp::<egui::TextureHandle>(id)).unwrap_or_else(|| {
+        let texture = ui.ctx().load_texture("figcraft-original-app-icon", image.clone(), egui::TextureOptions::LINEAR);
+        ui.ctx().data_mut(|data| data.insert_temp(id, texture.clone()));
+        texture
+    });
+    ui.painter().image(texture.id(), rect, egui::Rect::from_min_max(egui::pos2(0.0, 0.0), egui::pos2(1.0, 1.0)), Color32::WHITE);
+}
+
 pub fn regular(size: f32) -> FontId {
     FontId::new(size, FontFamily::Proportional)
 }
@@ -331,3 +450,73 @@ pub fn doc_c32(ctx: &Context, c: figcraft_color::Color) -> Color32 {
     let conv = ctx.data(|d| d.get_temp::<figcraft_color::ProfileConversion>(screen_conversion_id()));
     c32(conv.map_or(c, |k| k.apply(c)))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn canvas_overlays_take_the_green_that_stands_out_on_the_page() {
+        let ctx = Context::default();
+        assert_eq!(canvas_accent(&ctx), ACCENT, "before any page shows");
+        set_canvas_page(&ctx, Color32::from_rgb(0x1E, 0x1E, 0x1E));
+        assert_eq!(canvas_accent(&ctx), BRAND, "the bright green on a dark page");
+        set_canvas_page(&ctx, Color32::WHITE);
+        assert_eq!(canvas_accent(&ctx), ACCENT, "the darker green on a light page");
+        set_canvas_page(&ctx, Color32::from_rgb(0xF5, 0xF5, 0xF5));
+        assert_eq!(canvas_accent(&ctx), ACCENT);
+        // White text never sits on the bright green.
+        assert_eq!(under_white(BRAND), ACCENT);
+        assert_eq!(under_white(COMPONENT), COMPONENT);
+    }
+
+    /// `fill` (premultiplied, maybe translucent) painted over the opaque `bg`.
+    fn over(fill: Color32, bg: Color32) -> Color32 {
+        let k = 1.0 - f32::from(fill.a()) / 255.0;
+        let mix = |f: u8, b: u8| (f32::from(f) + f32::from(b) * k).round().min(255.0) as u8;
+        Color32::from_rgb(mix(fill.r(), bg.r()), mix(fill.g(), bg.g()), mix(fill.b(), bg.b()))
+    }
+
+    #[test]
+    fn disabled_and_selected_text_stay_readable_in_both_themes() {
+        for t in [Tokens::light(), Tokens::dark()] {
+            let theme = if t.dark { "dark" } else { "light" };
+            // Disabled text (a disabled button's label, placeholders) on panels, fields and
+            // selected rows, still dimmer than secondary text.
+            for bg in [t.panel, t.field, t.hover, t.selected_row] {
+                let ratio = c(t.text_tertiary).contrast(c(bg));
+                assert!(ratio >= 3.0, "{theme}: dim text {:?} on {bg:?} is {ratio:.2}:1", t.text_tertiary);
+                assert!(ratio < c(t.text_secondary).contrast(c(bg)), "{theme}: dim text reads dimmer than secondary text");
+            }
+            // Selected text (renaming a page or layer, any text box) on the selection highlight.
+            let v = visuals(t);
+            for bg in [t.panel, t.field] {
+                let highlight = over(v.selection.bg_fill, bg);
+                let ratio = c(v.selection.stroke.color).contrast(c(highlight));
+                assert!(ratio >= 3.0, "{theme}: selected text on {highlight:?} is {ratio:.2}:1");
+            }
+        }
+    }
+
+    #[test]
+    fn ui_font_draws_every_mac_shortcut_glyph() {
+        figcraft_text::scan_system_fonts();
+        let lacking: String = KEY_SYMBOLS.chars().filter(|c| figcraft_text::face_with_char(*c, &KEY_FAMILIES).is_none()).collect();
+        if !lacking.is_empty() {
+            eprintln!("no system face here draws {lacking}; skipping");
+            return;
+        }
+        let ctx = Context::default();
+        install_fonts(&ctx, true, 0);
+        let input =
+            egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::pos2(0.0, 0.0), egui::vec2(100.0, 100.0))), ..Default::default() };
+        ctx.run_ui(input, |_| {}).textures_delta.clear();
+        ctx.fonts_mut(|f| {
+            for c in KEY_SYMBOLS.chars() {
+                for font in [regular(11.0), semibold(11.0)] {
+                    assert!(f.has_glyphs(&font, &c.to_string()), "UI font draws {c:?}");
+                }
+            }
+        });
+    }
+}
diff --git a/crates/ui-egui/src/titlebar_tests.rs b/crates/ui-egui/src/titlebar_tests.rs
index 796cb6700..9f1916c17 100644
--- a/crates/ui-egui/src/titlebar_tests.rs
+++ b/crates/ui-egui/src/titlebar_tests.rs
@@ -4,6 +4,7 @@
 
 use egui::{Event, PointerButton, Pos2, RawInput, Rect, ResizeDirection, ViewportCommand, ViewportId, pos2, vec2};
 use figcraft_engine::Session;
+use serde_json::json;
 
 use crate::{FigApp, NoServices, TitleBar};
 
@@ -76,7 +77,23 @@ fn window_buttons_minimise_maximise_and_close() {
     let mut u = Ui::new(TitleBar::Custom);
     assert!(u.click(window_button(0)).contains(&ViewportCommand::Minimized(true)));
     assert!(u.click(window_button(1)).contains(&ViewportCommand::Maximized(true)));
-    assert!(u.click(window_button(2)).contains(&ViewportCommand::Close));
+    u.click(window_button(2));
+    assert!(u.frame(vec![]).contains(&ViewportCommand::Close));
+}
+
+#[test]
+fn titlebar_close_asks_over_the_presenter_when_a_file_is_unsaved() {
+    let mut u = Ui::new(TitleBar::Custom);
+    let frame = u.app.session.execute("node.create", &json!({"type": "frame", "width": 402, "height": 874})).unwrap()["id"].clone();
+    u.app.session.execute("proto.present", &json!({"start": frame})).unwrap();
+    u.app.handle_ui_requests();
+    u.frame(vec![]);
+    assert!(u.app.ui.present.is_some());
+
+    let commands = u.click(window_button(2));
+    assert!(!commands.contains(&ViewportCommand::Close));
+    assert!(u.app.ui.confirm_close);
+    assert!(u.ctx.memory(|memory| memory.area_rect(egui::Id::new(Some(crate::i18n::tr("Unsaved changes")))).is_some()));
 }
 
 #[test]
@@ -141,6 +158,81 @@ fn tabs_and_new_tab_keep_their_clicks() {
     assert!(opened, "the new-tab button took no click");
 }
 
+#[test]
+fn many_tabs_do_not_cover_the_window_buttons() {
+    let mut u = Ui::new(TitleBar::Custom);
+    for _ in 0..24 {
+        u.app.session.execute("file.new", &json!({})).unwrap();
+    }
+    u.frame(vec![]);
+    let before = u.app.session.docs.len();
+    u.click(pos2(SIZE.x - 222.0, 20.0));
+    assert_eq!(u.app.session.docs.len(), before + 1, "the new-tab button must stay reachable");
+    assert!(u.click(window_button(0)).contains(&ViewportCommand::Minimized(true)));
+    assert!(u.click(window_button(1)).contains(&ViewportCommand::Maximized(true)));
+    u.click(window_button(2));
+    assert!(u.frame(vec![]).contains(&ViewportCommand::Close));
+}
+
+#[test]
+fn close_button_on_inactive_tab_closes_it_without_switching() {
+    let mut u = Ui::new(TitleBar::Custom);
+    u.app.session.execute("file.new", &json!({})).unwrap();
+    u.app.session.execute("file.new", &json!({})).unwrap();
+    let active_uid = u.app.session.docs[u.app.session.active].uid;
+    let inactive_uid = u.app.session.docs[1].uid;
+    let close_button = pos2(270.0, 20.0);
+    u.frame(vec![Event::PointerMoved(close_button)]);
+    u.click(close_button);
+    assert!(
+        !u.app.session.docs.iter().any(|doc| doc.uid == inactive_uid),
+        "docs={}, active={}, last_error={:?}, target_dirty={}",
+        u.app.session.docs.len(),
+        u.app.session.active,
+        u.app.ui.last_error,
+        u.app.session.docs.iter().find(|doc| doc.uid == inactive_uid).is_some_and(|doc| doc.is_dirty())
+    );
+    assert_eq!(u.app.session.docs[u.app.session.active].uid, active_uid);
+}
+
+#[test]
+fn closing_a_tab_before_the_active_one_keeps_the_active_file() {
+    let mut u = Ui::new(TitleBar::Custom);
+    for _ in 0..3 {
+        u.app.session.execute("file.new", &json!({})).unwrap();
+    }
+    u.app.session.execute("doc.switch", &json!({"index": 2})).unwrap();
+    let active_uid = u.app.session.docs[u.app.session.active].uid;
+    let closed_uid = u.app.session.docs[0].uid;
+    let close_button = pos2(156.0, 20.0);
+    u.frame(vec![Event::PointerMoved(close_button)]);
+    u.click(close_button);
+    assert!(!u.app.session.docs.iter().any(|doc| doc.uid == closed_uid));
+    assert_eq!(u.app.session.docs[u.app.session.active].uid, active_uid);
+}
+
+#[test]
+fn dragging_a_tab_along_the_bar_reorders_it_without_detaching() {
+    let mut u = Ui::new(TitleBar::Custom);
+    for name in ["Two", "Three", "Four"] {
+        u.app.session.execute("file.new", &json!({"name": name})).unwrap();
+    }
+    let moved_uid = u.app.session.docs[0].uid;
+    let active_uid = u.app.session.docs[u.app.session.active].uid;
+    u.frame(vec![]);
+    let commands = u.drag(pos2(100.0, 20.0), vec2(310.0, 0.0));
+    assert!(!commands.contains(&ViewportCommand::StartDrag), "{commands:?}");
+    assert_eq!(
+        u.app.session.docs[2].uid,
+        moved_uid,
+        "order={:?}, active={}, error={:?}",
+        u.app.session.docs.iter().map(|d| d.uid).collect::<Vec<_>>(),
+        u.app.session.active,
+        u.app.ui.last_error
+    );
+    assert_eq!(u.app.session.docs[u.app.session.active].uid, active_uid);
+}
+
 #[test]
 fn a_system_title_bar_leaves_the_window_alone() {
     let mut u = Ui::new(TitleBar::Native);
diff --git a/crates/ui-egui/src/toolbar.rs b/crates/ui-egui/src/toolbar.rs
index a921cc293..b95575b87 100644
--- a/crates/ui-egui/src/toolbar.rs
+++ b/crates/ui-egui/src/toolbar.rs
@@ -9,30 +9,54 @@ use crate::FigApp;
 use crate::a11y::{self, Nav, Region, Tip};
 use crate::i18n::{tr, tr_noop, trf};
 use crate::icons::{self, Icon};
-use crate::theme::{ACCENT, Tokens, regular};
+use crate::theme::{Tokens, regular};
+
+/// Every mark in the toolbar row is painted in a box this size, so they share one optical size
+/// and one stroke width (#737, #738).
+const GLYPH: f32 = 18.0;
+/// The flyout carets: smaller than the marks, but on a box whose stroke rounds to the same width
+/// as theirs at 1×, 1.5× and 2× (a 10-point box drew them one physical pixel thinner).
+const CARET: f32 = 14.0;
+
+/// `GLYPH`'s box centred in `r`.
+fn glyph_rect(r: Rect) -> Rect {
+    Rect::from_center_size(r.center(), vec2(GLYPH, GLYPH))
+}
 
 struct Group {
     key: &'static str,
     /// The flyout button's name for screen readers.
     name: &'static str,
     tools: &'static [(ToolId, Icon)],
+    /// What a one-tool group's flyout offers instead of tools (boards: colours, shapes, stamps).
+    options: Options,
+}
+
+/// The choices a board tool's flyout shows.
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub(crate) enum Options {
+    None,
+    Colors,
+    Shapes,
+    Stamps,
+}
+
+impl Group {
+    const fn tools(key: &'static str, name: &'static str, tools: &'static [(ToolId, Icon)]) -> Group {
+        Group { key, name, tools, options: Options::None }
+    }
+    fn has_flyout(&self) -> bool {
+        self.tools.len() > 1 || self.options != Options::None
+    }
 }
 
 const GROUPS: &[Group] = &[
-    Group {
-        key: "move",
-        name: tr_noop("Move tools"),
-        tools: &[(ToolId::Move, Icon::Move), (ToolId::Hand, Icon::Hand), (ToolId::Scale, Icon::Scale)],
-    },
-    Group {
-        key: "frame",
-        name: tr_noop("Frame tools"),
-        tools: &[(ToolId::Frame, Icon::Frame), (ToolId::Section, Icon::Section), (ToolId::Slice, Icon::Slice)],
-    },
-    Group {
-        key: "shape",
-        name: tr_noop("Shape tools"),
-        tools: &[
+    Group::tools("move", tr_noop("Move tools"), &[(ToolId::Move, Icon::Move), (ToolId::Hand, Icon::Hand), (ToolId::Scale, Icon::Scale)]),
+    Group::tools("frame", tr_noop("Frame tools"), &[(ToolId::Frame, Icon::Frame), (ToolId::Section, Icon::Section), (ToolId::Slice, Icon::Slice)]),
+    Group::tools(
+        "shape",
+        tr_noop("Shape tools"),
+        &[
             (ToolId::Rectangle, Icon::Rectangle),
             (ToolId::Line, Icon::Line),
             (ToolId::Arrow, Icon::Arrow),
@@ -40,14 +64,31 @@ const GROUPS: &[Group] = &[
             (ToolId::Polygon, Icon::Polygon),
             (ToolId::Star, Icon::Star),
         ],
-    },
-    Group {
-        key: "pen",
-        name: tr_noop("Drawing tools"),
-        tools: &[(ToolId::Pen, Icon::Pen), (ToolId::Pencil, Icon::Pencil), (ToolId::ShapeBuilder, Icon::ShapeBuilder)],
-    },
-    Group { key: "text", name: tr_noop("Text"), tools: &[(ToolId::Text, Icon::Text)] },
-    Group { key: "comment", name: tr_noop("Comment"), tools: &[(ToolId::Comment, Icon::Comment)] },
+    ),
+    Group::tools(
+        "pen",
+        tr_noop("Drawing tools"),
+        &[(ToolId::Pen, Icon::Pen), (ToolId::Pencil, Icon::Pencil), (ToolId::ShapeBuilder, Icon::ShapeBuilder)],
+    ),
+    Group::tools("text", tr_noop("Text"), &[(ToolId::Text, Icon::Text)]),
+    Group::tools("comment", tr_noop("Comment"), &[(ToolId::Comment, Icon::Comment)]),
+];
+
+/// A board's toolbar: moving around, ink, stickies, shapes, connectors, text, sections, stamps.
+const BOARD_GROUPS: &[Group] = &[
+    Group::tools("bmove", tr_noop("Move tools"), &[(ToolId::Move, Icon::Move), (ToolId::Hand, Icon::Hand)]),
+    Group::tools(
+        "ink",
+        tr_noop("Drawing tools"),
+        &[(ToolId::Marker, Icon::Marker), (ToolId::Highlighter, Icon::Highlighter), (ToolId::Eraser, Icon::Eraser)],
+    ),
+    Group { key: "sticky", name: tr_noop("Sticky note colors"), tools: &[(ToolId::Sticky, Icon::Board)], options: Options::Colors },
+    Group { key: "bshape", name: tr_noop("Shapes"), tools: &[(ToolId::BoardShape, Icon::Shapes)], options: Options::Shapes },
+    Group::tools("connector", tr_noop("Connector"), &[(ToolId::Connector, Icon::Connector)]),
+    Group::tools("text", tr_noop("Text"), &[(ToolId::Text, Icon::Text)]),
+    Group::tools("section", tr_noop("Section"), &[(ToolId::Section, Icon::Section)]),
+    Group { key: "stamp", name: tr_noop("Stamps"), tools: &[(ToolId::Stamp, Icon::Stamp)], options: Options::Stamps },
+    Group::tools("comment", tr_noop("Comment"), &[(ToolId::Comment, Icon::Comment)]),
 ];
 
 fn remembered(ui: &Ui, key: &str, default: ToolId) -> ToolId {
@@ -57,6 +98,7 @@ fn remembered(ui: &Ui, key: &str, default: ToolId) -> ToolId {
 pub fn show(app: &mut FigApp, ui: &mut Ui) {
     let t = Tokens::get(ui.ctx());
     let canvas = app.canvas.rect;
+    app.ui.actions_rect = None;
     // A file you can't edit now (view only, or on its way to a server): moving around only.
     if let Some(why) = app.session.active_read_only() {
         view_only_toolbar(app, ui, why);
@@ -72,80 +114,146 @@ pub fn show(app: &mut FigApp, ui: &mut Ui) {
         builder_toolbar(app, ui);
         return;
     }
-    let cell = 32.0;
-    let gap = 4.0;
-    let width = GROUPS.len() as f32 * (cell + 4.0) + 4.0 * 10.0 + 2.0 * (cell + 4.0) + 16.0 + 4.0 * 34.0 + 24.0;
-    let rect = pill(ui, &mut app.ui.nav, canvas, width, &t);
-    let current = app.session.tool.tool;
-    let mut x = rect.min.x + 8.0;
+    let board = app.session.doc().is_ok_and(figcraft_engine::board::is_board);
+    main_toolbar(app, ui, canvas, &t, board);
+}
+
+/// The main toolbar pill's width for the active file: the Actions palette matches it so the two
+/// read as one bar.
+pub(crate) fn bar_width(app: &FigApp) -> f32 {
+    let board = app.session.doc().is_ok_and(figcraft_engine::board::is_board);
+    main_width(if board { BOARD_GROUPS } else { GROUPS }, board)
+}
+
+/// The main toolbar pill's width: the tool groups with their flyout carets, Resources and
+/// Actions, and the mode switcher (boards: the Design panel's button instead).
+fn main_width(groups: &[Group], board: bool) -> f32 {
+    let (cell, gap) = (TOOL_CELL, 4.0);
+    let carets = groups.iter().filter(|g| g.has_flyout()).count() as f32 * 10.0;
+    let end = if board { cell + 16.0 } else { 4.0 * 34.0 + 24.0 };
+    groups.len() as f32 * (cell + gap) + carets + 2.0 * (cell + gap) + 16.0 + end
+}
+
+/// The main toolbar pill: the tool groups with their flyouts, Resources and Actions, then the
+/// Draw · Design · Prototype · Inspect mode switcher (on a board, the Design panel's button).
+fn main_toolbar(app: &mut FigApp, ui: &mut Ui, canvas: Rect, t: &Tokens, board: bool) {
+    let groups = if board { BOARD_GROUPS } else { GROUPS };
+    let rect = pill(ui, &mut app.ui.nav, canvas, main_width(groups, board), t);
     let cy = rect.center().y;
-    for g in GROUPS {
-        let in_group = g.tools.iter().any(|(tid, _)| *tid == current);
-        let shown = if in_group { current } else { remembered(ui, g.key, g.tools.first().map(|x| x.0).unwrap_or(ToolId::Move)) };
-        let icon = g.tools.iter().find(|(tid, _)| *tid == shown).map(|(_, i)| *i).unwrap_or(Icon::Move);
-        let r = Rect::from_center_size(pos2(x + cell / 2.0, cy), vec2(cell, cell));
-        let resp = tool_cell(ui, &t, r, ("tool", g.key), icon, in_group, &format!("{}  {}", tr(shown.label()), pretty_shortcut(shown.shortcut())));
-        if in_group {
-            a11y::prefer(&mut app.ui.nav, Region::Toolbar, resp.id);
+    let mut x = rect.min.x + 8.0;
+    for g in groups {
+        x = group_cell(app, ui, g, pos2(x, cy), rect.min.y, t);
+    }
+    x = side_buttons(app, ui, x, cy, t);
+    divider(ui, t, x, cy);
+    x += 8.0;
+    if board {
+        // Boards have no prototypes or Dev Mode; the Design panel is hidden until asked for.
+        let r = Rect::from_center_size(pos2(x + TOOL_CELL / 2.0, cy), vec2(TOOL_CELL, TOOL_CELL));
+        let tip = crate::shortcuts::tip(tr("Design panel"), "view.design");
+        if tool_cell(ui, t, r, "board_panel", Icon::Panels, app.ui.board_panel, tip).clicked() {
+            app.run("view.design", json!({}));
         }
-        if resp.clicked() {
-            // Enter (a keyboard click) on the shape or frame tool already chosen places one; the
-            // canvas takes the keyboard.
-            if in_group && shown.draws_shape() && ui.input(|i| i.key_pressed(egui::Key::Enter)) {
-                app.run("tool.place", json!({}));
-                app.ui.nav.go(Region::Canvas);
-            } else {
-                app.run("tool.set", json!({"tool": shown.id()}));
-            }
-        }
-        x += cell;
-        // Flyout chevron.
-        if g.tools.len() > 1 {
-            let cr = Rect::from_center_size(pos2(x + 5.0, cy), vec2(10.0, cell));
-            let cresp = ui.interact(cr, ui.id().with(("flyout", g.key)), Sense::click());
-            let open = app.ui.tool_flyout == Some(g.key);
-            a11y::menu_button(&cresp, tr(g.name), open);
-            if open {
-                a11y::popup(&mut app.ui.nav, cresp.id, flyout_id(g.key));
-            }
-            if cresp.hovered() {
-                ui.painter().rect_filled(cr, CornerRadius::same(4), t.hover);
-            }
-            icons::paint(ui.painter(), Rect::from_center_size(cr.center(), vec2(10.0, 10.0)), Icon::Chevron, t.icon_secondary);
-            if cresp.clicked() {
-                app.ui.tool_flyout = if app.ui.tool_flyout == Some(g.key) { None } else { Some(g.key) };
-            }
-            x += 10.0;
-        }
-        x += gap;
-        if app.ui.tool_flyout == Some(g.key) {
-            flyout(app, ui, g, pos2(r.min.x, rect.min.y - 8.0));
+    } else {
+        mode_switcher(app, ui, x, cy, t);
+    }
+    help_button(app, ui, canvas, t);
+}
+
+/// A toolbar button's size.
+const TOOL_CELL: f32 = 32.0;
+
+/// Tool group `g` at `at` (its left edge, the pill's middle): the shown tool's button, its flyout
+/// caret and, while open, its flyout above the pill (whose top is `top`). Where the next starts.
+fn group_cell(app: &mut FigApp, ui: &mut Ui, g: &Group, at: egui::Pos2, top: f32, t: &Tokens) -> f32 {
+    let current = app.session.tool.tool;
+    let in_group = g.tools.iter().any(|(tid, _)| *tid == current);
+    let shown = if in_group { current } else { remembered(ui, g.key, g.tools.first().map(|x| x.0).unwrap_or(ToolId::Move)) };
+    let icon = g.tools.iter().find(|(tid, _)| *tid == shown).map(|(_, i)| *i).unwrap_or(Icon::Move);
+    let r = Rect::from_center_size(pos2(at.x + TOOL_CELL / 2.0, at.y), vec2(TOOL_CELL, TOOL_CELL));
+    let resp = tool_cell(ui, t, r, ("tool", g.key), icon, in_group, &format!("{}  {}", tr(shown.label()), pretty_shortcut(shown.shortcut())));
+    if in_group {
+        a11y::prefer(&mut app.ui.nav, Region::Toolbar, resp.id);
+    }
+    if resp.clicked() {
+        // Enter (a keyboard click) on the shape or frame tool already chosen places one; the
+        // canvas takes the keyboard.
+        // In Dev Mode the tool goes through `choose`, which returns to the design first.
+        if in_group && shown.draws_shape() && app.ui.right_tab != crate::RightTab::Inspect && ui.input(|i| i.key_pressed(egui::Key::Enter)) {
+            app.run("tool.place", json!({}));
+            app.ui.nav.go(Region::Canvas);
+        } else {
+            choose(app, shown);
         }
     }
-    // Resources (components, plugins) opens the Assets panel; Actions palette.
+    let mut x = at.x + TOOL_CELL;
+    if g.has_flyout() {
+        flyout_caret(app, ui, g, pos2(x, at.y), t);
+        x += 10.0;
+    }
+    if app.ui.tool_flyout == Some(g.key) {
+        if g.options == Options::None {
+            flyout(app, ui, g, pos2(r.min.x, top - 8.0));
+        } else {
+            options_flyout(app, ui, g, pos2(r.min.x, top - 8.0));
+        }
+    }
+    x + 4.0
+}
+
+/// The caret after group `g`'s button (at `at`, its left edge and middle): opens or closes its
+/// flyout.
+fn flyout_caret(app: &mut FigApp, ui: &mut Ui, g: &Group, at: egui::Pos2, t: &Tokens) {
+    let cr = Rect::from_center_size(pos2(at.x + 5.0, at.y), vec2(10.0, TOOL_CELL));
+    let cresp = ui.interact(cr, ui.id().with(("flyout", g.key)), Sense::click());
+    let open = app.ui.tool_flyout == Some(g.key);
+    a11y::menu_button(&cresp, tr(g.name), open);
+    if open {
+        a11y::popup(&mut app.ui.nav, cresp.id, flyout_id(g.key));
+    }
+    if cresp.hovered() {
+        ui.painter().rect_filled(cr, CornerRadius::same(4), t.hover);
+    }
+    icons::paint(ui.painter(), Rect::from_center_size(cr.center(), vec2(CARET, CARET)), Icon::Chevron, t.icon_secondary);
+    if cresp.clicked() {
+        app.ui.tool_flyout = if open { None } else { Some(g.key) };
+    }
+}
+
+/// Resources (components, plugins: the Assets panel) and the Actions palette's button, from `x`.
+/// Where the next part starts.
+fn side_buttons(app: &mut FigApp, ui: &mut Ui, mut x: f32, cy: f32, t: &Tokens) -> f32 {
     for (icon, tip, id) in [
         (Icon::Assets, crate::shortcuts::key_tip(tr("Resources"), "Shift+I"), "resources"),
         (Icon::Actions, crate::shortcuts::tip(tr("Actions"), "app.actions"), "actions"),
     ] {
-        let r = Rect::from_center_size(pos2(x + cell / 2.0, cy), vec2(cell, cell));
+        let r = Rect::from_center_size(pos2(x + TOOL_CELL / 2.0, cy), vec2(TOOL_CELL, TOOL_CELL));
         let resp = ui.interact(r, ui.id().with(id), Sense::click()).tip(tip);
-        if resp.hovered() {
+        if id == "actions" {
+            app.ui.actions_rect = Some(r);
+        }
+        // The Actions button reads on while its panel is open; clicking it again closes it.
+        let actions_open = id == "actions" && app.ui.palette.is_some();
+        if actions_open {
+            ui.painter().rect_filled(r, CornerRadius::same(5), t.accent);
+        } else if resp.hovered() {
             ui.painter().rect_filled(r, CornerRadius::same(5), t.hover);
         }
-        icons::paint(ui.painter(), r.shrink(7.0), icon, t.icon);
+        icons::paint(ui.painter(), glyph_rect(r), icon, if actions_open { t.accent_on } else { t.icon });
         if resp.clicked() {
             if id == "actions" {
-                app.ui.palette = Some(String::new());
+                crate::menus::toggle_palette(&mut app.ui);
             } else {
-                app.ui.left_tab = crate::LeftTab::Assets;
-                app.ui.left_collapsed = false;
+                app.run("view.assets", json!({}));
             }
         }
-        x += cell + 4.0;
+        x += TOOL_CELL + 4.0;
     }
-    divider(ui, &t, x, cy);
-    x += 8.0;
-    // Mode switcher: Draw · Design · Prototype · Inspect (code).
+    x
+}
+
+/// The mode switcher from `x`: Draw · Design · Prototype · Inspect (code).
+fn mode_switcher(app: &mut FigApp, ui: &mut Ui, x: f32, cy: f32, t: &Tokens) {
     let modes = [(Icon::Pencil, tr("Draw")), (Icon::Frame, tr("Design")), (Icon::Prototype, tr("Prototype")), (Icon::Code, tr("Inspect"))];
     let active = match app.ui.right_tab {
         crate::RightTab::Design if app.session.tool.tool == ToolId::Pencil => 0,
@@ -165,25 +273,33 @@ pub fn show(app: &mut FigApp, ui: &mut Ui) {
         } else if resp.hovered() {
             ui.painter().rect_filled(r, CornerRadius::same(6), t.hover);
         }
-        icons::paint(ui.painter(), r.shrink(9.0), *icon, if i == active { t.accent_text } else { t.icon_secondary });
+        icons::paint(ui.painter(), glyph_rect(r), *icon, if i == active { t.accent_text } else { t.icon_secondary });
         if resp.clicked() {
-            match i {
-                0 => {
-                    app.ui.right_tab = crate::RightTab::Design;
-                    app.run("tool.set", json!({"tool": "pencil"}));
-                }
-                1 => {
-                    app.ui.right_tab = crate::RightTab::Design;
-                    if app.session.tool.tool == ToolId::Pencil {
-                        app.run("tool.set", json!({"tool": "move"}));
-                    }
-                }
-                2 => app.ui.right_tab = crate::RightTab::Prototype,
-                _ => app.ui.right_tab = crate::RightTab::Inspect,
-            }
+            pick_mode(app, i);
         }
     }
-    // Floating help button at the bottom right of the canvas.
+}
+
+/// Mode `i` of the switcher chosen.
+fn pick_mode(app: &mut FigApp, i: usize) {
+    match i {
+        0 => {
+            app.ui.right_tab = crate::RightTab::Design;
+            app.run("tool.set", json!({"tool": "pencil"}));
+        }
+        1 => {
+            app.ui.right_tab = crate::RightTab::Design;
+            if app.session.tool.tool == ToolId::Pencil {
+                app.run("tool.set", json!({"tool": "move"}));
+            }
+        }
+        2 => app.ui.right_tab = crate::RightTab::Prototype,
+        _ => app.ui.right_tab = crate::RightTab::Inspect,
+    }
+}
+
+/// The floating help button at the bottom right of the canvas.
+fn help_button(app: &mut FigApp, ui: &mut Ui, canvas: Rect, t: &Tokens) {
     let hr = Rect::from_center_size(pos2(canvas.max.x - 32.0, canvas.max.y - 32.0), vec2(32.0, 32.0));
     let hresp = ui.interact(hr, ui.id().with("help"), Sense::click()).tip(tr("Help and resources"));
     ui.painter().circle_filled(hr.center() + vec2(0.0, 1.0), 17.0, Color32::from_black_alpha(20));
@@ -325,10 +441,15 @@ fn builder_toolbar(app: &mut FigApp, ui: &mut Ui) {
     }
 }
 
+/// Where a toolbar pill `width` wide sits: centred 12 px above the canvas's bottom edge.
+pub(crate) fn pill_rect(canvas: Rect, width: f32) -> Rect {
+    Rect::from_center_size(pos2(canvas.center().x, canvas.max.y - 12.0 - 24.0), vec2(width, 48.0))
+}
+
 /// The floating pill (shadow, panel, border) `width` wide at the bottom centre of the canvas: the
 /// toolbar region keyboard navigation moves through.
 fn pill(ui: &Ui, nav: &mut Nav, canvas: Rect, width: f32, t: &Tokens) -> Rect {
-    let rect = Rect::from_center_size(pos2(canvas.center().x, canvas.max.y - 12.0 - 24.0), vec2(width, 48.0));
+    let rect = pill_rect(canvas, width);
     // The pill takes the press and the drag over it: its buttons sense clicks only, and egui gives
     // a drag the canvas under them would sense to the canvas, so the pen placed an anchor there.
     // Not focusable: the keyboard walks the buttons, not the pill.
@@ -345,20 +466,20 @@ fn pill(ui: &Ui, nav: &mut Nav, canvas: Rect, width: f32, t: &Tokens) -> Rect {
 }
 
 /// A square tool button: accent when active, tinted on hover; `tip` is its tooltip and name.
-fn tool_cell(ui: &mut Ui, t: &Tokens, r: Rect, id: impl egui::AsIdSalt, icon: Icon, active: bool, tip: &str) -> egui::Response {
+pub(crate) fn tool_cell(ui: &mut Ui, t: &Tokens, r: Rect, id: impl egui::AsIdSalt, icon: Icon, active: bool, tip: &str) -> egui::Response {
     let resp = ui.interact(r, ui.id().with(id), Sense::click()).on_hover_ui(|ui| {
         ui.label(tip);
     });
     a11y::toggle(&resp, tip, active);
     let bg = if active {
-        ACCENT
+        t.accent
     } else if resp.hovered() {
         t.hover
     } else {
         Color32::TRANSPARENT
     };
     ui.painter().rect_filled(r, CornerRadius::same(5), bg);
-    icons::paint(ui.painter(), r.shrink(7.0), icon, if active { Color32::WHITE } else { t.icon });
+    icons::paint(ui.painter(), glyph_rect(r), icon, if active { t.accent_on } else { t.icon });
     resp
 }
 
@@ -374,11 +495,46 @@ fn done_button(ui: &mut Ui, t: &Tokens, x: f32, cy: f32, tip: &str) -> bool {
     divider(ui, t, x, cy);
     let done = Rect::from_min_size(pos2(x + 12.0, cy - 14.0), vec2(DONE_W, 28.0));
     let resp = ui.interact(done, ui.id().with("tool_done"), Sense::click()).tip(tip);
-    ui.painter().rect_filled(done, CornerRadius::same(6), if resp.hovered() { t.accent_hover } else { ACCENT });
-    ui.painter().text(done.center(), Align2::CENTER_CENTER, tr("Done"), crate::theme::semibold(11.5), Color32::WHITE);
+    ui.painter().rect_filled(done, CornerRadius::same(6), if resp.hovered() { t.accent_hover } else { t.accent });
+    ui.painter().text(done.center(), Align2::CENTER_CENTER, tr("Done"), crate::theme::semibold(11.5), t.accent_on);
     resp.clicked()
 }
 
+/// A board tool's flyout: the colours, shapes or stamps it places, in a row. A pick chooses the
+/// tool with it.
+fn options_flyout(app: &mut FigApp, ui: &mut Ui, g: &Group, bottom_left: egui::Pos2) {
+    let t = Tokens::get(ui.ctx());
+    let Some(&(tool, _)) = g.tools.first() else { return };
+    let items = crate::board_bar::choices(g.options, &app.session.tool.board);
+    let (cell, pad) = (32.0, 8.0);
+    let size = vec2(items.len() as f32 * (cell + 4.0) - 4.0 + 2.0 * pad, cell + 2.0 * pad);
+    let mut chosen = None;
+    egui::Area::new(flyout_id(g.key)).fixed_pos(pos2(bottom_left.x, bottom_left.y - size.y)).order(egui::Order::Foreground).show(ui.ctx(), |ui| {
+        let (rect, _) = ui.allocate_exact_size(size, Sense::hover());
+        ui.painter().rect_filled(rect, CornerRadius::same(13), t.menu);
+        for (i, c) in items.iter().enumerate() {
+            let r = Rect::from_min_size(pos2(rect.min.x + pad + i as f32 * (cell + 4.0), rect.min.y + pad), vec2(cell, cell));
+            let resp = ui.interact(r, ui.id().with(("opt", g.key, i)), Sense::click()).on_hover_text(tr(c.label));
+            a11y::menu_item(&resp, tr(c.label), "", Some(c.on));
+            a11y::own_focus(&resp);
+            if c.on || resp.hovered() || resp.has_focus() {
+                ui.painter().rect_filled(r, CornerRadius::same(5), t.menu_hover);
+            }
+            crate::board_bar::paint_choice(ui.painter(), r.shrink(5.0), &c.mark, t.menu_text);
+            if resp.clicked() {
+                chosen = Some(c.params.clone());
+            }
+        }
+    });
+    if ui.input(|i| i.key_pressed(egui::Key::Escape)) {
+        app.ui.tool_flyout = None;
+    }
+    if let Some(params) = chosen {
+        app.run(&format!("tool.{}", tool.id()), params);
+        app.ui.tool_flyout = None;
+    }
+}
+
 fn flyout(app: &mut FigApp, ui: &mut Ui, g: &Group, bottom_left: egui::Pos2) {
     let t = Tokens::get(ui.ctx());
     let item_h = 32.0;
@@ -417,11 +573,20 @@ fn flyout(app: &mut FigApp, ui: &mut Ui, g: &Group, bottom_left: egui::Pos2) {
         if let Some(i) = ToolId::ALL.iter().position(|x| *x == tid) {
             ui.data_mut(|d| d.insert_temp(egui::Id::new(("tb_last", g.key)), i as u8));
         }
-        app.run("tool.set", json!({"tool": tid.id()}));
+        choose(app, tid);
         app.ui.tool_flyout = None;
     }
 }
 
+/// Choose `tool` from the toolbar. Dev Mode only inspects: a tool that edits leaves it for the
+/// design.
+fn choose(app: &mut FigApp, tool: ToolId) {
+    if app.ui.right_tab == crate::RightTab::Inspect && !matches!(tool, ToolId::Move | ToolId::Hand | ToolId::Comment) {
+        app.ui.right_tab = crate::RightTab::Design;
+    }
+    app.run("tool.set", json!({"tool": tool.id()}));
+}
+
 /// A tool group's flyout (an egui area).
 fn flyout_id(key: &str) -> egui::Id {
     egui::Id::new(("flyout_area", key))
@@ -431,3 +596,52 @@ fn flyout_id(key: &str) -> egui::Id {
 pub fn pretty_shortcut(s: &str) -> String {
     figcraft_engine::keymap::display(s, crate::shortcuts::platform())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use egui::Shape;
+
+    /// The stroke widths `icon` paints with in a `size` box at `ppp` pixels per point.
+    fn widths(ppp: f32, icon: Icon, size: f32) -> Vec<f32> {
+        let ctx = egui::Context::default();
+        let input = || {
+            let mut i = egui::RawInput::default();
+            i.viewports.entry(egui::ViewportId::ROOT).or_default().native_pixels_per_point = Some(ppp);
+            i
+        };
+        ctx.run_ui(input(), |_| {}).textures_delta.clear();
+        let mut out =
+            ctx.run_ui(input(), |ui| icons::paint(ui.painter(), Rect::from_center_size(pos2(50.0, 50.0), vec2(size, size)), icon, Color32::WHITE));
+        out.textures_delta.clear();
+        assert_eq!(ctx.pixels_per_point(), ppp);
+        let mut w: Vec<f32> = out
+            .shapes
+            .iter()
+            .filter_map(|c| match &c.shape {
+                Shape::LineSegment { stroke, .. } => Some(stroke.width),
+                Shape::Path(p) => Some(p.stroke.width),
+                Shape::Rect(r) => Some(r.stroke.width),
+                _ => None,
+            })
+            .filter(|w| *w > 0.0)
+            .collect();
+        w.dedup();
+        w
+    }
+
+    /// The flyout carets and the marks beside them draw with one stroke width (#737), and the
+    /// mode switcher's marks are the tool marks' size (#738).
+    #[test]
+    fn toolbar_marks_share_one_stroke_width() {
+        for ppp in [1.0, 1.5, 2.0] {
+            let mark = widths(ppp, Icon::Rectangle, GLYPH);
+            assert_eq!(mark.len(), 1, "one width at {ppp}×: {mark:?}");
+            assert_eq!(widths(ppp, Icon::Chevron, CARET), mark, "caret at {ppp}×");
+            assert_eq!(widths(ppp, Icon::Code, GLYPH), mark, "mode mark at {ppp}×");
+            for icon in [Icon::Frame, Icon::Text] {
+                assert_eq!(widths(ppp, icon, GLYPH), mark, "{icon:?} at {ppp}×");
+            }
+        }
+    }
+}
diff --git a/crates/ui-egui/src/type_settings_tests.rs b/crates/ui-egui/src/type_settings_tests.rs
new file mode 100644
index 000000000..675abfa08
--- /dev/null
+++ b/crates/ui-egui/src/type_settings_tests.rs
@@ -0,0 +1,29 @@
+//! Regression for #1029: a Type settings row whose label is wider than its column (French "Retrait
+//! de paragraphe") stays inside the popover, which otherwise widened a little every frame.
+use egui::{Area, Id, Pos2, RawInput, Rect, vec2};
+
+#[test]
+fn a_long_label_does_not_widen_the_type_settings_popover() {
+    let ctx = egui::Context::default();
+    crate::theme::install_fonts(&ctx, false, 0);
+    let id = Id::new("ty_row_test");
+    let mut widths = Vec::new();
+    for i in 0..30 {
+        let raw =
+            RawInput { screen_rect: Some(Rect::from_min_size(Pos2::ZERO, vec2(1200.0, 900.0))), time: Some(i as f64 / 60.0), ..Default::default() };
+        ctx.run_ui(raw, |ui| {
+            // As `egui::Popup::width` shows it: a default width the area grows past to fit.
+            Area::new(id).fixed_pos(Pos2::ZERO).default_width(264.0).show(ui.ctx(), |ui| {
+                for label in ["List spacing", "Retrait de paragraphe, plus long que la colonne"] {
+                    crate::typography::field_row(ui, label, |ui, fw| ui.allocate_exact_size(vec2(fw, 20.0), egui::Sense::hover()));
+                }
+            });
+        })
+        .textures_delta
+        .clear();
+        widths.push(ctx.memory(|m| m.area_rect(id)).expect("the area is shown").width());
+    }
+    let (first, last) = (widths[1], widths[widths.len() - 1]);
+    assert!((last - first).abs() < 0.01, "the row widens the popover every frame: {first} → {last}");
+    assert!((last - 264.0).abs() < 0.01, "{last}");
+}
diff --git a/crates/ui-egui/src/typography.rs b/crates/ui-egui/src/typography.rs
index 78552dcb9..eefe7c9b1 100644
--- a/crates/ui-egui/src/typography.rs
+++ b/crates/ui-egui/src/typography.rs
@@ -186,9 +186,10 @@ fn font_rows(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId], styles: &[TextStyle]
                 remember_family(ui.ctx(), &f);
                 apply_style(app, "fontFamily", json!(f));
                 ui.close();
-            } else if let Some(f) = pick.highlighted {
-                // The canvas shows the family the arrow keys are on.
-                app.preview_text(ui.ctx(), "text.style", text_style_params(ids, range, json!({"fontFamily": f})));
+            } else if let Some(h) = pick.hovered.or(pick.highlighted) {
+                // The canvas shows the hovered family (or the one the arrow keys are on);
+                // closing without picking ends the preview.
+                app.preview_text(ui.ctx(), "text.style", text_style_params(ids, range, json!({"fontFamily": h})));
             }
         });
     });
@@ -467,17 +468,15 @@ fn type_settings(
         // Indent applies to start-aligned text only; elsewhere the field stays visible but off.
         let start_aligned =
             common(doc, ids, |n| n.kind.text().map(|t| t.align_h != TextAlignH::Center && t.align_h != TextAlignH::Justified)).flatten();
-        ui.horizontal(|ui| {
-            ui.add_enabled_ui(start_aligned != Some(false), |ui| {
-                ui.add_sized(vec2(110.0, FIELD_H), egui::Label::new(egui::RichText::new(tr("Paragraph indent")).font(regular(11.0)).color(t.text)));
-                let field = widgets::number_field(ui, Id::new("ty_indent"), Lead::None, indent, "", w - 118.0, 1.0);
-                if let Some(FieldEdit::Set(v) | FieldEdit::Scrub(v, true)) = field {
-                    app.set_props(ids, json!({"paragraphIndent": v.clamp(0.0, 10_000.0)}));
-                }
-            })
-            .response
-            .on_disabled_hover_text(tr("Paragraph indent applies to left-aligned text"));
-        });
+        ui.add_enabled_ui(start_aligned != Some(false), |ui| {
+            let field =
+                field_row(ui, tr("Paragraph indent"), |ui, fw| widgets::number_field(ui, Id::new("ty_indent"), Lead::None, indent, "", fw, 1.0));
+            if let Some(FieldEdit::Set(v) | FieldEdit::Scrub(v, true)) = field {
+                app.set_props(ids, json!({"paragraphIndent": v.clamp(0.0, 10_000.0)}));
+            }
+        })
+        .response
+        .on_disabled_hover_text(tr("Paragraph indent applies to left-aligned text"));
         ui.add_space(4.0);
         for (key, label) in [("hangingPunctuation", tr("Hanging punctuation")), ("hangingList", tr("Hanging list"))] {
             let all_on = ids.iter().all(|i| {
@@ -507,16 +506,13 @@ fn type_settings(
         if resize == Some(TextAutoResize::Truncate) {
             let max = common(doc, ids, |n| n.kind.text().map(|t| t.max_lines)).flatten();
             ui.add_space(4.0);
-            ui.horizontal(|ui| {
-                ui.add_sized(vec2(110.0, FIELD_H), egui::Label::new(egui::RichText::new(tr("Max lines")).font(regular(11.0)).color(t.text)));
-                let shown = max.map(f64::from).filter(|m| *m > 0.0);
-                let empty = if max.is_some() { tr("Auto") } else { tr(MIXED) };
-                if let Some(FieldEdit::Set(v) | FieldEdit::Scrub(v, true)) =
-                    widgets::number_field_or(ui, Id::new("ty_maxlines"), shown, empty, w - 118.0, 1.0)
-                {
-                    app.run("text.maxLines", json!({"ids": ids, "lines": v.round().clamp(0.0, 10_000.0)}));
-                }
-            });
+            let shown = max.map(f64::from).filter(|m| *m > 0.0);
+            let empty = if max.is_some() { tr("Auto") } else { tr(MIXED) };
+            if let Some(FieldEdit::Set(v) | FieldEdit::Scrub(v, true)) =
+                field_row(ui, tr("Max lines"), |ui, fw| widgets::number_field_or(ui, Id::new("ty_maxlines"), shown, empty, fw, 1.0))
+            {
+                app.run("text.maxLines", json!({"ids": ids, "lines": v.round().clamp(0.0, 10_000.0)}));
+            }
         }
     } else if let (2, Some(face)) = (tab, &vf) {
         variable_axes(app, ui, ids, styles, face);
@@ -541,13 +537,14 @@ fn type_settings(
     }
 }
 
-/// A Type settings row: a label, then `add` with the rest of the width.
-fn field_row<R>(ui: &mut Ui, label: &str, add: impl FnOnce(&mut Ui, f32) -> R) -> R {
+/// A Type settings row: a label, then `add` with the rest of the width. A label wider than its
+/// column (French, say) narrows the field rather than the row outgrowing the popover, which then
+/// widened every frame (#1029).
+pub(crate) fn field_row<R>(ui: &mut Ui, label: &str, add: impl FnOnce(&mut Ui, f32) -> R) -> R {
     let t = Tokens::get(ui.ctx());
-    let w = ui.available_width();
     ui.horizontal(|ui| {
         ui.add_sized(vec2(110.0, FIELD_H), egui::Label::new(egui::RichText::new(label).font(regular(11.0)).color(t.text)));
-        add(ui, w - 118.0)
+        add(ui, ui.available_width())
     })
     .inner
 }
@@ -586,7 +583,7 @@ fn decoration_details(app: &mut FigApp, ui: &mut Ui, styles: &[TextStyle], apply
             if !auto
                 && ui
                     .add(
-                        egui::Label::new(egui::RichText::new(tr("Auto")).font(regular(11.0)).color(Tokens::get(ui.ctx()).accent))
+                        egui::Label::new(egui::RichText::new(tr("Auto")).font(regular(11.0)).color(Tokens::get(ui.ctx()).accent_text))
                             .sense(Sense::click()),
                     )
                     .on_hover_text(tip)
@@ -712,7 +709,7 @@ fn variable_axes(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId], styles: &[TextSt
     }
     if styles.iter().any(|s| !s.variations.is_empty()) {
         ui.add_space(8.0);
-        let r = ui.add(egui::Label::new(egui::RichText::new(tr("Reset to style")).font(regular(11.0)).color(t.accent)).sense(Sense::click()));
+        let r = ui.add(egui::Label::new(egui::RichText::new(tr("Reset to style")).font(regular(11.0)).color(t.accent_text)).sense(Sense::click()));
         if r.on_hover_text(tr("Back to the values the font style implies")).clicked() {
             app.run("text.setVariations", json!({"ids": ids, "variations": {}, "replace": true}));
         }
@@ -788,7 +785,7 @@ fn axis_slider(ui: &mut Ui, id: Id, axis: &figcraft_text::Axis, value: Option<f6
         let x = x_of(v);
         p.rect_filled(Rect::from_min_max(track.min, pos2(x, track.max.y)), CornerRadius::same(2), t.accent);
         p.circle_filled(pos2(x, track.center().y), 6.0, Color32::WHITE);
-        let ring = if resp.hovered() || resp.dragged() { t.accent } else { t.border_strong };
+        let ring = if resp.hovered() || resp.dragged() { crate::theme::ACCENT } else { t.border_strong };
         p.circle_stroke(pos2(x, track.center().y), 6.0, Stroke::new(1.0, ring));
     }
     if resp.double_clicked() {
@@ -898,14 +895,14 @@ fn feature_row(ui: &mut Ui, tag: &str, label: &str, on: Option<bool>, supported:
     match on {
         Some(true) => {
             ui.painter().rect_filled(b, CornerRadius::same(3), t.accent);
-            icons::paint(ui.painter(), b.shrink(1.5), Icon::Check, Color32::WHITE);
+            icons::paint(ui.painter(), b.shrink(1.5), Icon::Check, t.accent_on);
         }
         Some(false) => {
             ui.painter().rect_stroke(b, CornerRadius::same(3), Stroke::new(1.0, t.border_strong), StrokeKind::Inside);
         }
         None => {
             ui.painter().rect_filled(b, CornerRadius::same(3), t.accent);
-            ui.painter().line_segment([pos2(b.min.x + 3.5, b.center().y), pos2(b.max.x - 3.5, b.center().y)], Stroke::new(1.5, Color32::WHITE));
+            ui.painter().line_segment([pos2(b.min.x + 3.5, b.center().y), pos2(b.max.x - 3.5, b.center().y)], Stroke::new(1.5, t.accent_on));
         }
     }
     let col = if supported { t.text } else { t.text_tertiary };
@@ -1024,7 +1021,7 @@ fn lead_field(ui: &mut Ui, id: Id, glyph: LeadGlyph, value: &str, width: f32, ti
     crate::a11y::text(&resp, tip, value);
     ui.painter().rect_filled(rect, CornerRadius::same(5), t.field);
     if editing.is_some() {
-        ui.painter().rect_stroke(rect, CornerRadius::same(5), Stroke::new(1.0, t.accent), StrokeKind::Inside);
+        ui.painter().rect_stroke(rect, CornerRadius::same(5), Stroke::new(1.0, crate::theme::ACCENT), StrokeKind::Inside);
     } else if resp.hovered() {
         ui.painter().rect_stroke(rect, CornerRadius::same(5), Stroke::new(1.0, t.field_hover_border), StrokeKind::Inside);
     }
@@ -1161,9 +1158,12 @@ pub(crate) struct FontPick {
     pub picked: Option<String>,
     /// The family Up and Down are on (Enter picks it).
     pub highlighted: Option<String>,
+    /// The family the pointer is over (the caller previews it on the canvas).
+    pub hovered: Option<String>,
 }
 
 /// The searchable family list: click a family, or step through it with Up and Down and press Enter.
+/// Hovering a family previews it on the canvas (closing without picking restores the original).
 pub(crate) fn font_picker(ui: &mut Ui, current: Option<&str>, just_opened: bool) -> FontPick {
     let t = Tokens::get(ui.ctx());
     let q_id = Id::new("font_query");
@@ -1248,10 +1248,11 @@ pub(crate) fn font_picker(ui: &mut Ui, current: Option<&str>, just_opened: bool)
             PickRow::Family(f) => Some(f.clone()),
             PickRow::Header(_) => None,
         });
-        return FontPick { picked: hi.and_then(family).or(first), highlighted: None };
+        return FontPick { picked: hi.and_then(family).or(first), highlighted: None, hovered: None };
     }
     let mut budget = 4;
     let mut picked = None;
+    let mut hovered_family = None;
     let mut area = egui::ScrollArea::vertical().max_height(LIST_HEIGHT).auto_shrink([false, true]);
     if let Some(y) = offset {
         area = area.vertical_scroll_offset(y);
@@ -1269,7 +1270,7 @@ pub(crate) fn font_picker(ui: &mut Ui, current: Option<&str>, just_opened: bool)
                     if hovered {
                         ui.painter().rect_filled(rect, CornerRadius::same(5), t.accent);
                     }
-                    let col = if hovered { Color32::WHITE } else { t.text };
+                    let col = if hovered { t.accent_on } else { t.text };
                     if current.is_some_and(|c| c.eq_ignore_ascii_case(f)) {
                         icons::paint(
                             ui.painter(),
@@ -1297,12 +1298,15 @@ pub(crate) fn font_picker(ui: &mut Ui, current: Option<&str>, just_opened: bool)
                     if resp.clicked() {
                         picked = Some(f.clone());
                     }
+                    if resp.hovered() {
+                        hovered_family = Some(f.clone());
+                    }
                 }
             }
         }
     });
     ui.data_mut(|d| d.insert_temp(hi_id.with("view"), (shown.state.offset.y, shown.inner_rect.height())));
-    FontPick { highlighted: hi.and_then(family), picked }
+    FontPick { highlighted: hi.and_then(family), picked, hovered: hovered_family }
 }
 
 #[cfg(test)]
diff --git a/crates/ui-egui/src/ui_scale.rs b/crates/ui-egui/src/ui_scale.rs
new file mode 100644
index 000000000..6b275a078
--- /dev/null
+++ b/crates/ui-egui/src/ui_scale.rs
@@ -0,0 +1,116 @@
+//! The interface size (Preferences ▸ Interface size, `pref.uiScale`): how the saved choice becomes
+//! egui's zoom factor.
+//!
+//! egui draws at `pixels_per_point = zoom factor × the system's scale`. The size is relative to the
+//! system's scale, so it is the zoom itself: 100 % is the system's own size on every screen (native
+//! on a Retina Mac too), 125 % a quarter larger. A size above 100 % is held back while the window is
+//! too small to lay the interface out at it; the saved choice never changes.
+
+/// The smallest window, in points, the interface is laid out for: the main window's minimum size.
+pub const FIT_POINTS: (f32, f32) = (800.0, 500.0);
+
+/// The zoom factors egui's own settings window allows.
+const ZOOM_RANGE: (f32, f32) = (0.1, 10.0);
+
+/// What to give egui for a saved choice on this screen and window.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Plan {
+    /// For `Context::set_zoom_factor`: the size drawn, relative to the system's scale.
+    pub zoom: f32,
+    /// Physical pixels per point once drawn (the zoom times the system's scale).
+    pub drawn: f32,
+    /// The window is too small for the size chosen, so a smaller one is drawn.
+    pub limited: bool,
+}
+
+/// The plan for `choice` (relative to the system's scale), the system's scale `native` and the
+/// window's size in physical pixels `window_px`. An unknown, zero or not finite value reads as no
+/// information: a size of 1, a system scale of 1 and a window of any size.
+pub fn plan(choice: f64, native: Option<f32>, window_px: Option<(f32, f32)>) -> Plan {
+    let native = native.filter(|n| n.is_finite() && *n > 0.0).unwrap_or(1.0);
+    let want = Some(choice as f32).filter(|c| c.is_finite() && *c > 0.0).unwrap_or(1.0);
+    // The largest zoom at which the window still holds the smallest layout.
+    let fit = window_px
+        .filter(|(w, h)| w.is_finite() && h.is_finite() && *w > 0.0 && *h > 0.0)
+        .map(|(w, h)| (w / FIT_POINTS.0).min(h / FIT_POINTS.1) / native);
+    // Never below 100 % (or the size asked, when that is smaller): a tiny window doesn't shrink the interface further.
+    let zoom = match fit {
+        Some(fit) if want > fit => fit.max(want.min(1.0)),
+        _ => want,
+    }
+    .clamp(ZOOM_RANGE.0, ZOOM_RANGE.1);
+    Plan { zoom, drawn: zoom * native, limited: zoom < want - 0.005 }
+}
+
+/// A size as the percentage Preferences shows (1.25 → 125).
+pub fn percent(scale: f32) -> u32 {
+    (scale * 100.0).round().clamp(0.0, 100_000.0) as u32
+}
+
+/// The sizes Preferences offers, relative to the system's scale (`pref.uiScale` takes up to 3).
+pub const SIZES: [f64; 8] = [0.75, 0.9, 1.0, 1.1, 1.25, 1.5, 1.75, 2.0];
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const BIG: Option<(f32, f32)> = Some((20000.0, 12000.0));
+
+    #[test]
+    fn a_size_is_relative_to_the_systems_scale_on_every_screen() {
+        // Windows 100/125/150/175 %, Retina 2×, a bare X11 window manager's guessed 2×, a 3× screen.
+        for native in [1.0, 1.25, 1.5, 1.75, 2.0, 3.0] {
+            let p = plan(1.0, Some(native), BIG);
+            assert_eq!((p.zoom, p.drawn, p.limited), (1.0, native, false), "100 % is the system's own size on {native}");
+            for size in SIZES {
+                let p = plan(size, Some(native), BIG);
+                assert!((p.zoom - size as f32).abs() < 1e-5, "{size} on {native}: zoom {}", p.zoom);
+                assert!((p.drawn - size as f32 * native).abs() < 1e-4, "{size} on {native}: drawn {}", p.drawn);
+                assert!(!p.limited, "{size} on {native}");
+            }
+        }
+    }
+
+    #[test]
+    fn a_missing_or_unusable_scale_reads_as_1_and_never_gives_egui_a_bad_zoom() {
+        for native in [None, Some(0.0), Some(-2.0), Some(f32::NAN), Some(f32::INFINITY)] {
+            for choice in [1.0, 1.5, f64::NAN, f64::INFINITY, -1.0, 0.0, 1e300] {
+                let p = plan(choice, native, Some((f32::NAN, 0.0)));
+                assert!(p.zoom.is_finite() && (ZOOM_RANGE.0..=ZOOM_RANGE.1).contains(&p.zoom), "{choice:?} {native:?}: {p:?}");
+                assert!(p.drawn.is_finite() && p.drawn > 0.0, "{choice:?} {native:?}: {p:?}");
+            }
+        }
+        // A choice that isn't a usable number is the system's own size.
+        assert_eq!(plan(f64::NAN, Some(2.0), BIG), plan(1.0, Some(2.0), BIG));
+    }
+
+    #[test]
+    fn a_small_window_holds_a_big_size_back_without_going_below_100() {
+        // The minimum window on a Retina Mac: 800 × 500 points is 1600 × 1000 pixels, which holds 100 % only.
+        let min = Some((1600.0, 1000.0));
+        let p = plan(1.5, Some(2.0), min);
+        assert_eq!((p.zoom, p.drawn, p.limited), (1.0, 2.0, true));
+        assert!(!plan(1.0, Some(2.0), min).limited);
+        // A larger window on a 1× screen: 1200 × 750 pixels hold 150 %.
+        let p = plan(2.0, Some(1.0), Some((1200.0, 750.0)));
+        assert_eq!((p.zoom, p.limited), (1.5, true));
+        // A window smaller than the minimum (a tiling window manager): never below 100 %, and never
+        // below a smaller size the person chose.
+        assert_eq!(plan(2.0, Some(1.0), Some((400.0, 250.0))).zoom, 1.0);
+        let p = plan(0.75, Some(1.0), Some((400.0, 250.0)));
+        assert_eq!((p.zoom, p.limited), (0.75, false));
+    }
+
+    #[test]
+    fn the_limit_does_not_depend_on_the_zoom_so_it_cannot_flicker() {
+        // The window's size in pixels is the same whatever zoom is drawn now, so the plan for it is too.
+        let px = Some((1700.0, 1100.0));
+        assert_eq!(plan(2.5, Some(2.0), px), plan(2.5, Some(2.0), px));
+    }
+
+    #[test]
+    fn percentages_round_like_the_menu_shows_them() {
+        assert_eq!([percent(0.75), percent(0.9), percent(1.1), percent(1.25), percent(2.0), percent(1.7999)], [75, 90, 110, 125, 200, 180]);
+        assert_eq!([percent(f32::NAN), percent(-1.0)], [0, 0]);
+    }
+}
diff --git a/crates/ui-egui/src/ui_scale_tests.rs b/crates/ui-egui/src/ui_scale_tests.rs
new file mode 100644
index 000000000..4f2a478b1
--- /dev/null
+++ b/crates/ui-egui/src/ui_scale_tests.rs
@@ -0,0 +1,223 @@
+//! The interface size, driven through egui headless on screens of different system scales: 100 %
+//! leaves the system's scale alone, another size is relative to it on every screen, and the
+//! Preferences drop-down tells a screen reader its name and value.
+//!
+//! The test window's size is fixed in points, so it grows with the zoom here; the limit for a small
+//! window is tested on its own in `ui_scale::tests`, and the sizes below stay inside it.
+
+use egui::accesskit::Role;
+use egui::{RawInput, ViewportId, ViewportInfo};
+use figcraft_engine::Session;
+use serde_json::json;
+
+use crate::layers_drag_tests::Ui;
+
+/// One frame on a screen whose system scale is `native` (a real window reports it every frame).
+fn frame_at(u: &mut Ui, native: f32) -> egui::FullOutput {
+    let mut raw = RawInput::default();
+    raw.viewports.insert(ViewportId::ROOT, ViewportInfo { native_pixels_per_point: Some(native), ..Default::default() });
+    u.frame_raw(raw)
+}
+
+/// Frames on that screen, enough for a new zoom to take effect.
+fn settle(u: &mut Ui, native: f32) {
+    for _ in 0..4 {
+        frame_at(u, native);
+    }
+}
+
+const SCREENS: [f32; 5] = [1.0, 1.25, 1.5, 2.0, 3.0];
+
+#[test]
+fn by_default_the_interface_is_the_systems_own_size() {
+    for native in SCREENS {
+        let mut u = Ui::new(Session::new());
+        settle(&mut u, native);
+        assert_eq!(u.ctx.zoom_factor(), 1.0, "{native}");
+        assert_eq!(u.ctx.pixels_per_point(), native, "{native}");
+    }
+}
+
+#[test]
+fn a_size_is_relative_to_the_systems_scale_on_every_screen_and_auto_is_100() {
+    for native in SCREENS {
+        let mut u = Ui::new(Session::new());
+        for size in [0.75_f64, 0.9, 1.25, 1.5] {
+            assert!(u.app.run("pref.uiScale", json!({"scale": size})).is_some());
+            settle(&mut u, native);
+            let drawn = u.ctx.pixels_per_point();
+            assert!((drawn - size as f32 * native).abs() < 1e-4, "{size} on a {native}× screen drew at {drawn}");
+            assert!((u.ctx.zoom_factor() - size as f32).abs() < 1e-5, "{size} on {native}");
+            assert!(!u.app.ui.ui_scale.limited, "{size} on {native}");
+        }
+        assert!(u.app.run("pref.uiScale", json!({"scale": "auto"})).is_some());
+        settle(&mut u, native);
+        assert_eq!((u.ctx.zoom_factor(), u.ctx.pixels_per_point()), (1.0, native), "{native}");
+    }
+}
+
+#[test]
+fn the_interface_size_menu_has_a_name_a_value_and_a_state_for_a_screen_reader() {
+    let mut u = Ui::new(Session::new());
+    u.app.ui.preferences = true;
+    u.ctx.enable_accesskit();
+    let combo = |u: &mut Ui| {
+        settle(u, 2.0);
+        let out = frame_at(u, 2.0);
+        let nodes: Vec<_> = out.platform_output.accesskit_update.expect("an AccessKit update").nodes.into_iter().map(|(_, n)| n).collect();
+        let n = nodes.iter().find(|n| n.role() == Role::ComboBox && n.label() == Some("Interface size")).expect("an Interface size menu");
+        (n.value().map(str::to_owned), n.is_expanded())
+    };
+    // 100 % is the system's own size, whatever it is (2× here).
+    assert_eq!(combo(&mut u), (Some("100%".to_owned()), Some(false)));
+    u.app.run("pref.uiScale", json!({"scale": 1.25}));
+    assert_eq!(combo(&mut u), (Some("125%".to_owned()), Some(false)));
+}
+
+/// Every window size, system scale and interface size, drawn the way a real window is: the window is
+/// a fixed number of physical pixels, and its size in points is that divided by the scale drawn now
+/// (egui-winit does the same each frame), so a bigger size shrinks the window in points.
+///
+/// What a fixed size promises: whatever it draws at above 100 %, the window still holds the smallest
+/// layout the interface is made for (`ui_scale::FIT_POINTS`), and the panels leave room for a canvas.
+#[test]
+fn every_window_size_system_scale_and_interface_size_lays_out_inside_the_window() {
+    use crate::ui_scale::{FIT_POINTS, SIZES};
+    use crate::{FigApp, NoServices};
+    use egui::{Pos2, Rect, vec2};
+
+    // Window sizes in points: the main window's minimum, common laptop and desktop screens up to 5K,
+    // and a short wide strip.
+    let windows: [(f32, f32); 10] = [
+        (800.0, 500.0),
+        (1024.0, 640.0),
+        (1280.0, 720.0),
+        (1366.0, 768.0),
+        (1440.0, 900.0),
+        (1920.0, 1080.0),
+        (2560.0, 1440.0),
+        (3840.0, 2160.0),
+        (5120.0, 2880.0),
+        (2560.0, 520.0),
+    ];
+
+    for native in [1.0_f32, 1.25, 1.5, 1.75, 2.0, 3.0] {
+        for (w, h) in windows {
+            let px = vec2(w * native, h * native);
+            for want in SIZES {
+                let case = format!("{w}x{h} pt at {native}x, {want}");
+                let mut app = FigApp::new(Session::new(), Box::new(NoServices));
+                assert!(app.run("pref.uiScale", json!({"scale": want})).is_some(), "{case}");
+                let ctx = egui::Context::default();
+                let mut time = 0.0;
+                let mut seen = Vec::new();
+                for _ in 0..8 {
+                    time += 1.0 / 60.0;
+                    let ppp = ctx.pixels_per_point();
+                    let mut raw = RawInput { screen_rect: Some(Rect::from_min_size(Pos2::ZERO, px / ppp)), time: Some(time), ..Default::default() };
+                    raw.viewports.insert(ViewportId::ROOT, ViewportInfo { native_pixels_per_point: Some(native), ..Default::default() });
+                    let mut out = ctx.run_ui(raw, |ui| app.ui(ui));
+                    out.textures_delta.clear();
+                    seen.push((ctx.pixels_per_point(), ctx.content_rect().size()));
+                }
+                // It settles within a few frames and then stays put: no flicker between two sizes.
+                let (ppp, content) = seen[seen.len() - 1];
+                assert_eq!(seen[seen.len() - 2].0, ppp, "{case}: still changing");
+                assert!(ppp.is_finite() && ppp > 0.0 && content.x.is_finite() && content.y.is_finite(), "{case}: {ppp} {content:?}");
+                let plan = app.ui.ui_scale;
+                assert!((ppp - plan.drawn).abs() < 1e-3, "{case}: egui draws at {ppp}, the plan said {}", plan.drawn);
+                // The size drawn, relative to the system's scale.
+                let zoom = ppp / native;
+                let want = want as f32;
+                assert_eq!(plan.limited, zoom < want - 0.005, "{case}: limited flag");
+                // Above 100 % the window holds the smallest layout; at or below it there is nothing more to give up.
+                if zoom > 1.001 {
+                    assert!(content.x >= FIT_POINTS.0 - 0.5 && content.y >= FIT_POINTS.1 - 0.5, "{case}: window is {content:?} points at {ppp}");
+                }
+                // It never draws bigger than asked, and only a window too small for it draws smaller.
+                assert!(zoom <= want + 1e-3, "{case}");
+                if !plan.limited {
+                    assert!((zoom - want).abs() < 1e-3, "{case}");
+                }
+                let panels = &app.inspect()["panels"];
+                let side = panels["left"].as_f64().unwrap_or(0.0) + panels["right"].as_f64().unwrap_or(0.0);
+                assert!(side < f64::from(content.x) - 100.0, "{case}: the panels ({side} pt) leave no canvas in {content:?}");
+            }
+        }
+    }
+}
+
+/// The interface size is reachable and changeable without a pointer: Tab reaches the menu, Enter
+/// opens it, the arrows and Tab move through its entries, Enter picks one and closes the menu, and
+/// Escape closes it alone, without changing anything and without closing Preferences (a second
+/// Escape does).
+#[test]
+fn the_interface_size_menu_works_from_the_keyboard() {
+    use crate::a11y::focused_name;
+    use egui::{Event, Key, Modifiers, Popup};
+
+    // A key press, then two quiet frames for the focus (and the name a screen reader reads) to settle.
+    let press_mod = |u: &mut Ui, key: Key, modifiers: Modifiers| {
+        u.frame_with(
+            vec![
+                Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers },
+                Event::Key { key, physical_key: None, pressed: false, repeat: false, modifiers },
+            ],
+            modifiers,
+        );
+        u.frame(vec![]);
+        u.frame(vec![]);
+    };
+    let press = |u: &mut Ui, key: Key| press_mod(u, key, Modifiers::NONE);
+    let open = |u: &mut Ui| {
+        // The Preferences dialog is not modal for the keyboard: Tab crosses the main window first.
+        let mut tabs = 0;
+        while focused_name(&u.ctx) != "Interface size" {
+            assert!(tabs < 140, "Tab never reaches the Interface size menu (focus: {:?})", focused_name(&u.ctx));
+            press(u, Key::Tab);
+            tabs += 1;
+        }
+        press(u, Key::Enter);
+        assert!(Popup::is_any_open(&u.ctx), "Enter opens the menu");
+    };
+    let chosen = |u: &Ui| u.app.inspect()["uiScale"]["choice"].clone();
+
+    let mut u = Ui::new(Session::new());
+    u.app.ui.preferences = true;
+    u.ctx.enable_accesskit();
+    settle(&mut u, 1.0);
+    assert_eq!(chosen(&u), json!(1.0));
+
+    // Escape closes the menu and nothing else: the size is unchanged and Preferences stays open.
+    open(&mut u);
+    press(&mut u, Key::Escape);
+    u.frame(vec![]);
+    assert!(!Popup::is_any_open(&u.ctx));
+    assert!(u.app.ui.preferences, "the first Escape closes the menu only");
+    assert_eq!(chosen(&u), json!(1.0));
+
+    // The arrows enter the menu on its first size and go down through the sizes (75, 90, 100, 110,
+    // 125); Enter picks the one that has the keyboard and closes the menu.
+    open(&mut u);
+    press(&mut u, Key::ArrowDown);
+    assert_eq!(focused_name(&u.ctx), "75%");
+    for _ in 0..4 {
+        press(&mut u, Key::ArrowDown);
+    }
+    assert_eq!(focused_name(&u.ctx), "125%");
+    for expected in ["150%", "175%", "200%", "200%"] {
+        press(&mut u, Key::Tab);
+        assert_eq!(focused_name(&u.ctx), expected, "Tab stays in the size menu");
+    }
+    for expected in ["175%", "150%", "125%"] {
+        press_mod(&mut u, Key::Tab, Modifiers::SHIFT);
+        assert_eq!(focused_name(&u.ctx), expected, "Shift+Tab stays in the size menu");
+    }
+    press(&mut u, Key::Enter);
+    assert_eq!(chosen(&u), json!(1.25));
+    assert!(!Popup::is_any_open(&u.ctx), "picking a size closes the menu");
+    assert!(u.app.ui.preferences, "picking a size leaves Preferences open");
+    // With no menu open, Escape closes Preferences as before.
+    press(&mut u, Key::Escape);
+    assert!(!u.app.ui.preferences);
+}
diff --git a/crates/ui-egui/src/variable_ui.rs b/crates/ui-egui/src/variable_ui.rs
index 04507c0c4..39c5396e9 100644
--- a/crates/ui-egui/src/variable_ui.rs
+++ b/crates/ui-egui/src/variable_ui.rs
@@ -17,7 +17,7 @@ use crate::a11y::Tip;
 use crate::i18n::tr;
 use crate::icons::{self, Icon};
 use crate::theme::{Tokens, regular, semibold};
-use crate::widgets::{self, BindEvent, Edit, FieldEdit, Lead};
+use crate::widgets::{self, BindEvent, Edit, Empty, FieldEdit, Lead};
 
 /// What picking a variable does.
 #[derive(Clone)]
@@ -258,7 +258,23 @@ pub fn number_field_or(
     lead: Lead,
     suffix: &str,
 ) -> Option<FieldEdit> {
-    number_field_edit(app, ui, ids, field, id, value, width, empty, lead, suffix)?.settled()
+    number_field_edit(app, ui, ids, field, id, value, width, Empty::Text(empty), lead, suffix)?.settled()
+}
+
+/// [`number_field_or`] for a field where 0 is its automatic value (a layout grid's width or
+/// count): typing the word for Auto sets 0 ([`Empty::Auto`]).
+pub fn number_field_auto(
+    app: &mut FigApp,
+    ui: &mut Ui,
+    ids: &[NodeId],
+    field: &str,
+    id: Id,
+    value: Option<f64>,
+    width: f32,
+    lead: Lead,
+    suffix: &str,
+) -> Option<FieldEdit> {
+    number_field_edit(app, ui, ids, field, id, value, width, Empty::Auto, lead, suffix)?.settled()
 }
 
 /// [`number_field`] over several layers: a relative edit of mixed values comes back as one for
@@ -274,7 +290,7 @@ pub fn number_field_mixed(
     suffix: &str,
     width: f32,
 ) -> Option<Edit> {
-    number_field_edit(app, ui, ids, field, id, value, width, tr("Mixed"), lead, suffix)
+    number_field_edit(app, ui, ids, field, id, value, width, Empty::Text(tr("Mixed")), lead, suffix)
 }
 
 fn number_field_edit(
@@ -285,7 +301,7 @@ fn number_field_edit(
     id: Id,
     value: Option<f64>,
     width: f32,
-    empty: &str,
+    empty: Empty<'_>,
     lead: Lead,
     suffix: &str,
 ) -> Option<Edit> {
@@ -361,6 +377,12 @@ pub fn bound_row(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId], field: &str, kin
     });
 }
 
+/// Whether a variable of type `have` belongs in a picker for `want` on `field`: its own type, and
+/// numbers for text content too (shown as text).
+fn kind_fits(want: Option<VariableType>, field: Option<&str>, have: VariableType) -> bool {
+    want.is_none_or(|k| have == k || (field == Some("characters") && have == VariableType::Number))
+}
+
 /// The picker popover (call once per frame).
 pub fn picker(app: &mut FigApp, ctx: &egui::Context) {
     let Some(p) = ctx.data(|d| d.get_temp::<Picker>(picker_id())) else { return };
@@ -379,8 +401,12 @@ pub fn picker(app: &mut FigApp, ctx: &egui::Context) {
     };
     // Prototypes and styles use this file's variables.
     let local_only = matches!(p.target, Target::Proto(_) | Target::Style { .. });
+    let field = match &p.target {
+        Target::Bind { field, .. } => Some(field.as_str()),
+        _ => None,
+    };
     let keep = |lib: Option<&PublishedLibrary>, v: &Variable| {
-        p.kind.is_none_or(|k| v.kind == k)
+        kind_fits(p.kind, field, v.kind)
             && !(local_only && lib.is_some())
             && (q.is_empty() || v.name.to_lowercase().contains(&q))
             && scope.is_none_or(|s| v.in_scope(s))
@@ -476,3 +502,19 @@ pub fn picker(app: &mut FigApp, ctx: &egui::Context) {
 fn groups_any_kind(doc: &Document, libs: &[Arc<PublishedLibrary>], kind: Option<VariableType>) -> bool {
     !groups(doc, libs, |_, v| kind.is_none_or(|k| v.kind == k)).is_empty()
 }
+
+#[cfg(test)]
+mod kind_tests {
+    use super::*;
+
+    #[test]
+    fn text_content_offers_numbers_too() {
+        use VariableType::*;
+        assert!(kind_fits(Some(String), Some("characters"), Number), "a number shows as text");
+        assert!(kind_fits(Some(String), Some("characters"), String));
+        assert!(!kind_fits(Some(String), Some("characters"), Color));
+        assert!(!kind_fits(Some(String), Some("fontFamily"), Number), "only text content");
+        assert!(!kind_fits(Some(Number), Some("width"), String));
+        assert!(kind_fits(None, None, Boolean));
+    }
+}
diff --git a/crates/ui-egui/src/variants_discovery_tests.rs b/crates/ui-egui/src/variants_discovery_tests.rs
new file mode 100644
index 000000000..e153d9822
--- /dev/null
+++ b/crates/ui-egui/src/variants_discovery_tests.rs
@@ -0,0 +1,111 @@
+//! Combine as variants and Add variant where people look for them (#903), driven through egui
+//! headless: the Design panel offers Combine for two or more main components and Add variant for
+//! a lone one, and the canvas / layers context menu lists Combine only when it applies.
+
+use egui::Pos2;
+use figcraft_doc::{NodeId, NodeKind};
+use figcraft_engine::Session;
+use serde_json::json;
+
+use crate::layers_drag_tests::Ui;
+use crate::live_tests::{flat, has_text, text_center};
+use crate::present_tests::id;
+
+const COMBINE: &str = "Combine as variants";
+
+/// A session with lone main components named A, B and C side by side, and a frame. Returns
+/// (session, [a, b, c], frame).
+fn doc() -> (Session, [NodeId; 3], NodeId) {
+    let mut s = Session::new();
+    let mut comps = Vec::new();
+    for (k, name) in ["A", "B", "C"].iter().enumerate() {
+        let f = id(&s.execute("frame.create", &json!({"x": k * 160, "y": 0, "width": 120, "height": 40, "name": name})).unwrap());
+        comps.push(id(&s.execute("component.create", &json!({"ids": [f]})).unwrap()));
+    }
+    let frame = id(&s.execute("frame.create", &json!({"x": 0, "y": 200, "width": 60, "height": 60})).unwrap());
+    (s, [comps[0], comps[1], comps[2]], frame)
+}
+
+fn select(u: &mut Ui, ids: &[NodeId]) {
+    u.app.session.execute("select.set", &json!({"ids": ids})).unwrap();
+    u.frame(vec![]);
+}
+
+/// The text painted this frame.
+fn shows(u: &mut Ui, s: &str) -> Option<Pos2> {
+    let shapes = flat(&u.frame_output(vec![]).shapes);
+    has_text(&shapes, s).then(|| text_center(&shapes, s))
+}
+
+fn click(u: &mut Ui, p: Pos2) {
+    u.button(p, true);
+    u.button(p, false);
+}
+
+fn set_of(u: &Ui, c: NodeId) -> Option<NodeId> {
+    let doc = u.app.session.doc().unwrap();
+    doc.node(c).and_then(|n| n.parent).filter(|p| doc.node(*p).is_some_and(|n| matches!(n.kind, NodeKind::ComponentSet { .. })))
+}
+
+fn undo_len(u: &Ui) -> usize {
+    u.app.session.ds().unwrap().history.undo.len()
+}
+
+#[test]
+fn the_design_panel_combines_two_selected_components() {
+    let (s, [a, b, _], _) = doc();
+    let mut u = Ui::new(s);
+    select(&mut u, &[a, b]);
+    let at = shows(&mut u, COMBINE).expect("the Design panel offers Combine as variants");
+    let undo = undo_len(&u);
+    click(&mut u, at);
+    let set = set_of(&u, a).expect("combined into a set");
+    assert_eq!(set_of(&u, b), Some(set));
+    assert_eq!(u.app.session.selection(), vec![set]);
+    assert_eq!(undo_len(&u), undo + 1);
+    assert!(u.app.ui.last_error.is_none(), "{:?}", u.app.ui.last_error);
+    assert!(shows(&mut u, COMBINE).is_none(), "a set selected: nothing to combine");
+}
+
+#[test]
+fn the_design_panel_offers_combine_only_when_it_applies() {
+    // The cases are the engine's (`can_combine_variants`); this pins the panel to it.
+    let (s, [a, ..], frame) = doc();
+    let mut u = Ui::new(s);
+    select(&mut u, &[a, frame]);
+    assert!(shows(&mut u, COMBINE).is_none(), "a component and a frame");
+}
+
+#[test]
+fn the_design_panel_adds_a_variant_to_a_lone_component() {
+    let (s, [a, ..], _) = doc();
+    let mut u = Ui::new(s);
+    select(&mut u, &[a]);
+    let at = shows(&mut u, "Add variant").expect("a lone main component offers Add variant");
+    click(&mut u, at);
+    let set = set_of(&u, a).expect("the component became a set");
+    assert_eq!(u.app.session.doc().unwrap().node(set).unwrap().children.len(), 2);
+    assert!(u.app.ui.last_error.is_none(), "{:?}", u.app.ui.last_error);
+}
+
+#[test]
+fn the_context_menu_lists_combine_for_two_selected_components() {
+    let (s, [a, b, _], _) = doc();
+    let mut u = Ui::new(s);
+    // One component: no Combine, Create component as before.
+    select(&mut u, &[a]);
+    u.app.ui.context_menu = Some((Pos2::new(700.0, 300.0), vec![a]));
+    assert!(shows(&mut u, COMBINE).is_none());
+    assert!(shows(&mut u, "Create component").is_some());
+    u.app.ui.context_menu = None;
+    // Two components, right-clicked on one layer row (the menu gets only that row): judged on
+    // the selection, which is what the command combines.
+    select(&mut u, &[a, b]);
+    u.app.ui.context_menu = Some((Pos2::new(700.0, 300.0), vec![a]));
+    u.frame(vec![]);
+    let at = shows(&mut u, COMBINE).expect("the context menu offers Combine as variants");
+    click(&mut u, at);
+    let set = set_of(&u, a).expect("combined into a set");
+    assert_eq!(set_of(&u, b), Some(set));
+    assert!(u.app.ui.context_menu.is_none(), "the menu closes");
+}
diff --git a/crates/ui-egui/src/web_clipboard_tests.rs b/crates/ui-egui/src/web_clipboard_tests.rs
index a77871204..bda57373b 100644
--- a/crates/ui-egui/src/web_clipboard_tests.rs
+++ b/crates/ui-egui/src/web_clipboard_tests.rs
@@ -86,6 +86,26 @@ impl Page {
         self.frame(vec![Self::key(Key::V, false)]);
     }
 
+    /// Cmd+V with `m` added, as the browser delivers it: the key press, then the paste event.
+    fn chord(&mut self, m: Modifiers) {
+        let m = m | Modifiers::MAC_CMD | Modifiers::COMMAND;
+        let v = |pressed| Event::Key { key: Key::V, physical_key: Some(Key::V), pressed, repeat: false, modifiers: m };
+        let text = self.clipboard.clone();
+        self.frame(vec![Event::ModifiersChanged(m), v(true), Event::Paste(text)]);
+        self.frame(vec![v(false)]);
+        self.frame(vec![Event::ModifiersChanged(Modifiers::NONE)]);
+    }
+
+    /// Copy the selected rectangle A (made red) and its properties, then select a new rectangle B.
+    fn copy_a_select_b(&mut self) -> figcraft_doc::NodeId {
+        self.app.session.execute("fill.set", &json!({"color": "#e53935"})).unwrap();
+        self.copy();
+        self.app.session.execute("edit.copyProperties", &json!({})).unwrap();
+        let b = self.app.session.execute("shape.rectangle", &json!({"x": 400, "y": 250, "width": 100, "height": 50})).unwrap();
+        self.app.session.execute("select.set", &json!({"ids": [b["id"]]})).unwrap();
+        figcraft_doc::NodeId(b["id"].as_u64().unwrap())
+    }
+
     fn count(&self, kind: fn(&NodeKind) -> bool) -> usize {
         self.app.session.doc().unwrap().nodes().filter(|n| kind(&n.kind)).count()
     }
@@ -121,6 +141,70 @@ fn text_copied_elsewhere_after_our_copy_still_pastes_as_text() {
     assert_eq!(p.count(text), 1, "newer text from elsewhere becomes a text layer");
 }
 
+#[test]
+fn copying_text_layers_puts_their_text_on_the_clipboard() {
+    // #808: other apps get a text layer's text, not its SVG; FigCraft still pastes the layers.
+    let mut p = Page::new();
+    let a = p.app.session.execute("text.create", &json!({"text": "Hello", "x": 0, "y": 200})).unwrap();
+    let b = p.app.session.execute("text.create", &json!({"text": "World", "x": 0, "y": 300})).unwrap();
+    p.app.session.execute("select.set", &json!({"ids": [a["id"], b["id"]]})).unwrap();
+    p.frame(vec![]);
+    p.copy();
+    assert_eq!(p.clipboard, "Hello\nWorld", "one line per text layer");
+    p.paste();
+    assert_eq!(p.count(text), 4, "the copied text layers were pasted, not one layer of their text");
+    let r = p.app.session.doc().unwrap().nodes().find(|n| rect(&n.kind)).map(|n| n.id.0).unwrap();
+    p.app.session.execute("select.set", &json!({"ids": [r, a["id"]]})).unwrap();
+    p.copy();
+    assert!(p.clipboard.contains("<svg"), "a selection with other layers stays SVG");
+}
+
+#[test]
+fn shift_cmd_v_pastes_over_once_and_no_text() {
+    for foreign in [false, true] {
+        let mut p = Page::new();
+        let b = p.copy_a_select_b();
+        if foreign {
+            p.clipboard = "hello from another app".into();
+        }
+        p.chord(Modifiers::SHIFT);
+        assert_eq!(p.count(rect), 3, "foreign text {foreign}: one copy pasted over B");
+        assert_eq!(p.count(text), 0, "foreign text {foreign}: the paste event pasted nothing");
+        let doc = p.app.session.doc().unwrap();
+        let over = doc.nodes().filter(|n| n.id != b).filter_map(|n| doc.world_bounds(n.id)).any(|r| r.x0 == 400.0 && r.y0 == 250.0);
+        assert!(over, "foreign text {foreign}: the copy sits at B's top-left");
+    }
+}
+
+#[test]
+fn alt_cmd_v_pastes_properties_once_and_no_text() {
+    for foreign in [false, true] {
+        let mut p = Page::new();
+        let b = p.copy_a_select_b();
+        if foreign {
+            p.clipboard = "hello from another app".into();
+        }
+        p.chord(Modifiers::ALT);
+        assert_eq!(p.count(rect), 2, "foreign text {foreign}: no layer pasted");
+        assert_eq!(p.count(text), 0, "foreign text {foreign}: the paste event pasted nothing");
+        let fill = figcraft_engine::inspect::node_json(p.app.session.doc().unwrap(), b, 0)["fills"][0]["color"].clone();
+        assert_eq!(fill, "#E53935", "foreign text {foreign}: B took A's fill");
+    }
+}
+
+#[test]
+fn a_chord_tapped_within_one_frame_runs_once() {
+    let mut p = Page::new();
+    p.copy_a_select_b();
+    let m = Modifiers::SHIFT | Modifiers::MAC_CMD | Modifiers::COMMAND;
+    let v = |pressed| Event::Key { key: Key::V, physical_key: Some(Key::V), pressed, repeat: false, modifiers: m };
+    let clip = p.clipboard.clone();
+    p.frame(vec![Event::ModifiersChanged(m), v(true), Event::Paste(clip), v(false), Event::ModifiersChanged(Modifiers::NONE)]);
+    p.frame(vec![]);
+    assert_eq!(p.count(rect), 3, "one copy pasted over B");
+    assert_eq!(p.count(text), 0);
+}
+
 #[test]
 fn copy_as_png_puts_an_image_on_the_clipboard() {
     let mut p = Page::new();
diff --git a/crates/ui-egui/src/widgets.rs b/crates/ui-egui/src/widgets.rs
index b44135454..845dca9df 100644
--- a/crates/ui-egui/src/widgets.rs
+++ b/crates/ui-egui/src/widgets.rs
@@ -37,6 +37,25 @@ impl Lead<'_> {
     }
 }
 
+/// What a number field shows when it has no single value, and whether that word types 0.
+#[derive(Clone, Copy)]
+pub enum Empty<'a> {
+    /// Dim text that is only a label ("Mixed", or "Auto" where 0 means something else).
+    Text(&'a str),
+    /// Auto, in the UI's language: 0 is the field's automatic value, so the word types 0.
+    Auto,
+}
+
+impl<'a> Empty<'a> {
+    /// The text shown when the field has no value.
+    fn text(self) -> &'a str {
+        match self {
+            Empty::Text(s) => s,
+            Empty::Auto => tr("Auto"),
+        }
+    }
+}
+
 /// Result of a field edit.
 pub enum FieldEdit {
     /// Committed a new value (Enter, Tab or focus loss; an arrow key's step).
@@ -157,18 +176,19 @@ pub fn number_field(ui: &mut Ui, id: Id, lead: Lead, value: Option<f64>, suffix:
 /// [`number_field`] over several layers: without a single value (`value` None, "Mixed") a relative
 /// edit comes back as one for each layer ([`Edit::Each`]).
 pub fn number_field_mixed(ui: &mut Ui, id: Id, lead: Lead, value: Option<f64>, suffix: &str, width: f32, step: f64) -> Option<Edit> {
-    number_field_bindable(ui, id, lead, value, suffix, width, step, None, tr("Mixed")).0
+    number_field_bindable(ui, id, lead, value, suffix, width, step, None, Empty::Text(tr("Mixed"))).0
 }
 
 /// [`number_field`] that shows `empty` (dim) for no value instead of "Mixed" (e.g. "Auto"): there
 /// is no value to edit relative to, so `+4` is 4.
 pub fn number_field_or(ui: &mut Ui, id: Id, value: Option<f64>, empty: &str, width: f32, step: f64) -> Option<FieldEdit> {
-    number_field_impl(ui, id, Lead::None, value, "", width, step, None, empty).0?.settled()
+    number_field_impl(ui, id, Lead::None, value, "", width, step, None, Empty::Text(empty)).0?.settled()
 }
 
 /// [`number_field`] that can bind a variable: `binding` None = not bindable, `Some(None)` = shows
 /// a variable button on hover, `Some(Some(name))` = bound (shows the name; click to change, the
-/// detach button unbinds). No value shows `empty` ("Mixed", "Auto").
+/// detach button unbinds). No value shows `empty` ("Mixed", "Auto"); [`Empty::Auto`] also takes
+/// the word for Auto as 0.
 pub fn number_field_bindable(
     ui: &mut Ui,
     id: Id,
@@ -178,7 +198,7 @@ pub fn number_field_bindable(
     width: f32,
     step: f64,
     binding: Option<Option<&str>>,
-    empty: &str,
+    empty: Empty<'_>,
 ) -> (Option<Edit>, Option<BindEvent>) {
     number_field_impl(ui, id, lead, value, suffix, width, step, binding, empty)
 }
@@ -192,7 +212,7 @@ fn number_field_impl(
     width: f32,
     step: f64,
     binding: Option<Option<&str>>,
-    empty: &str,
+    empty: Empty<'_>,
 ) -> (Option<Edit>, Option<BindEvent>) {
     let t = Tokens::get(ui.ctx());
     let (rect, _) = ui.allocate_exact_size(vec2(width, FIELD_H), Sense::hover());
@@ -202,7 +222,7 @@ fn number_field_impl(
     let mut out: Option<Edit> = None;
     let lead_w = match lead {
         Lead::None | Lead::Named(_) => 6.0,
-        Lead::Text(s) => (12.0 + s.chars().count() as f32 * 7.0).max(24.0),
+        Lead::Text(s) => text_lead_width(ui, s, width),
         Lead::Icon(..) => 24.0,
     };
     let lead_rect = Rect::from_min_size(rect.min, vec2(lead_w, FIELD_H));
@@ -210,20 +230,25 @@ fn number_field_impl(
     let editing_id = id.with("editing");
     let mut editing: Option<String> = ui.data(|d| d.get_temp(editing_id));
     let field_resp = ui.interact(edit_rect, id.with("field"), Sense::click());
-    a11y::number(&field_resp, lead.name(), value, suffix, empty);
+    a11y::number(&field_resp, lead.name(), value, suffix, empty.text());
     a11y::ring_around(ui, rect, &field_resp);
     // The label scrubs with the pointer; the keyboard stops at the value only.
     let lead_resp = ui.interact(lead_rect, id.with("lead"), Sense::CLICK | Sense::DRAG);
     let hovered = field_resp.hovered() || lead_resp.hovered() || editing.is_some();
     ui.painter().rect_filled(rect, CornerRadius::same(5), t.field);
     if editing.is_some() {
-        ui.painter().rect_stroke(rect, CornerRadius::same(5), Stroke::new(1.0, t.accent), StrokeKind::Inside);
+        ui.painter().rect_stroke(rect, CornerRadius::same(5), Stroke::new(1.0, crate::theme::ACCENT), StrokeKind::Inside);
     } else if hovered {
         ui.painter().rect_stroke(rect, CornerRadius::same(5), Stroke::new(1.0, t.field_hover_border), StrokeKind::Inside);
     }
     match lead {
         Lead::Text(s) => {
-            ui.painter().text(pos2(lead_rect.min.x + 8.0, rect.center().y), Align2::LEFT_CENTER, s, regular(11.0), t.text_secondary);
+            let galley = crate::bidi::name_galley(ui.painter(), s, regular(11.0), t.text_secondary, lead_w - 12.0);
+            // A label cut short shows whole on hover.
+            if galley.elided {
+                lead_resp.clone().on_hover_text(s);
+            }
+            ui.painter().galley(pos2(lead_rect.min.x + 8.0, rect.center().y - galley.size().y / 2.0), galley, t.text_secondary);
         }
         Lead::Icon(i, _) => {
             icons::paint(ui.painter(), Rect::from_center_size(lead_rect.center() + vec2(1.0, 0.0), vec2(14.0, 14.0)), i, t.icon_secondary)
@@ -254,10 +279,21 @@ fn number_field_impl(
     };
     // A relative edit of no single value goes to each layer's own.
     let set = |v: f64| Edit::All(FieldEdit::Set(v));
-    let typed = |text: &str| match (parse(text, suffix == "%")?, value) {
-        (Typed::Value(v), _) => Some(set(v)),
-        (Typed::Rel(r), Some(cur)) => r.apply(cur).map(set),
-        (Typed::Rel(r), None) => Some(Edit::Each(r)),
+    let typed = |text: &str| {
+        // A field where 0 is its automatic value takes the word for Auto as input too: the
+        // placeholder's own text (so it is what the field shows, in the UI's language) or the
+        // English word.
+        if let Empty::Auto = empty {
+            let t = text.trim();
+            if t == empty.text() || t.eq_ignore_ascii_case("auto") {
+                return Some(set(0.0));
+            }
+        }
+        match (parse(text, suffix == "%")?, value) {
+            (Typed::Value(v), _) => Some(set(v)),
+            (Typed::Rel(r), Some(cur)) => r.apply(cur).map(set),
+            (Typed::Rel(r), None) => Some(Edit::Each(r)),
+        }
     };
     // With the keyboard on the field (Tab) and nothing typed yet, the arrows step it as it is.
     if editing.is_none()
@@ -344,10 +380,11 @@ fn number_field_impl(
         None => {
             let s = match value {
                 Some(v) => format!("{}{}", fmt_num(v), suffix),
-                None => empty.to_string(),
+                None => empty.text().to_string(),
             };
             let col = if value.is_some() { t.text } else { t.text_secondary };
-            ui.painter().text(pos2(edit_rect.min.x, rect.center().y), Align2::LEFT_CENTER, s, regular(11.0), col);
+            // A value too long for its room ends in "…", so a cut number never reads as another.
+            crate::bidi::paint_name(ui.painter(), pos2(edit_rect.min.x, rect.center().y), &s, regular(11.0), col, edit_rect.width());
         }
     }
     // The variable button shows while the pointer is over a bindable field.
@@ -369,6 +406,13 @@ fn number_field_impl(
     (out, bind)
 }
 
+/// The width a text label takes at the start of a field `field_w` wide: the label as drawn plus
+/// its padding, leaving the value room for a few characters (a longer label ends in an ellipsis).
+pub(crate) fn text_lead_width(ui: &Ui, label: &str, field_w: f32) -> f32 {
+    let text = ui.painter().layout_no_wrap(label.to_string(), regular(11.0), Color32::PLACEHOLDER).size().x;
+    (12.0 + text).min(field_w - 32.0).max(24.0)
+}
+
 /// A field bound to a variable: the lead, then the variable's name in a chip; the chip opens the
 /// picker and the detach button unbinds.
 /// A field showing the variable `name` bound to it in `rect`: click to change, detach to unbind.
@@ -383,8 +427,9 @@ pub fn bound_field(ui: &mut Ui, id: Id, lead: Lead, rect: Rect, name: &str) -> O
     let lead_w = match lead {
         Lead::None | Lead::Named(_) => 4.0,
         Lead::Text(s) => {
-            ui.painter().text(pos2(rect.min.x + 8.0, rect.center().y), Align2::LEFT_CENTER, s, regular(11.0), t.text_secondary);
-            (12.0 + s.chars().count() as f32 * 7.0).max(24.0)
+            let w = text_lead_width(ui, s, rect.width());
+            crate::bidi::paint_name(ui.painter(), pos2(rect.min.x + 8.0, rect.center().y), s, regular(11.0), t.text_secondary, w - 12.0);
+            w
         }
         Lead::Icon(i, _) => {
             icons::paint(ui.painter(), Rect::from_center_size(pos2(rect.min.x + 13.0, rect.center().y), vec2(14.0, 14.0)), i, t.icon_secondary);
@@ -493,7 +538,7 @@ fn text_field_in(ui: &mut Ui, id: Id, value: &str, rect: Rect, placeholder: &str
     a11y::text(&resp, name, value);
     ui.painter().rect_filled(rect, CornerRadius::same(5), t.field);
     if editing.is_some() {
-        ui.painter().rect_stroke(rect, CornerRadius::same(5), Stroke::new(1.0, t.accent), StrokeKind::Inside);
+        ui.painter().rect_stroke(rect, CornerRadius::same(5), Stroke::new(1.0, crate::theme::ACCENT), StrokeKind::Inside);
     } else if resp.hovered() {
         ui.painter().rect_stroke(rect, CornerRadius::same(5), Stroke::new(1.0, t.field_hover_border), StrokeKind::Inside);
     }
@@ -501,7 +546,7 @@ fn text_field_in(ui: &mut Ui, id: Id, value: &str, rect: Rect, placeholder: &str
     if started {
         editing = Some(value.to_string());
         ui.memory_mut(|m| m.request_focus(id.with("te")));
-        select_all_next(ui, id.with("te"));
+        select_all_next(ui, id.with("te"), value);
     }
     let mut out = None;
     match editing {
@@ -556,7 +601,7 @@ pub fn text_input(ui: &mut Ui, id: Id, text: &mut String, width: f32, hint: &str
     ui.painter().rect_filled(rect, CornerRadius::same(5), t.field);
     let r = field_editor(ui, rect, id, text, hint);
     if r.has_focus() {
-        ui.painter().rect_stroke(rect, CornerRadius::same(5), Stroke::new(1.0, t.accent), StrokeKind::Inside);
+        ui.painter().rect_stroke(rect, CornerRadius::same(5), Stroke::new(1.0, crate::theme::ACCENT), StrokeKind::Inside);
     } else if ui.rect_contains_pointer(rect) {
         ui.painter().rect_stroke(rect, CornerRadius::same(5), Stroke::new(1.0, t.field_hover_border), StrokeKind::Inside);
     }
@@ -593,21 +638,33 @@ pub fn select_all_on_focus(ui: &Ui, r: &Response, text: &str) {
         ui.data_mut(|d| d.remove::<bool>(pending));
         return;
     }
-    if let Some(mut state) = egui::TextEdit::load_state(ui.ctx(), r.id) {
-        let all = egui::text::CCursorRange::two(egui::text::CCursor::new(0), egui::text::CCursor::new(text.chars().count()));
-        state.cursor.set_char_range(Some(all));
-        state.store(ui.ctx(), r.id);
-        ui.ctx().request_repaint();
+    // A key typed in the frame the edit started already replaced the selection laid beforehand.
+    if r.changed() {
+        ui.data_mut(|d| d.remove::<bool>(pending));
+        return;
     }
+    select_all(ui, r.id, text);
+    ui.ctx().request_repaint();
     if !down {
         ui.data_mut(|d| d.remove::<bool>(pending));
     }
 }
 
 /// Has [`select_all_on_focus`] select all of editor `te_id` from now on (an edit that starts
-/// with the editor already focused, which then gains no focus).
-fn select_all_next(ui: &Ui, te_id: Id) {
+/// with the editor already focused, which then gains no focus). Call it before adding the editor:
+/// the text is selected at once, so a key typed in the frame the edit starts (the frame after a
+/// double-click or F2 is often the one with the first key) replaces it.
+fn select_all_next(ui: &Ui, te_id: Id, text: &str) {
     ui.data_mut(|d| d.insert_temp(select_all_id(te_id), true));
+    select_all(ui, te_id, text);
+}
+
+/// Selects all of `text` in editor `te_id`.
+fn select_all(ui: &Ui, te_id: Id, text: &str) {
+    let mut state = egui::TextEdit::load_state(ui.ctx(), te_id).unwrap_or_default();
+    let all = egui::text::CCursorRange::two(egui::text::CCursor::new(0), egui::text::CCursor::new(text.chars().count()));
+    state.cursor.set_char_range(Some(all));
+    state.store(ui.ctx(), te_id);
 }
 
 fn select_all_id(te_id: Id) -> Id {
@@ -948,7 +1005,7 @@ pub fn checkbox(ui: &mut Ui, on: bool, label: &str) -> bool {
     let b = Rect::from_min_size(pos2(rect.min.x, rect.center().y - 7.0), vec2(14.0, 14.0));
     if on {
         ui.painter().rect_filled(b, CornerRadius::same(3), t.accent);
-        icons::paint(ui.painter(), b.shrink(1.5), Icon::Check, Color32::WHITE);
+        icons::paint(ui.painter(), b.shrink(1.5), Icon::Check, t.accent_on);
     } else {
         ui.painter().rect_stroke(b, CornerRadius::same(3), Stroke::new(1.0, t.border_strong), StrokeKind::Inside);
     }
@@ -964,35 +1021,35 @@ pub fn radio(ui: &mut Ui, on: bool, label: &str) -> bool {
     let c = pos2(rect.min.x + 7.0, rect.center().y);
     if on {
         ui.painter().circle_filled(c, 7.0, t.accent);
-        ui.painter().circle_filled(c, 2.5, Color32::WHITE);
+        ui.painter().circle_filled(c, 2.5, t.accent_on);
     } else {
-        ui.painter().circle_stroke(c, 6.5, Stroke::new(1.0, if resp.hovered() { t.accent } else { t.border_strong }));
+        ui.painter().circle_stroke(c, 6.5, Stroke::new(1.0, if resp.hovered() { crate::theme::ACCENT } else { t.border_strong }));
     }
     ui.painter().text(pos2(rect.min.x + 22.0, rect.center().y), Align2::LEFT_CENTER, label, regular(11.0), t.text);
     resp.clicked()
 }
 
 /// A text button: `primary` is filled with the accent colour, otherwise outlined. A disabled
-/// button is dimmed and never reports clicks.
+/// button is grey with dim text (still readable) and never reports clicks.
 pub fn button(ui: &mut Ui, label: &str, primary: bool, enabled: bool) -> Response {
     let t = Tokens::get(ui.ctx());
     let galley = ui.painter().layout_no_wrap(label.to_string(), regular(11.0), t.text);
     let sense = if enabled { Sense::click() } else { Sense::hover() };
     let (rect, resp) = ui.allocate_exact_size(vec2(galley.size().x + 24.0, FIELD_H), sense);
     a11y::button(&resp, label);
-    let hot = enabled && resp.hovered();
-    let (fill, text) = match (primary, hot) {
-        (true, false) => (t.accent, Color32::WHITE),
-        (true, true) => (t.accent_hover, Color32::WHITE),
-        (false, false) => (Color32::TRANSPARENT, t.text),
-        (false, true) => (t.hover, t.text),
+    let (fill, text) = match (enabled, primary, resp.hovered()) {
+        (false, true, _) => (t.field, t.text_tertiary),
+        (false, false, _) => (Color32::TRANSPARENT, t.text_tertiary),
+        (true, true, false) => (t.accent, t.accent_on),
+        (true, true, true) => (t.accent_hover, t.accent_on),
+        (true, false, false) => (Color32::TRANSPARENT, t.text),
+        (true, false, true) => (t.hover, t.text),
     };
-    let dim = |c: Color32| if enabled { c } else { c.gamma_multiply(0.4) };
-    ui.painter().rect_filled(rect, CornerRadius::same(5), dim(fill));
+    ui.painter().rect_filled(rect, CornerRadius::same(5), fill);
     if !primary {
         ui.painter().rect_stroke(rect, CornerRadius::same(5), Stroke::new(1.0, t.border_strong), StrokeKind::Inside);
     }
-    ui.painter().text(rect.center(), Align2::CENTER_CENTER, label, regular(11.0), dim(text));
+    ui.painter().text(rect.center(), Align2::CENTER_CENTER, label, regular(11.0), text);
     resp
 }
 
@@ -1015,12 +1072,12 @@ pub fn text_field_inline(ui: &mut Ui, id: Id, value: &str, rect: Rect, font: egu
     if started {
         buf = Some(value.to_string());
         ui.memory_mut(|m| m.request_focus(te_id));
-        select_all_next(ui, te_id);
+        select_all_next(ui, te_id, value);
     }
     match buf {
         Some(mut text) => {
             ui.painter().rect_filled(rect.expand(2.0), CornerRadius::same(4), t.panel);
-            ui.painter().rect_stroke(rect.expand(2.0), CornerRadius::same(4), Stroke::new(1.0, t.accent), StrokeKind::Inside);
+            ui.painter().rect_stroke(rect.expand(2.0), CornerRadius::same(4), Stroke::new(1.0, crate::theme::ACCENT), StrokeKind::Inside);
             let mut child = ui.new_child(egui::UiBuilder::new().max_rect(rect));
             let r = crate::bidi::single_line(&mut child, te_id, &mut text, font, rect.width());
             a11y::own_focus(&r);
diff --git a/crates/ui-egui/src/windows.rs b/crates/ui-egui/src/windows.rs
index 510c24f69..6afcf1b1e 100644
--- a/crates/ui-egui/src/windows.rs
+++ b/crates/ui-egui/src/windows.rs
@@ -91,7 +91,9 @@ pub fn with_app<R>(f: impl FnOnce(&mut FigApp) -> R) -> Option<R> {
 /// Last-resort guard around a frame: a panic becomes a message and recovery copies of unsaved
 /// files, not a lost document.
 pub fn guard(app: &mut FigApp, ctx: &Context, f: impl FnOnce(&mut FigApp)) {
-    let res = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| f(&mut *app)));
+    // Started with automation roots, everything the window and the control channel do is confined.
+    let roots = app.automation_roots.clone();
+    let res = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| figcraft_engine::file_access::confined(roots.as_ref(), || f(&mut *app))));
     if let Err(e) = res {
         let msg = e.downcast_ref::<&str>().map(|s| s.to_string()).or_else(|| e.downcast_ref::<String>().cloned()).unwrap_or_else(|| "panic".into());
         log::error!("UI panic: {msg}");
@@ -208,13 +210,15 @@ pub fn open(app: &mut FigApp, ctx: &Context, index: Option<usize>, path: Option<
         docs: vec![uid],
         active: Some(uid),
         pane: Pane {
-            // A new window opens like the one it comes from: the same tabs and panel widths.
+            // A new window opens like the one it comes from: the same tabs, panel widths and pages
+            // list height.
             ui: UiState {
                 title_bar: app.ui.title_bar,
                 right_tab: app.ui.right_tab,
                 left_tab: app.ui.left_tab,
                 left_width: app.ui.left_width,
                 right_width: app.ui.right_width,
+                pages_height: app.ui.pages_height,
                 ..UiState::default()
             },
             ..Pane::default()
@@ -300,7 +304,12 @@ pub fn on_close_request(app: &mut FigApp, ctx: &Context) {
     if app.windows.current == 0 && (unsaved || !app.windows.list.is_empty()) {
         ctx.send_viewport_cmd(ViewportCommand::CancelClose);
     }
-    if unsaved {
+    request_close(app, ctx);
+}
+
+/// The custom title bar's Close button uses the same unsaved-file check as a system close event.
+pub(crate) fn request_close(app: &mut FigApp, ctx: &Context) {
+    if !app.unsaved().is_empty() {
         app.ui.confirm_close = true;
         ctx.request_repaint();
     } else {
@@ -313,8 +322,33 @@ fn close_current(app: &mut FigApp, ctx: &Context) {
     ctx.request_repaint_of(ViewportId::ROOT);
 }
 
-/// The unsaved-changes question when a window closes.
+/// What the unsaved-changes question was answered with.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum CloseAnswer {
+    /// Save every file with unsaved changes, then close (Save as for a file without a path).
+    Save,
+    /// Close and lose the changes.
+    DontSave,
+    /// Keep the window open.
+    Cancel,
+}
+
+/// The unsaved-changes question when a window closes: Don't Save / Cancel / Save, as the other
+/// Craft apps ask it.
 pub(crate) fn confirm_close(app: &mut FigApp, ctx: &Context) {
+    // A Save as this question started: once its dialog is answered, closing goes on if the file
+    // was saved; cancelled or failed, the window stays open.
+    if let Some(uid) = app.ui.close_after_save_as {
+        if app.pending_dialog.is_some() {
+            return;
+        }
+        app.ui.close_after_save_as = None;
+        // Saved: go on with the other files, then close.
+        if app.session.docs.iter().find(|d| d.uid == uid).is_none_or(|d| !d.is_dirty()) {
+            save_then_close(app, ctx);
+        }
+        return;
+    }
     if !app.ui.confirm_close {
         return;
     }
@@ -324,20 +358,76 @@ pub(crate) fn confirm_close(app: &mut FigApp, ctx: &Context) {
         return;
     }
     let t = crate::theme::Tokens::get(ctx);
-    let (mut open, mut discard, mut cancel) = (true, false, false);
-    crate::dialogs::window(tr("Unsaved changes"), ctx).open(&mut open).show(ctx, |ui| {
+    let mut open = true;
+    let mut answer = None;
+    crate::dialogs::window(tr("Unsaved changes"), ctx).order(egui::Order::Foreground).open(&mut open).show(ctx, |ui| {
         ui.set_width(340.0);
-        crate::widgets::label(ui, &trf("Unsaved changes in {names}. Close the window and lose them?", &[("names", &names.join(", "))]), t.text);
+        crate::widgets::label(ui, &trf("Unsaved changes in {names}. Save them before closing?", &[("names", &names.join(", "))]), t.text);
         ui.add_space(12.0);
         ui.horizontal(|ui| {
-            discard = crate::widgets::button(ui, tr("Close without saving"), true, true).clicked();
-            cancel = crate::widgets::button(ui, tr("Cancel"), false, true).clicked();
+            if crate::widgets::button(ui, tr("Don't Save"), false, true).clicked() {
+                answer = Some(CloseAnswer::DontSave);
+            }
+            if crate::widgets::button(ui, tr("Cancel"), false, true).clicked() {
+                answer = Some(CloseAnswer::Cancel);
+            }
+            if crate::widgets::button(ui, tr("Save"), true, true).clicked() {
+                answer = Some(CloseAnswer::Save);
+            }
         });
+        // Save is the default: Enter answers it when no button has the keyboard.
+        if answer.is_none() && ui.memory(|m| m.focused().is_none()) && ui.input(|i| i.key_pressed(egui::Key::Enter)) {
+            answer = Some(CloseAnswer::Save);
+        }
     });
-    app.ui.confirm_close = open && !discard && !cancel;
-    if discard {
-        close_current(app, ctx);
+    if !open {
+        answer = Some(CloseAnswer::Cancel);
     }
+    if let Some(a) = answer {
+        answer_close(app, ctx, a);
+    }
+}
+
+/// Act on the unsaved-changes question's answer.
+pub(crate) fn answer_close(app: &mut FigApp, ctx: &Context, answer: CloseAnswer) {
+    app.ui.confirm_close = false;
+    match answer {
+        CloseAnswer::Cancel => {}
+        CloseAnswer::DontSave => close_current(app, ctx),
+        CloseAnswer::Save => save_then_close(app, ctx),
+    }
+}
+
+/// Save each file of this window with unsaved changes, then close it. A file without a path (or
+/// one saved as .fig, which is never overwritten silently) asks where with Save as, and closing goes
+/// on when that dialog saved it ([`confirm_close`]). A save that fails shows why and keeps the
+/// window open.
+fn save_then_close(app: &mut FigApp, ctx: &Context) {
+    let files: Vec<u64> = app.session.docs.iter().filter(|d| app.shows(d.uid) && d.is_dirty() && d.branch_of.is_none()).map(|d| d.uid).collect();
+    for uid in files {
+        let Some(i) = app.session.docs.iter().position(|d| d.uid == uid) else { continue };
+        app.session.active = i;
+        let native = app
+            .session
+            .docs
+            .get(i)
+            .and_then(|d| d.path.as_deref())
+            .is_some_and(|p| !std::path::Path::new(p).extension().and_then(|e| e.to_str()).is_some_and(|e| e.eq_ignore_ascii_case("fig")));
+        if !native {
+            app.ui.close_after_save_as = Some(uid);
+            app.save_as_dialog();
+            if app.pending_dialog.is_none() {
+                // No dialog could start: stay open.
+                app.ui.close_after_save_as = None;
+            }
+            ctx.request_repaint();
+            return;
+        }
+        if app.run("file.save", json!({})).is_none() {
+            return;
+        }
+    }
+    close_current(app, ctx);
 }
 
 /// Before the main window draws: windows asked to close close, closed files leave their windows
diff --git a/crates/ui-egui/src/windows_tests.rs b/crates/ui-egui/src/windows_tests.rs
index 1a6e91bbc..a4e29212b 100644
--- a/crates/ui-egui/src/windows_tests.rs
+++ b/crates/ui-egui/src/windows_tests.rs
@@ -45,6 +45,25 @@ fn names(app: &FigApp) -> Vec<String> {
     app.session.docs.iter().map(|d| d.doc.name.clone()).collect()
 }
 
+#[test]
+fn closing_a_window_in_the_presenter_shows_the_unsaved_changes_dialog() {
+    let mut session = Session::new();
+    let frame_id = session.execute("node.create", &json!({"type": "frame", "width": 402, "height": 874})).unwrap()["id"].clone();
+    let ctx = egui::Context::default();
+    let mut app = FigApp::new(session, Box::new(NoServices));
+    frame(&ctx, &mut app, false);
+    app.session.execute("proto.present", &json!({"start": frame_id})).unwrap();
+    app.handle_ui_requests();
+    frame(&ctx, &mut app, false);
+    assert!(app.ui.present.is_some());
+
+    frame(&ctx, &mut app, true);
+    assert!(app.ui.confirm_close);
+    assert!(ctx.memory(|memory| memory.area_rect(egui::Id::new(Some(crate::i18n::tr("Unsaved changes")))).is_some()), "dialog must be on screen");
+    frame(&ctx, &mut app, false);
+    assert!(app.ui.present.is_some(), "asking to close does not dismiss the preview");
+}
+
 #[test]
 fn windows_hold_tabs_and_close_with_their_files() {
     let mut s = Session::empty();
@@ -116,13 +135,14 @@ fn another_hidden_window_answers_requests_that_need_no_frame_in_its_own_file() {
     assert_eq!(inspect.try_recv().expect("answered").result.unwrap()["name"], json!("A"));
     assert_eq!(app.session.ds().unwrap().doc.name, "B");
 
-    // What needs a frame keeps waiting for the other window; an unknown window is an error at once.
-    let ui = request(&mut app, "ui.inspect", json!({"window": w}));
+    // What needs a frame, and an unknown window, are errors at once: nothing waits for a window
+    // that may stay hidden.
+    let shot = request(&mut app, "ui.screenshot", json!({"window": w, "path": "unused.png"}));
     let unknown = request(&mut app, "window.list", json!({"window": 99}));
     logic(&ctx, &mut app, &[ViewportId::ROOT, other]);
-    assert!(ui.try_recv().is_err(), "waits for the window to show");
+    assert!(shot.try_recv().expect("answered").result.unwrap_err().contains(&format!("window {w} is minimised or hidden")));
     assert!(unknown.try_recv().expect("answered").result.unwrap_err().contains("no window 99"));
-    assert_eq!(app.control_queue.len(), 1);
+    assert!(app.control_queue.is_empty());
 }
 
 #[test]
@@ -150,3 +170,176 @@ fn a_request_for_a_window_on_screen_wakes_it_while_the_main_window_is_hidden() {
     assert!(ui.try_recv().is_err(), "answered in the other window's frame");
     assert!(woken.lock().unwrap().contains(&other), "the other window is asked to draw: {:?}", woken.lock().unwrap());
 }
+
+/// Answers each Save as with the next of `paths` (none left: cancelled) and counts the dialogs
+/// asked for.
+struct SaveAs {
+    paths: Vec<std::path::PathBuf>,
+    asked: std::rc::Rc<std::cell::Cell<usize>>,
+}
+
+impl crate::Services for SaveAs {
+    fn pick_save(&mut self, _title: &str, _name: &str, _exts: &[&str]) -> crate::DialogFuture {
+        self.asked.set(self.asked.get() + 1);
+        let next = if self.paths.is_empty() { None } else { Some(self.paths.remove(0)) };
+        Box::pin(std::future::ready(next))
+    }
+}
+
+fn temp_dir(tag: &str) -> std::path::PathBuf {
+    let d = std::env::temp_dir().join(format!("figcraft-close-save-{tag}-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&d);
+    std::fs::create_dir_all(&d).unwrap();
+    d
+}
+
+/// The main window with one file that has unsaved changes, saved at `path` first when given, and
+/// the window asked to close (the question shows).
+fn asking(path: Option<&std::path::Path>, save_as: Vec<std::path::PathBuf>) -> (egui::Context, FigApp, std::rc::Rc<std::cell::Cell<usize>>) {
+    let mut s = Session::new();
+    if let Some(p) = path {
+        s.execute("file.saveAs", &json!({"path": p.to_string_lossy()})).unwrap();
+    }
+    s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 10, "height": 10})).unwrap();
+    let asked = std::rc::Rc::new(std::cell::Cell::new(0));
+    let ctx = egui::Context::default();
+    let mut app = FigApp::new(s, Box::new(SaveAs { paths: save_as, asked: asked.clone() }));
+    frame(&ctx, &mut app, false);
+    frame(&ctx, &mut app, true);
+    assert!(app.ui.confirm_close, "the question shows");
+    (ctx, app, asked)
+}
+
+fn rects_in(path: &std::path::Path) -> usize {
+    let mut s = Session::new();
+    s.execute("file.open", &json!({"path": path.to_string_lossy()})).unwrap();
+    s.doc().unwrap().nodes().filter(|n| n.name.starts_with("Rectangle")).count()
+}
+
+/// A few frames, as the window draws them.
+fn settle(ctx: &egui::Context, app: &mut FigApp) {
+    for _ in 0..4 {
+        frame(ctx, app, false);
+    }
+}
+
+#[test]
+fn the_unsaved_changes_question_offers_save_dont_save_and_cancel() {
+    // As the other Craft apps ask it (#1170): Don't Save, Cancel, and Save as the default.
+    let (ctx, mut app, _) = asking(None, vec![]);
+    ctx.enable_accesskit();
+    frame(&ctx, &mut app, false);
+    let out = ctx.run_ui(RawInput::default(), |ui| app.ui(ui));
+    let nodes = out.platform_output.accesskit_update.expect("an AccessKit update").nodes;
+    let buttons: Vec<String> =
+        nodes.iter().filter(|(_, n)| n.role() == egui::accesskit::Role::Button).filter_map(|(_, n)| n.label().map(str::to_string)).collect();
+    for want in ["Don't Save", "Cancel", "Save"] {
+        assert!(buttons.iter().any(|b| b == want), "{want} in {buttons:?}");
+    }
+    assert!(!buttons.iter().any(|b| b == "Close without saving"));
+}
+
+#[test]
+fn save_saves_a_file_with_a_path_and_then_closes() {
+    let d = temp_dir("path");
+    let path = d.join("a.figcraft");
+    let (ctx, mut app, asked) = asking(Some(&path), vec![]);
+    assert_eq!(rects_in(&path), 0);
+    crate::windows::answer_close(&mut app, &ctx, crate::windows::CloseAnswer::Save);
+    settle(&ctx, &mut app);
+    assert_eq!(rects_in(&path), 1, "saved where it was");
+    assert_eq!(asked.get(), 0, "no Save as for a file with a path");
+    assert!(app.ui.quit, "then the window closes");
+    std::fs::remove_dir_all(&d).ok();
+}
+
+#[test]
+fn save_asks_where_for_an_untitled_file_and_closes_once_saved() {
+    let d = temp_dir("untitled");
+    let path = d.join("new.figcraft");
+    let (ctx, mut app, asked) = asking(None, vec![path.clone()]);
+    crate::windows::answer_close(&mut app, &ctx, crate::windows::CloseAnswer::Save);
+    settle(&ctx, &mut app);
+    assert_eq!(asked.get(), 1, "Save as asks where");
+    assert_eq!(rects_in(&path), 1, "saved there");
+    assert!(app.ui.quit, "then the window closes");
+    std::fs::remove_dir_all(&d).ok();
+}
+
+#[test]
+fn a_cancelled_save_as_or_a_failed_save_keeps_the_window_open() {
+    // Save as cancelled: nothing is written, the file keeps its changes and the window stays.
+    let (ctx, mut app, asked) = asking(None, vec![]);
+    crate::windows::answer_close(&mut app, &ctx, crate::windows::CloseAnswer::Save);
+    settle(&ctx, &mut app);
+    assert_eq!(asked.get(), 1);
+    assert!(!app.ui.quit && !app.ui.confirm_close, "open, and not asking again");
+    assert!(app.session.ds().unwrap().is_dirty());
+    assert_eq!(app.ui.close_after_save_as, None);
+
+    // The save fails (its folder is gone): the error shows and the window stays.
+    let d = temp_dir("gone");
+    let path = d.join("a.figcraft");
+    let (ctx, mut app, _) = asking(Some(&path), vec![]);
+    std::fs::remove_dir_all(&d).unwrap();
+    crate::windows::answer_close(&mut app, &ctx, crate::windows::CloseAnswer::Save);
+    settle(&ctx, &mut app);
+    assert!(!app.ui.quit, "a failed save keeps the window open");
+    assert!(app.session.ds().unwrap().is_dirty());
+}
+
+#[test]
+fn dont_save_closes_and_cancel_keeps_the_window() {
+    let d = temp_dir("answers");
+    let path = d.join("a.figcraft");
+    let (ctx, mut app, _) = asking(Some(&path), vec![]);
+    crate::windows::answer_close(&mut app, &ctx, crate::windows::CloseAnswer::Cancel);
+    settle(&ctx, &mut app);
+    assert!(!app.ui.quit && !app.ui.confirm_close);
+    frame(&ctx, &mut app, true);
+    crate::windows::answer_close(&mut app, &ctx, crate::windows::CloseAnswer::DontSave);
+    settle(&ctx, &mut app);
+    assert!(app.ui.quit, "Don't Save closes");
+    assert_eq!(rects_in(&path), 0, "without saving");
+    std::fs::remove_dir_all(&d).ok();
+}
+
+#[test]
+fn one_save_saves_every_untitled_file_of_the_window_then_closes() {
+    // Two new files with changes: Save asks where for each in turn, then the window closes,
+    // without asking the question again in between (#1173 review).
+    let d = temp_dir("two");
+    let (a, b) = (d.join("a.figcraft"), d.join("b.figcraft"));
+    let (ctx, mut app, asked) = asking(None, vec![a.clone(), b.clone()]);
+    app.session.execute("file.new", &json!({"name": "Second"})).unwrap();
+    app.session.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 10, "height": 10})).unwrap();
+    crate::windows::answer_close(&mut app, &ctx, crate::windows::CloseAnswer::Save);
+    for _ in 0..8 {
+        frame(&ctx, &mut app, false);
+        assert!(!app.ui.confirm_close, "not asked again");
+    }
+    assert_eq!(asked.get(), 2);
+    assert_eq!((rects_in(&a), rects_in(&b)), (1, 1), "both saved");
+    assert!(app.ui.quit);
+    std::fs::remove_dir_all(&d).ok();
+}
+
+#[test]
+fn enter_answers_save() {
+    let d = temp_dir("enter");
+    let path = d.join("a.figcraft");
+    let (ctx, mut app, _) = asking(Some(&path), vec![]);
+    frame(&ctx, &mut app, false);
+    let enter = |pressed| egui::Event::Key { key: egui::Key::Enter, physical_key: None, pressed, repeat: false, modifiers: egui::Modifiers::NONE };
+    let input = RawInput { events: vec![enter(true), enter(false)], ..Default::default() };
+    ctx.run_ui(input, |ui| {
+        crate::windows::on_close_request(&mut app, ui.ctx());
+        app.ui(ui);
+    })
+    .textures_delta
+    .clear();
+    settle(&ctx, &mut app);
+    assert_eq!(rects_in(&path), 1, "Enter saved");
+    assert!(app.ui.quit);
+    std::fs::remove_dir_all(&d).ok();
+}
diff --git a/crates/ui-egui/tests/canvas_pan_release.rs b/crates/ui-egui/tests/it/canvas_pan_release.rs
similarity index 98%
rename from crates/ui-egui/tests/canvas_pan_release.rs
rename to crates/ui-egui/tests/it/canvas_pan_release.rs
index c54d20dca..cd1a6e1cc 100644
--- a/crates/ui-egui/tests/canvas_pan_release.rs
+++ b/crates/ui-egui/tests/it/canvas_pan_release.rs
@@ -1,6 +1,5 @@
 //! A canvas pan (middle button or Space + primary) ends when its button is released, even when the
 //! release happens over a panel: returning to the canvas with no button held must not move the view.
-#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
 
 use egui::{Event, Key, PointerButton, Pos2, RawInput, Rect, vec2};
 use figcraft_engine::Session;
diff --git a/crates/ui-egui/tests/comment_open_other_page.rs b/crates/ui-egui/tests/it/comment_open_other_page.rs
similarity index 100%
rename from crates/ui-egui/tests/comment_open_other_page.rs
rename to crates/ui-egui/tests/it/comment_open_other_page.rs
diff --git a/crates/ui-egui/tests/file_menu_pdf.rs b/crates/ui-egui/tests/it/file_menu_pdf.rs
similarity index 97%
rename from crates/ui-egui/tests/file_menu_pdf.rs
rename to crates/ui-egui/tests/it/file_menu_pdf.rs
index 30b847b75..812529e07 100644
--- a/crates/ui-egui/tests/file_menu_pdf.rs
+++ b/crates/ui-egui/tests/it/file_menu_pdf.rs
@@ -1,6 +1,5 @@
 //! File > Export frames to PDF: the menu asks where to save and writes the frames' PDF there,
 //! one visible top-level frame per page.
-#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
 
 use std::path::PathBuf;
 
diff --git a/crates/ui-egui/tests/guide_label_narrow.rs b/crates/ui-egui/tests/it/guide_label_narrow.rs
similarity index 97%
rename from crates/ui-egui/tests/guide_label_narrow.rs
rename to crates/ui-egui/tests/it/guide_label_narrow.rs
index 6c4276adc..464fbfedc 100644
--- a/crates/ui-egui/tests/guide_label_narrow.rs
+++ b/crates/ui-egui/tests/it/guide_label_narrow.rs
@@ -1,5 +1,3 @@
-#![allow(clippy::unwrap_used)]
-
 use egui::{Pos2, RawInput, Rect, Vec2, vec2};
 use figcraft_engine::Session;
 use figcraft_ui_egui::{FigApp, NoServices};
diff --git a/crates/ui-egui/tests/it/main.rs b/crates/ui-egui/tests/it/main.rs
new file mode 100644
index 000000000..007f450d1
--- /dev/null
+++ b/crates/ui-egui/tests/it/main.rs
@@ -0,0 +1,11 @@
+//! The crate's integration tests, built as one test binary.
+
+#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+mod canvas_pan_release;
+mod comment_open_other_page;
+#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+mod file_menu_pdf;
+#[allow(clippy::unwrap_used)]
+mod guide_label_narrow;
+#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+mod recent_file_names;
diff --git a/crates/ui-egui/tests/recent_file_names.rs b/crates/ui-egui/tests/it/recent_file_names.rs
similarity index 97%
rename from crates/ui-egui/tests/recent_file_names.rs
rename to crates/ui-egui/tests/it/recent_file_names.rs
index 461d0c731..41e37ec25 100644
--- a/crates/ui-egui/tests/recent_file_names.rs
+++ b/crates/ui-egui/tests/it/recent_file_names.rs
@@ -1,5 +1,4 @@
 //! Recent file rows keep their full accessible name.
-#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
 
 use egui::{Context, Id, Pos2, RawInput, Rect, accesskit::Role, vec2};
 use figcraft_engine::Session;
diff --git a/crates/ui-egui/tests/type_settings_long_labels.rs b/crates/ui-egui/tests/type_settings_long_labels.rs
new file mode 100644
index 000000000..113b4daf1
--- /dev/null
+++ b/crates/ui-egui/tests/type_settings_long_labels.rs
@@ -0,0 +1,47 @@
+//! #1029, through the whole app: in a language whose labels run past Type settings' label column,
+//! the popover keeps its width while it stays open. French does with Inter (release builds, the
+//! report); Georgian does with egui's own fonts too (CI, which builds without craft-fonts). Its own
+//! test binary, since the UI language is one setting for the whole process.
+#![allow(clippy::unwrap_used)]
+
+use egui::{Id, Popup, Pos2, RawInput, Rect, vec2};
+use figcraft_engine::Session;
+use figcraft_ui_egui::{FigApp, NoServices};
+use serde_json::json;
+
+/// The Type settings popover's width over the frames it is open, the UI in `language`.
+fn widths(language: &str) -> Vec<f32> {
+    let mut s = Session::new();
+    s.execute("pref.language", &json!({"language": language})).unwrap();
+    // Truncating text also shows Max lines.
+    let text = s.execute("text.create", &json!({"text": "Type", "props": {"textAutoResize": "truncate"}})).unwrap()["id"].clone();
+    s.execute("select.set", &json!({"ids": [text]})).unwrap();
+    let ctx = egui::Context::default();
+    let mut app = FigApp::new(s, Box::new(NoServices));
+    let open = Id::new("ty_settings_open");
+    let mut widths = Vec::new();
+    for i in 0..40 {
+        if i == 3 {
+            Popup::open_id(&ctx, open);
+        }
+        let raw =
+            RawInput { screen_rect: Some(Rect::from_min_size(Pos2::ZERO, vec2(1440.0, 900.0))), time: Some(i as f64 / 60.0), ..Default::default() };
+        ctx.run_ui(raw, |ui| app.ui(ui)).textures_delta.clear();
+        // From the frame after the one it opened on (egui's sizing pass).
+        if i > 3 {
+            assert!(Popup::is_id_open(&ctx, open), "{language}: Type settings closed on frame {i}");
+            widths.push(ctx.memory(|m| m.area_rect(open)).unwrap().width());
+        }
+    }
+    widths
+}
+
+#[test]
+fn type_settings_keeps_its_width_with_labels_longer_than_their_column() {
+    for language in ["ka", "fr"] {
+        let w = widths(language);
+        assert_ne!(figcraft_ui_egui::i18n::tr("Paragraph indent"), "Paragraph indent", "{language} is shown");
+        // The width it asks for (`Popup::width`), every frame.
+        assert!(w.iter().all(|x| (x - 264.0).abs() < 0.01), "{language}: Type settings widens: {} → {}", w[0], w[w.len() - 1]);
+    }
+}
diff --git a/docs/auto-layout-parity.md b/docs/auto-layout-parity.md
index ae230608f..ea2cc54f5 100644
--- a/docs/auto-layout-parity.md
+++ b/docs/auto-layout-parity.md
@@ -1,6 +1,6 @@
 # Auto layout and constraints parity
 
-> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-13 · **Change:** minor (core editor leftovers: auto gap handles, wrapped-line alignment; behaviour suite written from the public documentation, every rule's status; fixes and the missing settings it found) · **Target:** Figma Design (desktop app 126.10.7)
+> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-17 · **Change:** minor (adding auto layout to an empty frame keeps its size (#369); `node.set` applies auto layout keys only to frames, with warnings (#603); core editor leftovers: auto gap handles, wrapped-line alignment; behaviour suite written from the public documentation, every rule's status; fixes and the missing settings it found) · **Target:** Figma Design (desktop app 126.10.7)
 
 Auto layout is the most used layout feature in Figma and the one where small differences (a
 hugging frame one pixel off, text wrapping at another width) break real files. **Breadth ~98%,
@@ -69,7 +69,7 @@ Status: **pass** (a case in the suite holds), **fixed** (the suite found a diver
 | Arrow keys move children one place (flows, rows, columns, grid cells, into neighbours) | done | `al_keys_tests.rs` |
 | Constraints: left, right, left and right, centre, scale; top/bottom likewise | done | |
 | Layout grids: columns, rows, grid; stretch/left/centre/right; variables bound | done | |
-| Suggest auto layout / "Add auto layout" on a selection | done | |
+| Suggest auto layout / "Add auto layout" on a selection | done | adding auto layout to an empty frame keeps its size, Fixed (it collapsed to 20×20); a frame with content still hugs it, as does a new frame wrapped around a selection (#369). `node.set` with auto layout keys on a mix of layers applies them to the frames and warns about the rest instead of failing the whole call (#603) |
 | Real Figma files laid out identically | **not checked** | needs `.fig` or REST import of real files ([gaps](gaps.md) #1, #3) |
 | Performance: re-flow only where sizes or places changed | done | measured in `cargo xtask bench` (components at scale) |
 
@@ -77,6 +77,7 @@ Status: **pass** (a case in the suite holds), **fixed** (the suite found a diver
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-17 | minor | Community batch #753: adding auto layout to an empty frame keeps its size, Fixed, while a frame with content hugs it (#369); `node.set` applies auto layout keys to the frames among its targets and warns about the others, and a font style the family lacks warns with the nearest face (#603). Checked over MCP. Numbers unchanged |
 | 2026-10-13 | minor | Auto layout, on-canvas handles of automatic gaps (M2): the handle between spread rows or columns (and between items with an auto gap) shows the distance the layout gives the gap instead of the stored value, and dragging it makes the gap a fixed one from there, as typing a gap in the panel does; one undo step (`gap_handle_tests`). Before, the drag changed a value that had no effect. The documentation is silent on dragging an automatic gap. Numbers unchanged. |
 | 2026-10-13 | minor | Auto layout, wrapped-line alignment (M2): a wrapping layout's lines (rows of a horizontal one, columns of a vertical one) are packed where the cross alignment says (start, centre, end; before, they always sat at the start), stretch when every child fills across the flow, or take the free space between them (`contentAlign: spaceBetween`, the Design panel's Row/Column gap mode, the alignment pad lighting the whole cross axis). Read from REST JSON and `.fig`, written to `.fig`, `align-content` in CSS, an instance override with the other alignment settings. 13 hand-computed layout cases and command tests. Numbers unchanged. |
 | 2026-10-11 | minor | Behaviour suite from the public documentation (64 layout cases, 8 command tests). Fixed: padding floor, inside-only included strokes (and included by default), auto gaps stop at 0, grid `fr` like CSS `fr`, canvas stacking actually drawn and hit. Added: auto gaps evenly/around, vertical wrap, grid cell alignment, strokes and canvas stacking controls. Breadth 95% → 98%, ready 68% → 74%, remaining 6–12 h → 3–6 h |
diff --git a/docs/boards-parity.md b/docs/boards-parity.md
new file mode 100644
index 000000000..b6928dd70
--- /dev/null
+++ b/docs/boards-parity.md
@@ -0,0 +1,61 @@
+# Boards parity
+
+> **Last reviewed:** 2026-10-24 · **Last updated:** 2026-10-24 · **Change:** major (created: board files, the first slice of the whiteboard workflow) · **Target:** the incumbent's whiteboard product (behaviour from its public help centre)
+
+**Breadth ~35%, ready ~20% (estimated, erring low).** A board is a FigCraft file of its own kind
+(`file.newBoard`) with sticky notes, shapes with text, connectors that follow what they join,
+marker, highlighter and eraser, stamps, text and sections, edited together in the existing live
+sessions. The facilitation tools (timer, voting, widgets), templates, tables, mind maps and the
+rest of the tail are missing. Remaining: ~30–60 h. Tracked as area 22 of
+[`target-app-parity.md`](target-app-parity.md) (not in its weighted sum: the target there is the
+design product). The work item is gap 24 in [`gaps.md`](gaps.md).
+
+## How boards are built
+
+Board objects are ordinary layers with a small `board` field on the node (`figcraft_doc::BoardItem`),
+so rendering, hit testing, undo, saving, SVG/PNG/PDF export, copy and paste and live sessions work
+on them unchanged. The file kind (`Document.kind`) is saved in `.figcraft` and reaches people who
+join a live session in their snapshot. What follows from the metadata (a sticky's text size, a
+shape's text room, connector routes and their labels) is recomputed in the engine's normalize pass,
+deterministically from the document, so local edits, undo and edits from others in a live session
+all end with the same geometry.
+
+## Features
+
+| Feature | Status | Notes |
+|---|---|---|
+| Board files: File ▸ New board, the home screen's New board card, a light page | done | `file.newBoard`; the kind shows in `inspect_document`, tabs and file rows (a note mark; design files a pen nib) |
+| Board toolbar at the bottom | done | Move/Hand, Marker/Highlighter/Eraser, Sticky (colour flyout), Shapes (flyout), Connector, Text, Section, Stamp (flyout), Comment, Resources, Actions, the Design panel's button |
+| Design panel hidden by default; a contextual bar above the selection | done | colour, shape, text size (S/M/L/XL), connector straight/elbow and its arrow; the Design panel opens with its button or View ▸ Design panel |
+| Prototyping and Dev Mode refuse on boards | done | `proto.*`, `dev.*`, `view.prototype`, `view.devMode` say why |
+| Sticky notes | done | a square frame (200 wide, growing taller through auto layout), 8 soft colours, a soft shadow, the note's text size shrinking as it grows (24 → 11, by characters and lines), the author's name at the bottom; a click places one and starts typing; Enter or a double-click edits; Shift+Cmd/Ctrl+Enter adds the next one beside it |
+| Sticky options: hide the author, change size presets, sticky stacks | partial | `board.sticky {author: false}`; no size presets or stacks |
+| Shapes with text | done | rectangle, rounded rectangle, ellipse, diamond, triangle, speech bubble, chevron; text centred and wrapping inside the outline; shape type and text size from the contextual bar |
+| Shape auto-fit to its text, more shapes (cylinder, cross, star…), shape libraries | missing | |
+| Connectors | done | from a layer's side (the facing one, or one named) to another layer or a free point, straight or elbow, arrowheads (the stroke's caps), a label in the middle (double-click to add); re-routed when either end moves or resizes; a deleted end stays where it was |
+| Curved connectors, connector waypoints, dragging an end to re-attach | missing | ends are attached when drawn or through `board.connector` |
+| Quick-create handles (drag out a connected copy) | missing | |
+| Marker and highlighter | done | the Pencil's stroke fitting with board presets: marker opaque, highlighter wide, see-through and multiplying |
+| Eraser | done | drag over marker and highlighter strokes to remove them, one undo step |
+| Pen colours and widths in the toolbar | partial | `tool.marker {color}`, `tool.highlighter {color}`; colour changes on a selected stroke from the contextual bar |
+| Stamps | done | thumbs up, heart, plus one, star, question, check: round badges drawn as vectors, the placer's name on hover |
+| Stamps sticking to the object they land on, the stamp wheel, emotes, stickers | missing | |
+| Text and sections | done | the existing Text tool and sections |
+| Live sessions: cursors, selections, cursor chat, spotlight | done | the existing sessions; board objects, connectors following moved objects, colours and stamps sync both ways (checked with two app instances) |
+| Timer and music | missing | |
+| Voting sessions | missing | |
+| Board widgets | missing | design-file widgets exist (`crates/engine/src/widgets.rs`), not wired to boards |
+| Templates (retrospective, brainstorm, flow chart…) | missing | |
+| Tables | missing | |
+| Mind maps | missing | |
+| Washi tape, code blocks, image cropping on boards | missing | images can be placed as in design files |
+| Audio and huddles | missing | |
+| AI features (summaries, sorting stickies, generating boards) | missing | |
+| Dot grid on the page | missing | the canvas grid is drawn over the render; a dot grid needs a render pass under the layers |
+| `.jam` import and export | missing | see [`file-format-parity.md`](file-format-parity.md) |
+
+## Revision history
+
+| Date | Change | Summary |
+|---|---|---|
+| 2026-10-24 | major | Created with board files (M12): sticky notes, shapes with text, connectors, ink and eraser, stamps, the board toolbar and contextual bar, live-session sync |
diff --git a/docs/cli.md b/docs/cli.md
index 9f5df40ef..91288f140 100644
--- a/docs/cli.md
+++ b/docs/cli.md
@@ -4,7 +4,9 @@ FigCraft without a window: inspect, export, convert and render documents, run co
 commands, serve MCP and measure performance. Build it with
 `cargo build --release -p figcraft-cli` (binary `target/release/figcraft-cli`).
 
-Bad arguments print usage and exit with code 2; failures exit with 1. The CLI never panics on input.
+`figcraft-cli --help` (or `-h`, or `help`) prints usage on stdout and exits with 0, and so does
+`--help` or `-h` after a subcommand (`figcraft-cli mcp --help`). Bad arguments print usage and exit
+with code 2; failures exit with 1. The CLI never panics on input.
 
 ## Fonts
 
@@ -29,7 +31,9 @@ be open to the public: [server.md](server.md#running-a-public-server)). See [ser
 ### `info <file> [--json]`
 
 Pages, node counts, top-level frames (id, type, name, size), style/variable/image counts. Repairs
-of a damaged file and import warnings go to stderr as `note:` lines (`notes` with `--json`).
+of a damaged file and import warnings go to stderr as `note:` lines (`notes` with `--json`). Fonts the
+file names that aren't installed are listed as `missing font` lines (`missingFonts: [{family,
+layers}]` with `--json`); their text renders in a fallback font.
 
 Every subcommand that reads a file also takes the public REST API file JSON (the response of
 `GET /v1/files/:key` or of its nodes endpoint, written to a `.json` file): it is imported on the fly.
@@ -49,6 +53,10 @@ page 1 "Screens": 380 nodes, 4 top-level
 
 - `<out>` is a directory: one file per top-level frame of the page (default the first page), named
   after the frame (`Home.png`, `Settings.png`…); with no frames, one file per top-level layer.
+  The name is kept as it is, except for the characters file systems refuse (`/ \ : * ? " < > |`
+  and control characters), which become `_`, and leading or trailing spaces and dots, which are
+  dropped. A name is cut at 100 characters. The app's export replaces the same characters (there a
+  `/` makes a folder). Two layers with the same name get `Name 2`, `Name 3`…
 - `<out>` has an image extension: one file with the given `--node`, or the whole page composited.
 - `--node` takes a layer id (`12` or `0:12`) or a layer name.
 - `--format fig` (or an `<out>` ending in `.fig`) writes the whole file as `.fig`, experimental:
@@ -103,7 +111,29 @@ Runs commands in a headless session (a new document, or `--in`), printing one JS
 {"command":"frame.create","ok":true,"result":{"id":2},"step":0}
 ```
 
-A failing step prints `"ok": false` with the error and exits with code 1 (nothing is saved).
+The whole script is **one undo step**, and it is **all-or-nothing**, exactly like running the same
+commands through `command.batch` (the MCP tool `batch`, the control channel, plugins): `{"$step": n}`
+in a step's params is the `id` in an earlier step's result, so a step can target a layer an earlier
+step of the same script created:
+
+```json
+[
+  {"command": "node.create", "params": {"type": "frame", "name": "Card", "width": 200, "height": 100}},
+  {"command": "node.create", "params": {"type": "text", "parent": {"$step": 0}, "text": "Hi"}}
+]
+```
+
+The result lines are printed once the script is through, so none of them reports work a later step
+took back.
+
+A failing step prints one line with `"ok": false`, the error and `"rolledBack": true`, writes
+nothing (`--out` is not saved, and the session's documents go back to how the script found them),
+and exits with code 1:
+
+```text
+{"step":1,"command":"node.set","ok":false,"error":"no such node 99999","rolledBack":true}
+```
+
 `--out` saves the result by extension like `convert`.
 
 Script formats: a JSON array of `{"command": id, "params": {...}}`, an object
@@ -129,15 +159,42 @@ figcraft-cli run start.json --out dashboard.figcraft
 figcraft-cli export dashboard.figcraft -o dashboard.png
 ```
 
+### Confining a run: `--automation-read-root DIR` / `--automation-write-root DIR`
+
+`info`, `export`, `convert`, `render` and `run` take these two flags, with the same meaning they
+have on [`mcp`](#mcp---attach-port---automation-read-root-dir---automation-write-root-dir): each is
+repeatable, each folder must exist, and together they confine every file that subcommand touches.
+Reads are allowed inside a read or write root, writes only inside a write root, and everything else
+is refused — so a run given only a read root cannot write at all. Without either flag a subcommand
+reads and writes as the user who started it.
+
+```sh
+# Renders in/doc.figcraft to out/ok.png and can touch nothing else.
+figcraft-cli render in/doc.figcraft -o out/ok.png \
+  --automation-read-root in --automation-write-root out
+
+figcraft-cli render in/doc.figcraft -o ./escaped.png \
+  --automation-read-root in --automation-write-root out
+# error: automation path rejected: . is outside the folders that may be written: …/out
+```
+
+This is for driving the CLI from a script or an agent that should not reach the rest of the disk;
+the flags leave the output identical when nothing strays outside the roots.
+
 ### `commands [--json] [--filter TEXT]`
 
 Every command with its label, shortcut, undoable flag (`*`) and parameter docs; `--json` for
 machines.
 
-### `mcp [--attach PORT]`
+### `mcp [--attach PORT] [--automation-read-root DIR]… [--automation-write-root DIR]…`
 
 Serve MCP on stdio: headless by default, or attached to a running app started with
-`figcraft --control PORT`. See [mcp.md](mcp.md). The headless session can host, join and publish
+`figcraft --control PORT`. See [mcp.md](mcp.md). The automation roots (each repeatable; existing
+folders) confine the files the agent's calls read (inside a read or write root) and write (inside a
+write root); everything else is refused ([mcp.md › Confining file access](mcp.md#confining-file-access)).
+They apply to the headless session only, and that is why `--attach` refuses them: an attached server
+is confined by the app it attaches to, from the flags that app was started with. The headless
+session can host, join and publish
 live sessions (`collab.*`: without a key on a server open to the public, with `collab.serverInfo`,
 `collab.manageFile` for the owner token and `collab.report`) and use plugin directories
 (`plugin.directory.*`); the one-shot `run` can't (no network link).
diff --git a/docs/collaboration-parity.md b/docs/collaboration-parity.md
index 95084d740..ae503633d 100644
--- a/docs/collaboration-parity.md
+++ b/docs/collaboration-parity.md
@@ -1,6 +1,6 @@
 # Collaboration parity
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-14 · **Change:** minor (removing someone from a live session; live-session revert guard; live sessions per document; a public figcraft-server: open hosting, owner tokens, per-address limits, idle expiry, moderation, install.sh; cursor chat and spotlight in live sessions; branch version history and finer list merges; comments and version history behaviour suite and fixes; hosting the server: `wss://` in the desktop app, server releases, deployment guide; team libraries on the server and swap library; branches: create, update from main, review and merge; wording: the standalone server with share links to edit or view; numbers unchanged) · **Target:** Figma Design (desktop app 126.10.7)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-17 · **Change:** minor (server message limits follow `max_file_mb`; a damaged log generation field keeps flushed edits; the web build joins from a `#join=` link; removing someone from a live session; live-session revert guard; live sessions per document; a public figcraft-server: open hosting, owner tokens, per-address limits, idle expiry, moderation, install.sh; cursor chat and spotlight in live sessions; branch version history and finer list merges; comments and version history behaviour suite and fixes; hosting the server: `wss://` in the desktop app, server releases, deployment guide; team libraries on the server and swap library; branches: create, update from main, review and merge; wording: the standalone server with share links to edit or view; numbers unchanged) · **Target:** Figma Design (desktop app 126.10.7)
 
 Figma is multiplayer first; FigCraft is local first. **Ready ~13% (estimated):** comments, version
 history and branches (review and merge) work inside one file; the real-time collaboration core landed in #103 (sync model,
@@ -12,10 +12,10 @@ cursors, selections, text carets, cursor chat and spotlights shown live ([`colla
 
 | Feature | Figma | FigCraft | Hours |
 |---|---|---|---|
-| Real-time co-editing | yes | **core built, no networking** (#103): client-scoped ids, per-property change sets with fractional positions, server ordering and validation, optimistic clients, binary messages; randomized multi-client convergence tests over real commands. Live sessions over the network landed (`crates/collab-net`): the WebSocket transport (keep-alive, size and rate limits, reconnect with backoff), hosting from the app (this machine or the local network) with invite links, live cursors with name tags, selections, avatars and follow, `collab.*` commands. Document sync between apps works over them (the host's server orders every batch; guests open the host's file as a new tab). Sessions are per document: each open file has its own or none, several run at once (host one, join another, publish a third) and keep syncing behind the tab in front, and closing a file ends its session only. Revert to saved is refused until the document leaves its live session; its access checks and sync association stay intact. Undo is per person (only your own steps, others' later writes left alone), refused edits roll back with a toast, and a reconnect resumes as the same client with what it missed (or a snapshot) and sends what was made offline. The browser build joins (same messages through the browser's WebSocket API); `figcraft://` invite links open the desktop app and join. Styles, variables, collections, modes and comments made in a session take ids from their creator's space (the server checks it), so concurrent creations all survive; modes, per-mode values and replies inside one entry still resolve last-writer-wins. A standalone `figcraft-server` keeps many files, persists them (a snapshot plus a log, compacted), loses nothing confirmed across a restart (apps resume as the same participants) and takes files published from the app (File ▸ Publish to server…). The desktop app and the CLI open `wss://` links too (TLS through a reverse proxy), and releases ship the server for Linux with a deployment guide (systemd, Caddy, nginx, Docker) and `install.sh`. A server can be open to the public: anyone publishes without the key, within limits per address, and files nobody opens expire. Left: server archives beyond Linux | 25–55 |
+| Real-time co-editing | yes | **core built, no networking** (#103): client-scoped ids, per-property change sets with fractional positions, server ordering and validation, optimistic clients, binary messages; randomized multi-client convergence tests over real commands. Live sessions over the network landed (`crates/collab-net`): the WebSocket transport (keep-alive, size and rate limits, reconnect with backoff), hosting from the app (this machine or the local network) with invite links, live cursors with name tags, selections, avatars and follow, `collab.*` commands. Document sync between apps works over them (the host's server orders every batch; guests open the host's file as a new tab). Sessions are per document: each open file has its own or none, several run at once (host one, join another, publish a third) and keep syncing behind the tab in front, and closing a file ends its session only. Revert to saved is refused until the document leaves its live session; its access checks and sync association stay intact. Undo is per person (only your own steps, others' later writes left alone), refused edits roll back with a toast, and a reconnect resumes as the same client with what it missed (or a snapshot) and sends what was made offline. The browser build joins (same messages through the browser's WebSocket API); `figcraft://` invite links open the desktop app and join. Styles, variables, collections, modes and comments made in a session take ids from their creator's space (the server checks it), so concurrent creations all survive; modes, per-mode values and replies inside one entry still resolve last-writer-wins. A standalone `figcraft-server` keeps many files, persists them (a snapshot plus a log, compacted), loses nothing confirmed across a restart (apps resume as the same participants) and takes files published from the app (File ▸ Publish to server…). The desktop app and the CLI open `wss://` links too (TLS through a reverse proxy), and releases ship the server for Linux with a deployment guide (systemd, Caddy, nginx, Docker) and `install.sh`. A server can be open to the public: anyone publishes without the key, within limits per address, and files nobody opens expire. Message limits follow the server's `max_file_mb`, so files above 64 MiB publish and open (the client takes at most 1 GiB from a server, and the server warns when large limits meet open publishing, #705); a damaged generation field in a file's log no longer drops the edits flushed to it (#687). Left: server archives beyond Linux | 25–55 |
 | Live cursors, selections, viewports; follow / observation mode; spotlight | yes | **done, in live sessions**: named cursors, selection outlines, avatars, follow (click an avatar), others' text carets and selected characters with their names, a note when two people type in one layer; spotlight (your avatar's menu, `collab.spotlight`): everyone follows your view and page, people who join later too, anyone who moves their view stops following and a banner offers to follow again, a newer spotlight takes over. Left: polish (no accounts, so anyone in the session can spotlight) | 2–4 |
 | Cursor chat, audio, high-fives | yes | **partial, in live sessions**: cursor chat (`/` opens a bubble at your pointer; everyone sees it as you type, it fades a few seconds after the last change, Enter sends and Escape takes it back, 100 characters; `collab.cursorChat` for agents); sent as ephemeral presence the host checks and rate-limits, never stored. No audio, high-fives or emote reactions | 2–5 |
-| Share links, permissions (view / edit), teams and projects | yes | **partial**: sharing with a join code from the Share popover (online: the file goes to the server in Preferences and the server names its edit and view links with short codes; local network: the app hosts and the code carries its address; one field joins with a code or a link, in the popover and on the home screen); `figcraft-server` share links per file with edit or view access (a viewer sees changes and presence, a "View only" badge and only the moving tools; the server refuses its edits), revocable at once, tokens stored as hashes; managed from the app's Share popover (first links), the server's command line or a managing connection. On a server open to the public, whoever published a file manages it with its owner token (links, name, removal: `collab.manageFile`), which the app remembers: Home ▸ Online lists your online files (open again as owner, start and stop sharing, copy the code, rename, remove, forget), with one request per server for what became of them; anyone in a file can report it, and the operator blocks addresses. The person hosting a session, or a file's owner, removes someone from it (right-click their avatar, `collab.removePerson`): they are disconnected and their address can't join that file again while it runs. The list is per computer: no accounts, teams or projects | 8–17 |
+| Share links, permissions (view / edit), teams and projects | yes | **partial**: sharing with a join code from the Share popover (online: the file goes to the server in Preferences and the server names its edit and view links with short codes; local network: the app hosts and the code carries its address; one field joins with a code or a link, in the popover and on the home screen; the browser build also joins from a link in its URL's fragment, `#join=…`, which never reaches the web host's logs, capped at 6 KiB and checked like a `figcraft://` link (#712; unit-tested, not run in a browser)); `figcraft-server` share links per file with edit or view access (a viewer sees changes and presence, a "View only" badge and only the moving tools; the server refuses its edits), revocable at once, tokens stored as hashes; managed from the app's Share popover (first links), the server's command line or a managing connection. On a server open to the public, whoever published a file manages it with its owner token (links, name, removal: `collab.manageFile`), which the app remembers: Home ▸ Online lists your online files (open again as owner, start and stop sharing, copy the code, rename, remove, forget), with one request per server for what became of them; anyone in a file can report it, and the operator blocks addresses. The person hosting a session, or a file's owner, removes someone from it (right-click their avatar, `collab.removePerson`): they are disconnected and their address can't join that file again while it runs. The list is per computer: no accounts, teams or projects | 8–17 |
 | Comments: pins on frames and layers, threads, reactions, @mentions, resolve, unread, search and filters, links, in the presenter | yes (shared) | **done, local**: stored in the file, your name from Preferences; a behaviour suite from the documentation (pinning and following layers, threads, own edits and deletes, mentions, reactions, C and Shift+C, stepping, filters, saving, copy and paste); restoring a version keeps them. In a live session threads sync and anyone in it can reply, react and resolve (no accounts: a name is who you are) | (shared once multiplayer lands) |
 | Version history: named versions, autosave checkpoints, view before restore, restore, duplicate | yes (cloud) | **done**, saved in the `.figcraft` file: restoring keeps the replaced design as an autosave first, a titled autosave becomes a named version, merging a branch records the file before and after. Versions are per person in a live session (a shared history needs accounts); no comparing two versions (Dev Mode compares a ready-for-dev layer with its state when marked) | — |
 | Branching and merging | yes (paid plans) | **done, local**: branches saved in the `.figcraft` file, each opened in its own tab; Review and merge shows both sides' changes since the branch was made and the conflicts (the same property on both sides, or a layer deleted on one side and edited on the other), each resolved for the branch or main; merge as one undo step (the branch is archived, the main file's history gets a version for the merge), update from main, archive. Each branch keeps its own version history (saved, viewed and restored on the branch tab, kept when it is merged or archived); fills, strokes and effects merge item by item. Left: branches in live sessions; other lists (text runs, export settings) conflict as a whole | 1–2 |
@@ -26,6 +26,7 @@ cursors, selections, text carets, cursor chat and spotlights shown live ([`colla
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-17 | minor | From community batch #735: server message limits follow `max_file_mb`, so files above 64 MiB publish and open, the client takes at most 1 GiB and the server warns about large limits with open publishing (#705); a damaged generation field no longer drops a log's flushed edits (#687); the web build joins a session from a `#join=` link in its URL (#712, unit-tested and built for wasm, not run in a browser). Percentages and hours unchanged |
 | 2026-10-14 | minor | Removing someone from a live session (M9, from the owner's use: whoever joined with the invite couldn't be put out short of ending the session for everyone): right-click a person's avatar ▸ "Remove <name> from session", or `collab.removePerson {client}`, when you host the session or own the file on a server (owner token). The hub closes their connection as the session's end for them (they keep their copy and don't reconnect) and bars their address from that file while the session or server runs, so the code or link they hold no longer gets them in; everyone else stays. Protocol addition within version 2 (`Admin removePeer`; older servers say they can't). Addresses are the only identity without accounts: people behind one address are barred together. Percentages and hours unchanged |
 | 2026-10-13 | minor | Live-session revert guard (M9, #198): `file.revert` is refused while its document belongs to a live session, including publishing, reconnecting and hosting before the welcome. The document, previews, branch tabs and session stay intact; leave the session before reverting a local save. Offline revert is unchanged. Scripted access and sync regressions in `live_access_tests`. Numbers unchanged. |
 | 2026-10-12 | minor | Your online files (M9): a file put on a server without its key stays its owner's after its tab closes or the app quits. The app records each one with the preferences (server, id, name, owner token, the owner's links, the codes others join with; at most 200; the token never in a command result, `ui.inspect`, a log or debug output) and Home ▸ **Online** lists them: open one as its owner (a new tab, or its tab comes to the front), Start / Stop sharing, Copy code / Copy link, Rename on the server, Remove from server (confirmed), Forget (the file stays on the server). Nothing is asked of a server until the section opens; then one request per server (`Admin owned`, a compatible addition within protocol version 2) says which files are still there, and a server that is offline or older leaves the list as recorded. Tabs of files in a live session carry a mark (shared, or open only to you), toasts about a file that isn't in front name it, and after a crash a recorded file reopens from its server as its owner, its recovery copy kept until its unsent changes are back on the server (or it is opened beside the file). `collab.files`, `collab.openFile`, `collab.forgetFile`; `collab.manageFile` takes its server and token from the record and gains `share` / `unshare`. Files are known per computer, not per person (no accounts): percentages and hours unchanged |
diff --git a/docs/components-parity.md b/docs/components-parity.md
index 659676fd4..7f7c162fc 100644
--- a/docs/components-parity.md
+++ b/docs/components-parity.md
@@ -1,6 +1,6 @@
 # Components, variants, styles and variables parity
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-14 · **Change:** minor (variables export in the browser as a download; core editor leftovers: component playground, variables inside styles; layers and assets panels behaviour suite and fixes; extended collections tail; styles and variables behaviour suite and fixes; components behaviour suite and fixes; team libraries on the server, library usage and swapping a library; extended collections, variables import/export, gradient stops and variant properties bound to variables) · **Target:** Figma Design (desktop app 126.10.7)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-23 · **Change:** minor (instance-swap properties in the component playground; duplicating or Alt-dragging a main component makes an instance of it (#892); a bound colour variable's alpha applies once (#802); variables import reads `variables` outside `meta` and warns when it imports none (#790); variant properties reorder by drag; library files saved right after a read are read again; Hide when publishing note corrected; size and resizing overrides of layers inside instances (#731); variables export in the browser as a download; core editor leftovers: component playground, variables inside styles; layers and assets panels behaviour suite and fixes; extended collections tail; styles and variables behaviour suite and fixes; components behaviour suite and fixes; team libraries on the server, library usage and swapping a library; extended collections, variables import/export, gradient stops and variant properties bound to variables) · **Target:** Figma Design (desktop app 126.10.7)
 
 Design systems are why teams adopt Figma. **Components: breadth ~96%, ready ~72%. Styles and
 variables: breadth ~95%, ready ~76% (estimated).** QA'd with a synthetic design system of ~300
@@ -14,21 +14,22 @@ accounts).
 |---|---|---|
 | Create component, instances, detach, reset, go to main, restore main, push changes | done | push from a nested layer goes to the outer main |
 | Per-layer overrides with reset; kept across main edits, nested swaps, copy/paste | done | main edits match a full rebuild exactly at 2,000 instances |
-| What an instance overrides: fills, strokes, effects, visibility, layer names, text content and every text property (resizing included), auto layout padding, gap and alignment, layout grids, export settings, prototype interactions, nested swaps and property values | done | each kept when the main changes that property, reset per group; opacity and corner radius too (documentation silent) |
-| What it doesn't: position, rotation, size, constraints and resizing of layers inside it, its auto layout direction and other settings, its structure | done | refused with a message, the fields greyed out; the instance itself resizes and its layers follow the main's constraints |
-| Component sets / variants, add variant, switch | done | |
+| What an instance overrides: fills, strokes, effects, visibility, layer names, text content and every text property (resizing included), auto layout padding, gap and alignment, layout grids, export settings, prototype interactions, nested swaps and property values; the size and resizing (hug, fill, fixed, min and max) of layers inside it | done | each kept when the main changes that property, reset per group; opacity and corner radius too (documentation silent); size and resizing are kept through relayout, undo, save, `.fig` and REST import and detach, and stay with the instance on push |
+| What it doesn't: position, rotation, constraints and absolute or grid placement of layers inside it, its auto layout direction and other settings, its structure | done | refused with a message, the fields greyed out; the instance itself resizes and its layers follow the main's constraints |
+| Component sets / variants, add variant, switch | done | Combine as variants is in the Object menu, and the canvas and layers context menu and the Design panel offer it when two or more main components are selected; Add variant on a main component not in a set yet makes it a set of itself and the new variant, one undo step (#903); components that are variants already aren't combined again (it used to put a set inside a set) |
+| A main's copy within its file is an instance of it: Duplicate, Alt-drag, Copy then Paste | done | a variant duplicated in its set stays a new variant and a whole set copies as a new set; only the copied roots become instances (a main inside a copied frame is copied as a main); Cut then Paste and pastes into other files keep the component (#892) |
 | Switching variants keeps overrides where names match and both variants had the same value; text layers keep theirs | done | |
 | Default variant: the top-left one (new instances, Assets thumbnail, generated code) | done | |
-| Variant property order (names rewritten), duplicate combinations reported | done | reordering through `component.editProperty {index}`; no drag in the panel yet |
+| Variant property order (names rewritten), duplicate combinations reported | done | drag a property in the Properties section to reorder it, one undo step (#679), or `component.editProperty {index}` |
 | Properties: boolean, text, instance swap (preferred values), variant | done | |
 | Slots (preferred components, fill menu, kept across updates) | done | Figma 2025 feature |
 | Exposed nested instances | done | hidden ones hide their properties |
 | Descriptions | done | |
 | Instance swap: panel, Alt-drop from Assets | done | the panel keeps overrides on same-named layers, an Alt-drop from Assets only text layers' |
 | Assets panel: folders by page, frame and slash names (fold away), thumbnails, search, drag into frames and auto layout slots | done | virtualized; `component.list` gives each one's `folder` |
-| Hidden from publishing: a leading `.` or `_` in the name | done | the name decides both ways (adding the prefix takes a published component out, removing it brings it back); no Hide when publishing menu item yet |
+| Hidden from publishing: a leading `.` or `_` in the name | done | the name decides both ways (adding the prefix takes a published component out, removing it brings it back); Hide when publishing in the Assets panel's context menu and Libraries ▸ Hide when publishing (see [ui-parity](ui-parity.md)) |
 | Instances pasted into other files follow their mains | done | missing main restorable |
-| Component playground (try properties without placing) | partial | variant, boolean and text properties in the Inspect tab and `component.playground`; instance swaps and slots have no control there yet (0.5–1 h) |
+| Component playground (try properties without placing) | partial | variant, boolean, text and instance-swap properties in the Inspect tab (the swap menu lists the preferred components first, then every component in the file, as in the Design panel) and `component.playground`; slots have no control there yet |
 | Real-world libraries QA | **not checked** | [gaps](gaps.md) #3 |
 
 The behaviour of instances, overrides, variants and swaps is checked against the public
@@ -48,7 +49,7 @@ updates with overrides kept: `library_tests.rs`, `components_scale_tests.rs`.
 |---|---|---|
 | Publish a file's components, sets, styles and variables (per-asset versions) | done | as local library files |
 | Enable a library in a file; read-only linked copies | done | |
-| Library updates available; overrides kept | done | |
+| Library updates available; overrides kept | done | a library file saved again within two seconds of being read, at the same length, is read again (its time stamp can't prove it unchanged; #652) |
 | Team libraries: publish to a `figcraft-server` under the file, enable by a share link (a view link reads it), background update checks | done | [server.md](server.md#team-libraries); no team-wide library list or accounts ([gaps](gaps.md) #10) |
 | Library analytics | partial | instances per component and the files using them, as apps report them; nothing over time, no detach counts |
 | Swap library (instances, styles and variables to another library's of the same names, overrides kept) | done | what has no match stays and is listed; one undo step |
@@ -65,17 +66,23 @@ updates with overrides kept: `library_tests.rs`, `components_scale_tests.rs`.
 | Modes: add, duplicate, rename, delete, set as default / reorder | done | layers on Auto follow a new default; explicit modes stay |
 | Deleting a bound variable or its collection | done | layers keep their last value and are unbound; aliases to it take its values |
 | Code syntax per platform (Web, iOS, Android) | done | generated CSS uses the Web name; in the variables JSON; SwiftUI/Compose code doesn't name variables yet |
-| Bindings: fills, strokes, effects, opacity, padding, gaps, sizes, radius, font size/weight, line height, letter spacing, paragraph spacing/indent, text, visibility, layout grids, instance properties | done | type-checked per field; number variables fill text content |
+| Bindings: fills, strokes, effects, opacity, padding, gaps, sizes, radius, font size/weight, line height, letter spacing, paragraph spacing/indent, text, visibility, layout grids, instance properties | done | type-checked per field; number variables fill text content; a colour variable bound to a solid paint brings its whole colour, alpha included, once (the paint's opacity restarts at 100% on binding, an opacity set while bound multiplies on top; unbinding moves the alpha back into the opacity) |
 | Explicit modes per frame, library collections' modes | done | |
 | Gradient stops and variant properties bound to variables | done | a stop's binding follows it when earlier stops are removed |
 | Extended collections | done | library collections, including a library's own extended collections (chains through libraries); overrides per mode with reset; follow library updates, variables new to the library collection being an update of their own; modes inherited. Checked with synthetic libraries only ([gaps](gaps.md) #14) |
-| Variables import/export (JSON) | done | the REST local variables shape (round-trips; merges by collection, mode and variable name); CSS custom properties export; in the browser the export arrives as a download (import there still needs a file picker) |
+| Variables import/export (JSON) | done | the REST local variables shape (round-trips; merges by collection, mode and variable name; `variableCollections` and `variables` read under `meta` or at the top level, a warning when no variables are found or fewer than the collections list); CSS custom properties export; in the browser the export arrives as a download (import there still needs a file picker) |
 | Expressions in prototype set-variable actions | done | see [prototyping-parity](prototyping-parity.md) |
 
 ## Revision history
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-23 | minor | Instance-swap properties in the component playground: the Inspect tab's Playground shows a dropdown for each, with the same menu as the Design panel's (the property's preferred components first, then every component in the file). The component picked changes the preview and the code only, never the file. Left: slots in the playground. Numbers unchanged. |
+| 2026-10-20 | minor | A main component's copy within its file is an instance of it (#892): Duplicate (`edit.duplicate`) and Alt-drag on the canvas made a second main; they now place an instance where the copy went (same offset, the instance's default name, selected), as Copy then Paste already did. A variant duplicated in its set stays a new variant. |
+| 2026-10-18 | minor | A bound colour variable's alpha applies once (#802): a `#RRGGBBAA` paint keeps its alpha in the paint opacity, and binding a variable with alpha left that opacity in place, so a 50% fill bound to a 50% variable drew at 25%. Binding (`variable.bind`, `node.set` `boundVariables`, `style.bind`) now restarts the paint's opacity at 100% and unbinding (also deleting the variable) moves the colour's alpha back into the opacity; `.fig` and REST imports take the variable's alpha back out of a bound paint's opacity, so `.fig` round trips no longer square it. Colour-picker edits of a colour variable or a plugin colour field, generated CSS strokes and the document colours list counted the paint opacity twice and now count it once (`bound_alpha_tests`). Numbers unchanged |
+| 2026-10-18 | minor | Variables import (#790): a `variables` map outside `meta` (or `meta.variables` next to top-level collections) is read, and an import that finds no variables, or fewer than the collections' `variableIds` list, says so in `warnings` instead of succeeding silently |
+| 2026-10-17 | minor | Variant properties reorder by dragging them in the Properties section, one undo step (#679; was "no drag in the panel yet"); a library file saved again right after it was read is read again, so a quick republish isn't missed (#652); the Hidden from publishing row no longer says the Hide when publishing item is missing (it landed 2026-10-12). Numbers unchanged |
+| 2026-10-17 | minor | Size and resizing overrides of layers inside instances (#731): a layer in an instance can hug, fill or keep a size of its own (group `resizing`: hug/fill/fixed with min and max; `size`), from the Layout panel, the canvas handles and `node.set`; they were refused, and imported ones were dropped at the first relayout. Kept through main edits of other properties, rebuilds, undo, save, `.fig` and REST import (sizes a `.fig` instance gives its layers and the REST `overrides` fields), `.fig` export and detach; reset per group and with Reset all changes (`instance_resizing_tests`). The row that listed them as not overridable was wrong. Numbers unchanged. |
 | 2026-10-14 | minor | Variables export in the browser: Export… ▸ Variables JSON / CSS custom properties did nothing in the web build, which has no save dialogs; it now hands the file over as a download (`Services::downloads` / `download`, `variables_export_ui_tests`). Import in the browser still needs a file picker, as do the other exports there. Numbers unchanged. |
 | 2026-10-13 | minor | Component playground (M3): with an instance, a component or a component set selected, the Inspect tab shows a Playground: a preview of the component and a control for each variant, boolean and text property. What is tried there changes the preview and the code in the Code section, never the file (no undo step, the canvas instance stays as it is); Reset goes back to the component's or the instance's own values. `component.playground {id?, properties?, language?, path?}` gives the same to scripts: the properties with their values, the code, and a PNG on request (`playground_tests`). Left: instance-swap and slot properties in the playground (the command takes an instance swap; the panel has no control for it), a code connect template's snippet with the tried values. Numbers unchanged. |
 | 2026-10-13 | minor | Variables inside styles (M3): a shared style can bind variables to fields of its value (`style.bind {style, field, variable?}`: a paint style's colours and gradient stops, an effect style's colour, radius, spread and offsets, a grid style's size, count, gutter and offset, a text style's font size, line height, letter spacing, family and style). Every layer using the style shows those fields resolved in its own modes and stays linked when a variable or a mode changes; the style keeps them resolved in the default modes. A style made from a layer keeps that layer's bindings; a new value drops bindings to what is gone. The style editor binds from its property rows (paint colour, shadow colour, blur radius, grid size) and detaches from the variable's chip; the style picker marks styles that use variables. `.fig` export and import carry the bindings on the style, REST layers hand theirs to the style they use. Left: binding text style fields and the other effect and grid fields from the editor (commands only), library variables in the picker, a style's library copy. Numbers unchanged. |
diff --git a/docs/control-protocol.md b/docs/control-protocol.md
index 397aed5b7..3941bd8ab 100644
--- a/docs/control-protocol.md
+++ b/docs/control-protocol.md
@@ -37,11 +37,15 @@ requests still queued after the UI timeout are discarded, including requests def
 window. A command already running is not interrupted.
 
 A minimised or covered window (the main one or another, see Windows below) draws no frames, but
-still answers `engine.execute`, `engine.commands`, `document.inspect`, `node.get`, `window.list`
-and `ui.render`, acting on the file that window shows, so an attached agent can edit, inspect and
-save while the app is out of sight. Screenshots, input (`ui.input`,
-`ui.pointer`, `ui.key`, `ui.type`) and the interface's own state wait for the window to show, and
-time out after 60 s if it doesn't.
+still answers every method that acts on the app's state (`engine.execute`, `document.inspect`,
+`node.get`, `ui.inspect`, `ui.pointer`, `ui.key`, `ui.type`, `ui.set`, `ui.render`, `window.list`,
+…), in the file that window shows, so an attached agent can edit, inspect and save while the app is
+out of sight. The app is not drawn meanwhile and only wakes for requests, at most ten times a
+second while minimised, so a request there takes up to about 0.1 s. What only a drawn frame can
+answer (`ui.screenshot`, `ui.input`, `window.new`) is an error at once (`window 0 is minimised or
+hidden: …`) instead of waiting for the window to show; `ui.render` draws the document without it.
+Under Wayland the app can't tell that its window is minimised: where the compositor then stops
+drawing it, a request waits for the window and gets the 60 s timeout error.
 
 Coordinates are page units, y down. `x`/`y` in `node.set`/`node.create` are relative to the parent
 frame (groups have no coordinate space of their own).
@@ -53,6 +57,32 @@ window, with its tabs, panels and canvas: `engine.execute` acts on the file it s
 last in front (the one the user clicked last, or the last `window.new` / `window.focus`). An
 unknown id is an error.
 
+## Confining file access
+
+```sh
+figcraft --control 7979 --automation-read-root /work/project --automation-write-root /work/project/out
+```
+
+`--automation-read-root <dir>` and `--automation-write-root <dir>` (each repeatable, `--flag=<dir>`
+works too; the same flags as `figcraft-cli mcp`) confine the files the app reads and writes for
+whoever asks: every control request (`engine.execute`, `ui.render`, `ui.screenshot`, `window.new`,
+`ui.key`, `ui.menu.invoke`…) and every frame of every window, so input injected with `ui.input`
+and what a person does in the window are held to the same folders. Files are read only inside a
+read or write root and written only inside a write root; anything else is an ordinary error reply
+(`automation path rejected: …`), and recent files outside the roots aren't listed. Paths are
+resolved as `docs/mcp.md` › Confining file access describes. A root that isn't an existing folder
+stops the app before its window opens, and so does any option the app doesn't know (a mistyped
+flag such as `--automation-write-roots` exits with `unknown option`, never starts unconfined).
+Without the flags nothing changes. The flags arrived in FigCraft 0.7.0: 0.6.0 and earlier ignore
+them and confine nothing.
+
+Not confined: opening the files given on the command line when the app starts and the documents
+the system hands over (Finder, Open With; saving them later is confined like any write), and the
+app's own folders (preferences, recovery copies, plugins installed from a plugin directory). Run `figcraft-cli mcp --attach PORT` without the flags against
+such an app (it refuses them: the app does the confining). `ui.screenshot` and `ui.render` without a
+`path` return the PNG as data, which is how the attached MCP server takes them, so it writes no
+temporary files.
+
 ## Methods
 
 ### `engine.execute {command, params?}`
@@ -101,7 +131,9 @@ component/instance links, overrides, `slot` (a slot layer's property name), boun
 `devStatus` (handoff status), `devChanged` (changed since it was marked ready for dev),
 `annotations` (Dev Mode notes: `[{label, properties, category?}]`), `codeLinks` (a component's
 links to code: `[{language, importPath, name, template}]`), `devResources` (links for developers,
-its own and inherited: `[{name, url, index?, from?}]`). The auto layout props
+its own and inherited: `[{name, url, index?, from?}]`), `pluginData` (layer data written with
+`node.set {props: {pluginData: {key: value}}}`, pages included: `{key: value}`, values as strings;
+only when there is some). The auto layout props
 that `node.set` accepts are listed in [mcp.md](mcp.md#conventions-agents-must-know).
 
 ### `ui.inspect {}`
@@ -117,7 +149,13 @@ zoom preview or the refined image (`canvas.quality`: `preview` or `refined`) and
 asking for a render to its preview and its refined image being handed to egui as the canvas
 texture (`canvas.previewLatencyMs`, `canvas.refineLatencyMs`, on a monotonic clock, rendering
 included in the browser too; the GPU upload and presenting the frame come after; `null` until
-there was one). While a prototype plays, `presenter`
+there was one). `importReport` holds the Import report window's content (`{name, pages, layers, images, appended, placed, warnings, warningCount}`,
+`null` while none is open). The window opens only for a file the user opened or imported in the app
+(File ▸ Open or Import, Open recent, a recent file on the home screen, a drop, a paste, the system's open event).
+Emulated user input counts as the user's action: `ui.input` and `ui.key` (for example a Cmd+V paste or a click
+on a menu item) can open it. Commands sent through this channel with `engine.execute`, MCP, `window.new {path}`
+and files named on the command line never open it.
+`file.open` and `file.import` return the counts as `summary`. While a prototype plays, `presenter`
 (full window) and `preview` (the preview pane) hold the player's state: the `current` frame and its
 `name`, `start`, `history`, open `overlays`, how many delayed mouse triggers are `waiting`, the screen's `scroll` offset and `scrollRange`, the
 `device` (and whether it is turned to `landscape`, its `deviceColor`) and the `viewport` of the frame
@@ -136,7 +174,10 @@ instance, a dragged axis slider; see `text.preview` in [mcp.md](mcp.md)).
 `canvas` or `properties`), whether `keyboard` mode is on (F6 or Tab moved the focus since the last
 pointer press, so the focus ring shows) and the name of the `control` with the keyboard (what a
 screen reader announces; empty when nothing has it). `reduceMotion` is true when the preference or
-the system's accessibility setting turns the interface's animations off. `live` is the live
+the system's accessibility setting turns the interface's animations off. `uiScale` is the interface
+size: the `choice` (relative to the system's display scale, `pref.uiScale`), the `zoom` drawn
+(relative too), what that is in physical pixels per point (`drawn`) and whether the window is too
+small for the choice (`limited`, so `zoom` is smaller). `live` is the live
 session of the window's active file as the window shows it (sessions are per file: another tab
 shows its own, or `status: "off"`): `session` (its id, null when the file isn't in one),
 `sessions` (how many the app has running), `status`, `role`, the number of `peers`, who you `follow`, the
@@ -165,7 +206,8 @@ A mouse gesture with the current tool. `kind`: `down`, `move`, `up`, `click`, `d
 (`x`, `y`) or screen pixels (`sx`, `sy`). `pressure` (0–1) is pen pressure (the Pencil records
 it); a drag's pressure goes from `pressure` to `pressureTo`. Returns `{selection, tool}`. With the Move and Scale
 tools, a press on a frame's or section's name label (as the canvas last drew it, along a rotated
-frame's top edge) selects and drags that frame.
+frame's top edge) selects and drags that frame; a double-click there renames the frame in place in
+the desktop app (the name field opens over the label).
 
 ```json
 {"id":4,"method":"engine.execute","params":{"command":"tool.set","params":{"tool":"ellipse"}}}
@@ -214,12 +256,13 @@ separate calls. Returns `{queued}`.
 
 Invoke a menu item exactly like clicking it (this may open a dialog). Returns `{ok, lastError}`.
 
-### `ui.set {rightTab?, leftTab?, theme?, home?, homeSection?, homeRecentsView?, homeRecentsSort?, homeRecentsOrder?, palette?, mainMenu?, focusRegion?, colorPicker?, variables?, layerFilter?, collapseLayers?, exportPreview?, preview?, presentScroll?, colorProfileDialog?, stylePicker?, stylePickerEdit?, stylePickerView?, iconGallery?, protoEditor?, contextMenu?, contextSelectLayer?, commentOpen?, commentDraft?, commentFilter?, commentSort?, commentSearch?, commentReply?, commentEdit?, presentComments?, devCompare?, devCompareMode?, devCompareSplit?, annotationFilter?, resetFrameStats?, pluginsWindow?, pluginsTab?, pluginConfirm?, pluginForm?}`
+### `ui.set {rightTab?, leftTab?, theme?, home?, homeSection?, homeSearch?, homeRecentsView?, homeRecentsSort?, homeRecentsOrder?, palette?, mainMenu?, focusRegion?, colorPicker?, variables?, layerFilter?, collapseLayers?, exportPreview?, preview?, presentScroll?, colorProfileDialog?, stylePicker?, stylePickerEdit?, stylePickerView?, iconGallery?, protoEditor?, contextMenu?, contextSelectLayer?, commentOpen?, commentDraft?, commentFilter?, commentSort?, commentSearch?, commentReply?, commentEdit?, presentComments?, devCompare?, devCompareMode?, devCompareSplit?, annotationFilter?, resetFrameStats?, pluginsWindow?, pluginsTab?, pluginConfirm?, pluginForm?, devCompareVersion?}`
 
 Switch panels and modes: `rightTab` `design|prototype|inspect`, `leftTab` `file|assets`, `theme`,
 `home` (bool), `homeSection` (`recents`, `online` or `templates`: which section the home screen shows, as `ui.inspect` reports it; opening
 `online` asks each server once what became of your online files), `homeRecentsView` (`grid|list`), `homeRecentsSort` (`modified|name|created`) and `homeRecentsOrder` (`desc|asc`): how the home screen shows its recent files (kept in the preferences; `ui.inspect` reports them under `homeRecents` with each file and whether its picture is in), `palette` (bool: the Actions palette), `mainMenu` (bool, or a top-level menu such
-as `"Plugins"` to open the main menu with it open), `pluginsWindow` (bool: Plugins ▸ Manage
+as `"Plugins"` to open the main menu with it open), `homeSearch` (text, at most 256 characters: filters locally known open, recent and online files plus starter templates in Home; an empty string returns to the selected section),
+`pluginsWindow` (bool: Plugins ▸ Manage
 plugins…), `pluginsTab` (`installed|browse`: that window's tab), `pluginConfirm` (a plugin id of the
 directory listed last: its install confirmation shows, as its Install button would; `null` closes
 it), `pluginForm` (`{id, command?}`: start that plugin command like its menu item, opening
@@ -250,24 +293,28 @@ closes it), `commentDraft` (`{x, y}`: start a new comment there), `commentFilter
 text, focused with the cursor at its end: an `@` there shows the mention picker), `commentEdit` (a
 message index of the open thread to edit, 0 for the first; `null` stops), `presentComments` (bool:
 the presenter shows the presented frame's comments, also Shift+C there). Dev Mode: `devCompare` (a
-ready-for-dev frame or section id opens the Compare changes view, like `dev.compare {id, show:
-true}`; `null` closes it) with `devCompareMode` (`sideBySide|overlay`) and `devCompareSplit` (the
+frame or section id opens the Compare changes view, like `dev.compare {id, show:
+true}`; `null` closes it) with `devCompareVersion` (a version id to compare with; `null`: when it
+was marked ready for dev), `devCompareMode` (`sideBySide|overlay`) and `devCompareSplit` (the
 overlay slider, 0–1), `annotationFilter` (`all`, `none` for uncategorised, or a category id or name:
 the annotations the canvas shows). `resetFrameStats` (true: start `framesDrawn` and
 `repaintCauses` over). Returns `ui.inspect` (which reports `stylePicker`,
 `stylePickerView`, `comments`: `open`, `draft`, `filter`, `sort`, `search`, `editing` and the
-`mentions` the picker offers, `devCompare` (`{id, mode, split}` or `null`), `devFocus` (the frame the
+`mentions` the picker offers, `devCompare` (`{id, mode, split, version}` or `null`), `devFocus` (the frame the
 focus view shows, or `null`) and `annotationFilter`).
 
-### `ui.screenshot {path}`
+### `ui.screenshot {path?}`
 
 PNG of the whole window (`window` picks one), UI included (needs a visible window; an idle one draws the frame to
-capture). Returns `{path, width, height}`, or an error after 60 s when the window doesn't deliver.
+capture). Returns `{path, width, height}`, without `path` `{format: "png", width, height, data}`
+(base64); an error at once when the window is minimised or hidden, or after 60 s when the window
+doesn't deliver.
 
-### `ui.render {path, scale?, ids?}`
+### `ui.render {path?, scale?, ids?}`
 
 PNG of the document without UI chrome (works without a window). Without `ids` it exports the
-selection, else the page's top-level layers. Returns the export result.
+selection, else the page's top-level layers. Returns the export result: written to `path`, or
+`{format: "png", data}` (base64) without one.
 
 ### `window.new {path?, index?}`
 
diff --git a/docs/dev-mode-parity.md b/docs/dev-mode-parity.md
index cba5e81df..bf3cc7373 100644
--- a/docs/dev-mode-parity.md
+++ b/docs/dev-mode-parity.md
@@ -1,23 +1,26 @@
 # Dev Mode parity
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-12 · **Change:** minor (dev resources links; inspect behaviour suite and fixes: colour formats, rem, blend, positions from the frame, CSS for rotation, gradients and text, icons and images as assets; code connect and Dev Mode plugins) · **Target:** Figma Design Dev Mode (desktop app 126.10.7)
+> **Last reviewed:** 2026-10-15 · **Last updated:** 2026-10-15 · **Change:** minor (import lines in generated layer trees; compare with any saved version; Dev Mode behaviour suite: an inspect-only canvas, Changed in the ready list, statuses only on frames and sections; plugin panels from the Inspect tab) · **Target:** Figma Design Dev Mode (desktop app 126.10.7)
 
-**Breadth ~96%, ready ~72% (estimated).** The inspect surface is broad, components connect
-to the code components of a repository and layers carry dev resources links; left: import lines
-inside generated layer trees. Remaining: 0–1 h.
+**Breadth ~97%, ready ~76% (estimated).** The inspect surface is broad, components connect
+to the code components of a repository (with their imports, also inside generated layer trees),
+changes compare with any saved version and the canvas only inspects in Dev Mode. Left: measurements
+kept on the canvas, a read-only layers panel in Dev Mode, publishing mappings from the code
+repository. Remaining: 2–4 h.
 
 | Feature | Status | Notes |
 |---|---|---|
-| Dev Mode toggle (Shift+D), Inspect panel | done | |
+| Dev Mode toggle (Shift+D), Inspect panel | done | the canvas only inspects: presses select, pan and comment but never move, resize, draw or edit text and vectors; menus and shortcuts refuse design edits with a note (Dev Mode's annotations, statuses, dev resources, code connections and comments still work); a drawing tool chosen in the toolbar goes back to the design. The layers panel and dropped files still edit (ours to tighten) |
 | Properties with their styles and variables; redlines on hover | done | positions from the frame around the layer (groups aren't frames), rotation, radius (CSS corner order), opacity, blend; colours in hex, RGB, CSS, HSL or HSB (`inspect.properties {colorFormat}`, the Inspect tab's Color format) |
 | Code: CSS, iOS (SwiftUI), Android (Compose) | done | plus HTML, React and Leptos (ours; Leptos: `#[component]` functions with `#[prop]` defaults, variant enums and `view!` markup); components take properties as parameters, instances are calls; CSS in px or rem (`inspect.code {unit, rootFontSize}`), with rotation, blend modes, gradient directions and kinds (linear, radial, conic), text alignment, case and decoration |
 | Assets list with export | done | layers with export settings, icons (small, vector shapes only: SVG) and images (PNG); the icon rule is ours |
 | Annotations: pinned properties, categories, coloured callouts, filter | done | |
-| Ready for dev list, statuses, "Changed" after edits | done | |
+| Ready for dev list, statuses, "Changed" after edits | done | the list filters Ready for dev, Changed, Completed or any, and badges changed ones (`inspect.readyForDev {status: changed}`, `changed` per item); only sections and frames at the top of a page or section take a status (others are refused) |
 | Focus view (one frame, previous / next) | done | |
-| Compare changes (before/after side by side or overlaid, property diffs) | done | only against the snapshot taken when a frame was marked ready; not against any named version |
-| Code connect (map components to repository code) | done | per language (React, Leptos, SwiftUI, Compose): import path, name and a template with `{property}` and `{property ? "a" : "b"}` placeholders; instances (also inside generated layer trees) show the snippet with their values; edited in the Inspect panel with a live preview; `figcraft.connect.json` export/import. Inside a generated layer tree, connected instances' imports aren't collected |
-| Plugins in Dev Mode (Jira, GitHub, etc.) | partial | FigCraft's own WASM plugins that only read run from the Inspect tab; no plugin UI at run time, no third-party integrations |
+| Compare changes (before/after side by side or overlaid, property diffs) | done | against the snapshot taken when a frame was first changed after it was marked ready, or any saved version (`dev.compare {version}`; the view's Compare with menu); a frame that isn't ready for dev compares with versions |
+| Code connect (map components to repository code) | done | per language (React, Leptos, SwiftUI, Compose): import path, name and a template with `{property}` and `{property ? "a" : "b"}` placeholders; instances (also inside generated layer trees) show the snippet with their values; edited in the Inspect panel with a live preview; `figcraft.connect.json` export/import; generated layer trees bring the import lines of the connected components they call (also in definitions, slots and swapped-in instances) once each at the top, per language. No CLI publishing mappings from the code repository |
+| Plugins in Dev Mode (Jira, GitHub, etc.) | partial | FigCraft's own WASM plugins that only read run from the Inspect tab, with their panels (callbacks can only read); no third-party integrations |
+| Measurements (redlines on hover, Alt in the design) | partial | distances between the selection and the hovered layer, its parent or a guide, auto layout padding and gaps (Shift+Alt); measurements kept on the canvas for others aren't there |
 | VS Code extension | out of scope | FigCraft's MCP server and control channel already serve design data, code and connected snippets to agents and editors |
 | Dev resources links on layers | done | a URL and a name per link on any layer (`devResource.*`, saved, synced, undoable); instances list their main component's (and its set's) read-only; URLs checked as http/https and never fetched (no page titles: a link without a name is named after its URL); the Inspect tab lists, adds, edits and removes them; `get_node` returns them |
 
@@ -25,6 +28,7 @@ inside generated layer trees. Remaining: 0–1 h.
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-15 | minor | Dev Mode tail (gap 16): generated layer trees (React, Leptos, SwiftUI, Compose) start with the import lines of the connected components they call, once each, also those in a component's definition, in slots an instance fills and placed by a connected template's instance swaps; Compare changes takes any saved version as the before (`dev.compare {version}`, the view's Compare with menu; frames that aren't ready for dev compare with versions). Behaviour suite (5 tests; 4 failed before the fixes): the Dev Mode canvas only inspects (no moving, resizing, drawing, text or vector editing; menus, shortcuts, nudges, opacity keys and paste refuse design edits with a note; toolbar drawing tools go back to the design), the ready list filters and badges Changed items, statuses are refused on layers inside frames. Read-only plugins run from the Inspect tab show their panels (the runtime's panels, reused). Breadth 96% → 97% (measurements kept on the canvas and the read-only layers panel counted as missing), ready 72% → 76%, 0–1 h → 2–4 h |
 | 2026-10-12 | minor | Dev resources (gap 16): links for developers (a URL and a name) on any layer: `devResource.add` / `edit` / `remove` / `list`, undoable, saved and synced; an instance also lists its main component's (and that component's set's) links read-only with where they come from, and layers inside an instance show their main layer's; URLs are checked as web links (http or https, a host, no spaces, at most 2,048 characters) and never fetched (a link added without a name is named after its URL), opened only when clicked; the Inspect tab lists, adds, edits and removes them; `get_node` and `inspect_document` return them as `devResources`. The editor extension stays out of scope (the MCP server serves agents and editors). Dev Mode breadth 93% → 96%, ready 70% → 72%, 1–3 h → 0–1 h; feature breadth (~82%) and ready for real work (~51%) unchanged at this rounding; full parity ~304–593 h → ~303–591 h |
 | 2026-10-11 | minor | Export and inspect behaviour suite written from the public documentation (139 cases in 19 tests; 47 failed before the fixes) and its fixes: an export covers what the layer paints, so a drop shadow adds room only where it falls, strokes on boxes and ellipses reach their real width (they added up to four times as much), hidden layers take no room and a mask group exports the mask's area; a slice exports everything under it; slashes in layer names export into folders; Copy as PNG copies the whole selection. Added: the export settings' contents only and include bounding box, and for SVG outline text (off writes `<text>`), unique id attributes and simplified strokes (stroke attributes where exact); Inspect colour formats (hex, RGB, CSS, HSL, HSB), CSS in rem, a Blend row, positions measured from the frame around a layer (groups aren't frames), CSS for rotation, blend modes, gradient directions and kinds, text alignment, case and decoration; icons and images in the asset list (`file.exportLayers {assets}`). Dev Mode breadth 90% → 93%, ready 64% → 70%, hours unchanged (1–3, dev resources); feature breadth and ready for real work unchanged at this rounding |
 | 2026-10-11 | minor | Code connect and Dev Mode plugins (gap 16): a component or set links to its code component per language (import path, name, a template with `{property}` and `{property ? "a" : "b"}` placeholders); `inspect.code`, `inspect.componentCode` and the Inspect panel show that snippet with the instance's values (also inside generated layer trees), edited in Connect to code with a live preview; links are saved, synced and undoable, and travel as `figcraft.connect.json` (`codeConnect.export` / `codeConnect.import`). Plugins that only read run from the Inspect tab. Dev Mode breadth 80% → 90%, ready 62% → 64%, 4–8 h → 1–3 h; feature breadth (~79%) and ready for real work (~47%) unchanged; full parity ~380–725 h → ~375–720 h |
diff --git a/docs/file-format-parity.md b/docs/file-format-parity.md
index d8e517119..ff796416a 100644
--- a/docs/file-format-parity.md
+++ b/docs/file-format-parity.md
@@ -1,6 +1,6 @@
 # File format parity
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-14 · **Change:** minor (SVG/PDF export depth refusal (#208); `.fig` export: instance sizes, variables with modes, shared styles, variable-width strokes; `.fig` export: written files checked by opening them in other software; experimental `.fig` export; export and inspect behaviour suite and fixes; .fig import: editable vector networks and more layer kinds; embedded image colour profiles; `.fig` import, best effort; animated GIF fills and TIFF images; last major: created, formats from the installed Figma's Info.plist and help center, ours from source) · **Target:** Figma Design (desktop app 126.10.7)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-24 · **Change:** minor (`.figcraft` carries the file kind (boards; `.fig` import: resized instances and variable modes by asset key; atomic saves; auto-save; SVG export clip of nested frames; SVG/PDF export depth refusal (#208); `.fig` export: instance sizes, variables with modes, shared styles, variable-width strokes; `.fig` export: written files checked by opening them in other software; experimental `.fig` export; export and inspect behaviour suite and fixes; .fig import: editable vector networks and more layer kinds; embedded image colour profiles; `.fig` import, best effort; animated GIF fills and TIFF images; last major: created, formats from the installed Figma's Info.plist and help center, ours from source; REST import keeps slot layers and instances' slot content (#792); REST import reads grid track sizes (#465); `.fig` import fidelity from the community batches, budgets for large files, the import report, a `.fig` copy from Save as, paste from another design app; instance layers' size and resizing and Hug on import (#731, #732); SVG/PDF export depth refusal (#208); `.fig` export: instance sizes, variables with modes, shared styles, variable-width strokes; `.fig` export: written files checked by opening them in other software; experimental `.fig` export; export and inspect behaviour suite and fixes; .fig import: editable vector networks and more layer kinds; embedded image colour profiles; `.fig` import, best effort; animated GIF fills and TIFF images; last major: created, formats from the installed Figma's Info.plist and help center, ours from source) · **Target:** Figma Design (desktop app 126.10.7)
 
 Every format Figma reads or writes, with FigCraft's support. Sources: `Info.plist` of
 `/Applications/Figma.app` (document types only; nothing inside the bundle's code was read), Figma's
@@ -17,10 +17,10 @@ and prototype interactions are still unchecked there.
 
 | Format | Figma | FigCraft read | FigCraft write | Fidelity / testing | Hours |
 |---|---|---|---|---|---|
-| `.fig` (Figma Design, `com.figma.document`, `application/x-figma`) | native (cloud; "Save local copy") | **yes, best effort** (`file.open`, `file.import`, drop, CLI, MCP) | **experimental** ([below](#export-to-fig-experimental)) | `.fig` files open (best effort): the zip, its deflate/zstd chunks and the kiwi schema are decoded generically and mapped by field name onto the REST importer, so pages, the layer tree, geometry, paints (styles resolved), strokes, effects, text with styled runs, vectors as editable vector networks (points, curved segments, filled areas with their winding, per-point corner radius and handle mirroring, end caps; outlines when the network is missing or damaged), auto layout (grid included), constraints, ellipse arcs, boolean operations, components, sets (with their descriptions), instances (expanded from their main with overrides, derived layout and property values), styles, variables with modes and bindings, prototyping (set-variable, set-variable-mode and conditional actions included) and image fills from the archive come across; sticky notes, shapes with text, connectors, tables, code blocks, slides and similar layers come in as the closest frames, text layers and vectors, with a warning; anything else is a warning. Not read: connector labels, table cells beyond their own layers, filled areas with their own fills, per-point stroke joins, variables bound to fields the editor can't bind, fixed or content-sized grid tracks, video fills. Tested on fixtures generated in code (`crates/format/src/fig/tests.rs`, `tail_tests.rs`, fuzzed) and by reading back what the export writes; no real-world files yet | read tail 5–10, write: checks against real files 5–15 |
-| `.jam` (FigJam), `.deck` (Slides) | native to other Figma products | no | no | out of scope | — |
-| REST API file JSON (`GET /v1/files/:key`) + local variables JSON + `images/` folder | the API's output | **yes** (`file.open`, `file.import`, CLI) | no | pages, layer tree, geometry, paints, strokes, effects, text runs, vectors, auto layout, constraints, grids, components, sets, instances with overrides, component properties, styles, prototyping (incl. conditionals and variable modes), variables with modes, aliases, scopes and bindings; warnings for what's skipped (video triggers and actions, modifier keys). Unit tests in `crates/format/src/rest/*_tests.rs` | — |
-| `.figcraft` (ours: zip of `document.json` + images, versions inside) | — | yes | yes | streamed JSON, 50k layers save ~0.09 s / load ~0.16 s (`cargo xtask bench`); old files keep opening (`large_tests.rs`) | — |
+| `.fig` (Figma Design, `com.figma.document`, `application/x-figma`) | native (cloud; "Save local copy") | **yes, best effort** (`file.open`, `file.import`, drop, CLI, MCP) | **experimental** ([below](#export-to-fig-experimental)) | `.fig` files open (best effort): the zip, its deflate/zstd chunks and the kiwi schema are decoded generically and mapped by field name onto the REST importer, so pages, the layer tree, geometry, paints (styles resolved), strokes, effects, text with styled runs, vectors as editable vector networks (points, curved segments, filled areas with their winding, per-point corner radius and handle mirroring, end caps; outlines when the network is missing or damaged), auto layout (grid included; a flow that records no primary-axis sizing hugs on that axis, an instance that records no auto layout has its main's), constraints, ellipse arcs, boolean operations, components, sets (with their descriptions), instances (expanded from their main with overrides, derived layout and property values; the size and resizing their layers override stay overrides), styles, variables with modes and bindings, prototyping (set-variable, set-variable-mode and conditional actions included) and image fills from the archive come across; sticky notes, shapes with text, connectors, tables, code blocks, slides and similar layers come in as the closest frames, text layers and vectors, with a warning; anything else is a warning. Since 2026-10-17 (community batches #727, #728): an instance's own identity and the cached library components a file carries, overrides applied by key and order, local text values and instance overrides over a shared text style, grid track sizes (fixed, content-sized, fill), slot content, labels of connectors saved with their drawn path (a static snapshot; the ends aren't live), skip ink, paragraph options and hanging lists, list start numbers, vertical trim, per-point stroke joins, editable text on a path, image adjustments and images carried in the message. Budgets come from the file's own size (one value per compressed byte, 20M–128M, lower ceilings on 32-bit targets; the layer cap follows), so a 15.4 MB synthetic file with 300,000 layers opens whole; the file's bytes stay out of the command journal; an import report lists what was left out or changed once the file opens. Not read: elbowed or curved connectors without a saved path (drawn straight) and labels of connectors without a saved snapshot, table cells beyond their own layers, filled areas with their own fills, variables bound to fields the editor can't bind, video fills. Tested on fixtures generated in code (`crates/format/src/fig/tests.rs`, `tail_tests.rs` and the per-feature `*_tests.rs` beside them, fuzzed) and by reading back what the export writes; no real-world files yet | read tail 5–10, write: checks against real files 5–15 |
+| `.jam` (whiteboards), `.deck` (Slides) | native to other Figma products | no | no | `.jam`: not read or written (boards are FigCraft files, see [boards-parity](boards-parity.md)); `.deck` out of scope | — |
+| REST API file JSON (`GET /v1/files/:key`) + local variables JSON + `images/` folder | the API's output | **yes** (`file.open`, `file.import`, CLI) | no | pages, layer tree, geometry, paints, strokes, effects, text runs, vectors, auto layout (sizing modes left out read as hug, as documented; grid track sizes from `gridColumnsSizing` / `gridRowsSizing`: px, fr, auto, `minmax(0, 1fr)`, `repeat()`), constraints, grids, components, sets, instances with overrides (sizes and resizing included), component properties, slots (`SLOT` layers bound to their slot property; an instance's slot keeps its content as the instance's own unless its property value is the main's default content; slot limits and preferred components are warnings), styles, prototyping (incl. conditionals and variable modes), variables with modes, aliases, scopes and bindings, image adjustments (the same tint sign as `.fig`); the import report after opening; warnings for what's skipped (video triggers and actions, modifier keys). Unit tests in `crates/format/src/rest/*_tests.rs` | — |
+| `.figcraft` (ours: zip of `document.json` + images, versions inside) | — | yes | yes | streamed JSON, 50k layers save ~0.09 s / load ~0.16 s (`cargo xtask bench`); old files keep opening (`large_tests.rs`); saves write a unique staging file and rename it into place (#284); optional auto-save of files with a path (`pref.autoSave`, #305); `kind: "board"` marks a board (left out for design files, so files from before boards are design files; the home screen reads it for the file's mark); board objects keep their `board` metadata on the layer | — |
 | Local library files | team libraries in the cloud | yes (enable a `.figcraft` as a library) | yes (publish) | per-asset versions, updates with overrides kept | see [collaboration-parity](collaboration-parity.md) |
 
 ## Import (place / paste / drop)
@@ -36,7 +36,7 @@ and prototype interactions are still unchecked there.
 | BMP | — | yes | | — |
 | MP4, MOV, WebM (video fills, paid plans) | yes | **no** | shortcut: decoding H.264/HEVC/VP9 needs non-Rust libraries (FFmpeg or each platform's media framework); presenter playback would reuse the animated GIF clock | 4–8 |
 | Images over 4096 px | downscaled to 4096 | kept | | — |
-| Pasted content from other apps | images, SVG, text, Figma clipboard | images, SVG, text (newest clipboard content wins) | no Figma clipboard (it carries Figma's own binary) | with `.fig` |
+| Pasted content from other apps | images, SVG, text, Figma clipboard | images, SVG, text (newest clipboard content wins), **layers copied from another design app, best effort** | Cmd/Ctrl+V reads an image copied in another app (under Wayland through the data-control protocol, not run on Linux here; Linux and BSD clipboard reads give up after 2 s). Copied design layers: the `.fig` canvas in the clipboard's HTML is read like a `.fig` file (with its warnings) and pasted as Paste pastes, in place or into the selected frame (`edit.pasteDesignLayers {html \| data}`, refused over 256 MB before decoding); text copied later pastes as text again. Tested with clipboard HTML made from our own `.fig` export (`design_paste_tests`), never with a real clipboard from other software | with `.fig` |
 
 ## Export
 
@@ -51,18 +51,21 @@ export limit, not a native document nesting limit.
 |---|---|---|---|---|
 | PNG | yes, scales/suffixes | yes | export settings per layer, presets (`2x`, `512w`, `512h`), preview, "Export N layers"; contents only (off: every layer showing in the area) and include bounding box (the layer's own box); slashes in layer names export into folders. The exported area is what the layer paints: shadows towards their offset, outside and centre strokes, unclipped children, a mask group's mask, nothing for hidden layers; slices export everything under them; sides round up to whole pixels | — |
 | JPG | yes | yes | white where transparent; fixed quality (90) | — |
-| SVG | yes (outline text option, ids) | yes | alpha/luminance masks kept; noise, texture, progressive and background blur, glass embedded as images; outline text (off: `<text>` with one `<tspan>` per line, one style per layer), unique id attributes from layer names, explicit depth-limit refusal, simplified strokes (stroke attributes for centred strokes and for inside and outside strokes on boxes and ellipses) | — |
+| SVG | yes (outline text option, ids) | yes | alpha/luminance masks kept; noise, texture, progressive and background blur, glass embedded as images; outline text (off: `<text>` with one `<tspan>` per line, one style per layer), unique id attributes from layer names, explicit depth-limit refusal, nested frames clipped by their parent's clip (#327), simplified strokes (stroke attributes for centred strokes and for inside and outside strokes on boxes and ellipses) | — |
 | PDF | yes | yes | one page per frame, real selectable text in subset fonts, links, vectors and gradients as vectors, effects as images; bleed, crop/bleed marks, page boxes, naive CMYK; checked by rendering the PDF back against PNG exports; explicit depth-limit refusal | CMYK output intent 2–4 |
 | WebP | — | yes (ours) | | — |
 | Copy as CSS / SVG / PNG / text / link | yes | yes | Copy as PNG: the whole selection at 2x | — |
 | Dev Mode code (CSS, iOS SwiftUI, Android Compose) | yes | yes, plus HTML and React | see [dev-mode-parity](dev-mode-parity.md) | — |
-| `.fig` ("Save local copy") | yes | **experimental** | the whole file; see [Export to `.fig`](#export-to-fig-experimental). Round trips through our own importer; written files checked by opening them in other software: layers, fills, gradients, strokes, shadows, vectors, components and text draw as in FigCraft; resized and scaled instances keep their size and lay their layers out for it, variables with their modes and colour bindings resolve there (a frame set to another mode shows that mode's colours, also inside instances), colour, text, effect and grid styles are listed, and variable-width strokes that are the same on both sides of the path draw with their width | 5–15 (non-colour bindings as bindings, checks of effects, images and prototypes, and against real files) |
+| `.fig` ("Save local copy") | yes | **experimental** | the whole file, also as a copy from File ▸ Save as… (the document keeps its `.figcraft` path and unsaved state); see [Export to `.fig`](#export-to-fig-experimental). Round trips through our own importer; written files checked by opening them in other software: layers, fills, gradients, strokes, shadows, vectors, components and text draw as in FigCraft; resized and scaled instances keep their size and lay their layers out for it, variables with their modes and colour bindings resolve there (a frame set to another mode shows that mode's colours, also inside instances), colour, text, effect and grid styles are listed, and variable-width strokes that are the same on both sides of the path draw with their width | 5–15 (non-colour bindings as bindings, checks of effects, images and prototypes, and against real files) |
 
 ### Export to `.fig` (experimental)
 
 `file.export {format: "fig"}` (or a `path` ending in `.fig`), File ▸ Export… ▸ .fig (experimental),
 `figcraft-cli export <file> -o <out>.fig` (and `convert`) and MCP's `export {format: "fig"}` write
-the whole document. The writer (`crates/format/src/fig/export.rs`) works from the same public format
+the whole document; so do File ▸ Save as… and `file.save` / `file.saveAs` with a `.fig` path, as a
+copy: the document keeps its `.figcraft` path, unsaved changes and version preview, and a file an
+earlier build saved under a `.fig` name is never overwritten by Save (`save_format_tests`,
+`save_as_tests`). The writer (`crates/format/src/fig/export.rs`) works from the same public format
 notes as the import and inverts its mapping: the zip holds `canvas.fig` (the fig-kiwi header, then a
 raw-deflate binary schema and a raw-deflate message), `meta.json`, `thumbnail.png` and
 `images/<hash>`; `meta.json` names the file and gives the page colour and the thumbnail size. The
@@ -119,10 +122,10 @@ each.
   image adjustments, glass settings other than frost, springs other than Gentle (written as ease
   out), set-variable, set-variable-mode and conditional actions, scroll-to offsets, text decoration
   looks, variable font axes, text on a path, nested list levels, list spacing, hanging punctuation,
-  leading trim, OpenType features, per-layer operations inside boolean groups, grid tracks of fixed
-  or content size, different stroke ends on lines. Not written at all: stroke outlines of dashed and
-  per-side strokes and of inside or outside strokes on polygons, stars and vectors, glyph outlines
-  of text (a reader lays text out with its own fonts), version history and branches.
+  leading trim, OpenType features, per-layer operations inside boolean groups, different stroke ends
+  on lines. Not written at all: stroke outlines of dashed and per-side strokes and of inside or
+  outside strokes on polygons, stars and vectors, glyph outlines of text (a reader lays text out
+  with its own fonts), version history and branches.
 - **Checked by opening written files in other software:** the example documents and a small test
   file open there, and layers, fills, gradients, strokes, shadows, vectors, components and text draw
   as in FigCraft. A file saved again there and read back keeps the layer tree and properties; two
@@ -162,6 +165,14 @@ each.
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-24 | minor | Boards (M12): `.figcraft` saves the file kind (`kind: "board"`, absent for design files) and each board object's `board` metadata; the `.jam` row points at boards |
+| 2026-10-15 | minor | `.fig` import (#279, #281; #266, #267): resized instances lay out their layers by their constraints, and explicit variable modes whose collection is named by its asset key come across (before, they were dropped and bound layers resolved in the default mode); fixture-tested, real files still owed. `.figcraft`: atomic saves and exports through unique staging files (#284), optional auto-save (#305). SVG export keeps a nested frame's fill and stroke inside its parent's clip (#327). Numbers unchanged |
+| 2026-10-20 | minor | `.fig` export writes grid track sizes (`gridColumnsSizing` / `gridRowsSizing`): fixed px, fractional fill and content-sized tracks keep their sizes and come back through our own importer (#465). Tracks whose size the format can't hold (a negative or out-of-range value) keep their id and read back equal, with a warning. Numbers unchanged |
+| 2026-10-18 | minor | REST file JSON import keeps `SLOT` layers (#792): they were dropped with everything placed in them, which emptied every instance's slot. A slot in a main component becomes a slot frame bound to its `SLOT` property (the one it references, else the one named like it, else the only one left), and an instance's slot holds the instance's own content, kept across syncs, moves of the mains and saving, unless the instance's property value is the main's default content (without values, a slot that holds layers keeps them). Instances in slot content link to their own mains. Slot content limits, preferred-only and preferred components are warnings. Synthetic files only. Numbers unchanged |
+| 2026-10-17 | minor | REST file JSON import reads grid track sizes from the CSS track strings `gridColumnsSizing` / `gridRowsSizing` (fixed px, fill fr, hug `auto`, `minmax(0, 1fr)`, `repeat()`; other tracks stay equal) (#465). Numbers unchanged |
+| 2026-10-17 | minor | The community batches #727 and #728 in the `.fig` row: instance identity and cached library components, overrides by key, text style precedence, grid track sizes, slot content, labels of connectors saved with their path, skip ink, paragraph options, list start numbers, vertical trim, per-point stroke joins, text on a path, image adjustments (also REST), images in the message; budgets from the file's size; the journal keeps no file bytes; the import report. Not read cut to what's left. A `.fig` copy from Save as. Pasted content: layers copied from another design app, best effort (tested only with clipboard HTML made from our own export), and images under Wayland (not run there). All on synthetic files: summary and hours unchanged |
+| 2026-10-17 | minor | Hug on import (#732): auto layout frames a `.fig` records no primary-axis sizing for hug on that axis (auto layout sized that axis by its content before it could be fixed) instead of turning fixed, instances that record no auto layout take their main's (they came in without auto layout and fixed, so longer text overflowed them), REST frames whose sizing modes are left out hug (the documented default), and text hugs by its resize mode (auto width both axes, auto height its height; it came in fixed). Numbers unchanged |
+| 2026-10-17 | minor | Instance layers' own size and resizing (#731): a `.fig` import keeps the sizes an instance gives its layers and their hug/fill/fixed and min/max as overrides, a REST import reads the resizing fields of `overrides`, and a `.fig` export writes a layer's own size as an override (it went with the derived layout, which a relayout replaces). Numbers unchanged |
 | 2026-10-14 | minor | SVG/PDF depth overflow (#208) is checked before bounds and drawing; public checked APIs return the offending root/layer, commands and CLI report it, and no incomplete export replaces an existing file. Tested at depths 255/256/257, with inner roots, hidden branches, masks, raster fallbacks and multiple roots/pages. Numbers unchanged. |
 | 2026-10-13 | minor | `.fig` export (gap 1): instances write what they change from their main as an override addressed by the main's id (their size, name and paints were lost elsewhere without it), what follows for their layers as derived data, and a scale factor when scaled as a whole; layers of a nested instance swapped for another component keep their overrides; variable collections, modes, variables and their bindings, the modes frames and pages set, shared styles with their links and variable-width strokes are written, and the import reads all of it back (style definitions and unused styles, variable order and scopes, bindings on paint lists, gradient stops, effects and layout grids, page modes, text field bindings, which a `.fig` import used to drop, and width profiles). Opened `.fig` and file JSON documents link nested instances of variants (and any nested instance under a name of its own) to their main's layers; they stayed unlinked, so a second export lost what they changed. Checked by opening written files in other software: resized and scaled instances keep their size and lay their layers out for it, variables with their modes and colour bindings resolve there (a frame set to another mode shows that mode's colours, also inside instances), colour, text, effect and grid styles are listed, and variable-width strokes that are the same on both sides of the path draw with their width; number, string and boolean bindings and bindings on effects, layout guides and gradient stops come across as the values they give but did not show as bound there (their entries now also name the layer field they set, not yet checked there), and strokes wider on one side of the path are written as filled outlines, no longer editable strokes there (the stroke itself is kept as plugin data and our own import puts it back; not yet checked there). Numbers unchanged |
 | 2026-10-12 | minor | `.fig` export made to open elsewhere (gap 1): the document and its pages say they are visible and opaque (left out, nothing was drawn), the schema in the file uses the format's own names, kinds, field ids and enum values, rectangles are rounded rectangles with four radii, frames and shapes carry their fill outline and plain strokes their stroke outline, text carries its layout settings, font styles use their standard names, line heights that are a share of the font size are raw multipliers, masks keep their type (read back too); the import reads per-side stroke weights whose zero sides are left out. Written files were checked by opening them in other software: layers, fills, gradients, strokes, shadows, vectors, components and text draw as in FigCraft; effects such as glass and noise, images and prototype interactions are still unchecked there, and variables are not written. Numbers unchanged |
diff --git a/docs/gaps.md b/docs/gaps.md
index e8b111a8d..40f970327 100644
--- a/docs/gaps.md
+++ b/docs/gaps.md
@@ -1,6 +1,6 @@
 # Where FigCraft falls short of Figma
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-15 · **Change:** minor (bounded canvas pan overscan; reviewed Russian catalog and integer plurals; `.fig` export: instance sizes, variables with modes, shared styles, variable-width strokes; sharing with a join code; text box sizes measured against documents re-saved by other software; live sessions per document; .fig export checked by opening written files in other software; experimental .fig export; keyboard shortcut parity suite and bindings; Simplified Chinese draft catalog; Latin American Spanish overlay; prototyping tail: gamepad triggers, widgets in prototypes, mode lookups; plugin directory on figcraft-server; Japanese and Korean draft catalogs and CJK UI fonts; plugin widgets and the plugin panel tail; French, German and Brazilian Portuguese draft catalogs; cursor chat and spotlight in live sessions; layers and assets panels behaviour suite and fixes; vector multi-edit and edit tail; dev resources links; extended collections tail; branch version history and finer list merges; comments and version history behaviour suite and fixes; canvas navigation, guides and grids behaviour suite and fixes; `.fig` import: editable vector networks, more layer kinds, variable prototype actions; `.fig` import, best effort: gap 1 down to its tail; Windows QA pass: everyday workflows on Windows 11, eight fixes incl. unsaved work kept after a crash or a forced quit; Display P3: gamut warning and soft-proof (true P3 blocked upstream); several windows; localization layer with a draft Spanish catalog; hosting figcraft-server: wss in the desktop app, server releases, deployment guide; plugin panels and settings; canvas fixes: boolean hit testing on the result, group drags, frame outlines and slices; code connect; stretch and scatter brushes, pen pressure; text on a path and pattern fills; team libraries on the server and swap library; branches: create, update from main, review and merge; animated GIF fills and TIFF images; Open recent, outlines for the selection and mask outlines: menu breadth 100%; extended collections, variables import/export, gradient stop and variant bindings: gap 14 down to its tail) · **Target:** Figma Design (desktop app 126.10.7)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-24 · **Change:** minor (gap 24: boards and their tail; Dev Mode tail: import lines in layer trees, compare with versions, an inspect-only canvas; gap 5: reviewed Turkish, Czech and Indonesian drafts, the Japanese draft completed; reviewed Russian catalog and integer plurals; `.fig` export: instance sizes, variables with modes, shared styles, variable-width strokes; sharing with a join code; text box sizes measured against documents re-saved by other software; live sessions per document; .fig export checked by opening written files in other software; experimental .fig export; keyboard shortcut parity suite and bindings; Simplified Chinese draft catalog; Latin American Spanish overlay; prototyping tail: gamepad triggers, widgets in prototypes, mode lookups; plugin directory on figcraft-server; Japanese and Korean draft catalogs and CJK UI fonts; plugin widgets and the plugin panel tail; French, German and Brazilian Portuguese draft catalogs; cursor chat and spotlight in live sessions; layers and assets panels behaviour suite and fixes; vector multi-edit and edit tail; dev resources links; extended collections tail; branch version history and finer list merges; comments and version history behaviour suite and fixes; canvas navigation, guides and grids behaviour suite and fixes; `.fig` import: editable vector networks, more layer kinds, variable prototype actions; `.fig` import, best effort: gap 1 down to its tail; Windows QA pass: everyday workflows on Windows 11, eight fixes incl. unsaved work kept after a crash or a forced quit; Display P3: gamut warning and soft-proof (true P3 blocked upstream); several windows; localization layer with a draft Spanish catalog; hosting figcraft-server: wss in the desktop app, server releases, deployment guide; plugin panels and settings; canvas fixes: boolean hit testing on the result, group drags, frame outlines and slices; code connect; stretch and scatter brushes, pen pressure; text on a path and pattern fills; team libraries on the server and swap library; branches: create, update from main, review and merge; animated GIF fills and TIFF images; Open recent, outlines for the selection and mask outlines: menu breadth 100%; extended collections, variables import/export, gradient stop and variant bindings: gap 14 down to its tail; the 2026-10-17 landings: `.fig` import fidelity, budgets for large files, the import report, a `.fig` copy from Save as and paste from another design app (gap 1); menus, the Actions palette, editor fixes, Selection colors and smart-selection spacing (gap 4); catalog counts re-measured (gap 5); bounded canvas pan overscan; reviewed Russian catalog and integer plurals; `.fig` export: instance sizes, variables with modes, shared styles, variable-width strokes; sharing with a join code; text box sizes measured against documents re-saved by other software; live sessions per document; .fig export checked by opening written files in other software; experimental .fig export; keyboard shortcut parity suite and bindings; Simplified Chinese draft catalog; Latin American Spanish overlay; prototyping tail: gamepad triggers, widgets in prototypes, mode lookups; plugin directory on figcraft-server; Japanese and Korean draft catalogs and CJK UI fonts; plugin widgets and the plugin panel tail; French, German and Brazilian Portuguese draft catalogs; cursor chat and spotlight in live sessions; layers and assets panels behaviour suite and fixes; vector multi-edit and edit tail; dev resources links; extended collections tail; branch version history and finer list merges; comments and version history behaviour suite and fixes; canvas navigation, guides and grids behaviour suite and fixes; `.fig` import: editable vector networks, more layer kinds, variable prototype actions; `.fig` import, best effort: gap 1 down to its tail; Windows QA pass: everyday workflows on Windows 11, eight fixes incl. unsaved work kept after a crash or a forced quit; Display P3: gamut warning and soft-proof (true P3 blocked upstream); several windows; localization layer with a draft Spanish catalog; hosting figcraft-server: wss in the desktop app, server releases, deployment guide; plugin panels and settings; canvas fixes: boolean hit testing on the result, group drags, frame outlines and slices; code connect; stretch and scatter brushes, pen pressure; text on a path and pattern fills; team libraries on the server and swap library; branches: create, update from main, review and merge; animated GIF fills and TIFF images; Open recent, outlines for the selection and mask outlines: menu breadth 100%; extended collections, variables import/export, gradient stop and variant bindings: gap 14 down to its tail) · **Target:** Figma Design (desktop app 126.10.7)
 
 Every known shortfall against Figma, one entry each, ranked by how much it stops a Figma user from
 doing real work in FigCraft. Agents: pick work from the top unless the owner says otherwise. The
@@ -14,11 +14,11 @@ No alpha blockers: the alpha gate in [`roadmap.md`](roadmap.md#alpha-gate) passe
 
 | # | Gap | Kind | Hours | Doc |
 |---|---|---|---|---|
-| 1 | `.fig` files: best-effort import with editable vector networks and stand-ins for non-design layers landed, and an experimental export (round trips through our own importer; written files opened in other software, where layers, fills, gradients, strokes, shadows, vectors, components and text draw as in FigCraft, instances keep their size and variables with modes and colour styles come across); real-file checks and the small tail left (**beta blocker** until checked on real files, gap 3) | File format | 5–10 | [file-format-parity](file-format-parity.md) |
+| 1 | `.fig` files: best-effort import with editable vector networks and stand-ins for non-design layers landed, then (2026-10-17) more fidelity on synthetic files, budgets for large files, an import report and paste from another design app; an experimental export, also as a copy from Save as (round trips through our own importer; written files opened in other software, where layers, fills, gradients, strokes, shadows, vectors, components and text draw as in FigCraft, instances keep their size and variables with modes and colour styles come across); real-file checks and the small tail left (**beta blocker** until checked on real files, gap 3) | File format | 5–10 | [file-format-parity](file-format-parity.md) |
 | 2 | Multiplayer and sharing are a preview, without accounts (**beta blocker**) | Feature | 42–84 | [collaboration-parity](collaboration-parity.md) |
 | 3 | Nothing checked against real Figma files | Fidelity | 15–30 | [target-app-parity](target-app-parity.md) |
 | 4 | Interaction fidelity not compared tool by tool | UI/UX | 40–60 | [ui-parity](ui-parity.md) |
-| 5 | Localization: English, reviewed Russian, plus unreviewed Spanish (and Latin American Spanish), French, German, Brazilian Portuguese, Japanese, Korean and Simplified Chinese drafts | Localization | 29–51 | [localization-parity](localization-parity.md) |
+| 5 | Localization: English, reviewed Russian and Turkish, plus unreviewed Spanish (and Latin American Spanish), French, German, Brazilian Portuguese, Japanese, Korean, Simplified Chinese, Indonesian and Czech drafts; Turkish and Swedish catalogs | Localization | 29–51 | [localization-parity](localization-parity.md) |
 | 6 | Plugins: widgets take clicks only, a self-hosted directory but no public catalogue; Figma's plugins don't run | Ecosystem | 8–26 | [target-app-parity](target-app-parity.md) |
 | 7 | CPU canvas where Figma uses the GPU | Hardware/performance | 30–60 | [hardware-parity](hardware-parity.md) |
 | 8 | Platform QA: Linux and the browser left (Windows pass done 2026-10-11) | Stability/platforms | 10–20 | [hardware-parity](hardware-parity.md) |
@@ -29,7 +29,7 @@ No alpha blockers: the alpha gate in [`roadmap.md`](roadmap.md#alpha-gate) passe
 | 13 | Vector tail: none left (boolean hit testing on the result landed 2026-10-11) | Feature | — | [target-app-parity](target-app-parity.md) |
 | 14 | Variables: extended collections checked on real libraries (the tail landed 2026-10-12) | Feature | 0–1 | [components-parity](components-parity.md) |
 | 15 | Prototyping: media triggers and actions; controllers on macOS, Linux and FreeBSD (controller buttons on key/gamepad triggers, widgets in prototypes landed) | Feature | 2–5 | [prototyping-parity](prototyping-parity.md) |
-| 16 | Dev Mode: import lines inside generated layer trees; the editor extension is left to the MCP server (code connect, Dev Mode plugins and dev resources landed) | Feature | 0–1 | [dev-mode-parity](dev-mode-parity.md) |
+| 16 | Dev Mode: measurements kept on the canvas, a read-only layers panel, publishing mappings from the code repository; the editor extension is left to the MCP server (import lines, compare with versions and an inspect-only canvas landed 2026-10-15) | Feature | 2–4 | [dev-mode-parity](dev-mode-parity.md) |
 | 17 | Branching: branches in live sessions, lists other than fills, strokes and effects merged whole (a branch's own version history and per-item list merges landed 2026-10-12) | Feature | 1–2 | [collaboration-parity](collaboration-parity.md) |
 | 18 | Display P3 on screen: blocked upstream (egui-wgpu picks an 8-bit sRGB surface); gamut warning and soft-proof sRGB landed, as did several windows | Hardware | 4–8 | [hardware-parity](hardware-parity.md) |
 | 19 | AI features | AI | 30–60 | [target-app-parity](target-app-parity.md) |
@@ -37,6 +37,7 @@ No alpha blockers: the alpha gate in [`roadmap.md`](roadmap.md#alpha-gate) passe
 | 21 | Menu items without a command: none left (landed 2026-10-11) | Feature | — | [parity-checklist](parity-checklist.md) |
 | 22 | Screen readers never run; browser has no accessibility tree | UI/UX | 4–8 | [ui-parity](ui-parity.md) |
 | 23 | CMYK output intent for print PDFs | File format | 2–4 | [file-format-parity](file-format-parity.md) |
+| 24 | Boards: the whiteboard tail (timer, voting, widgets, templates, tables, mind maps…) | Feature | 30–60 | [boards-parity](boards-parity.md) |
 
 ## Entries
 
@@ -60,20 +61,43 @@ No alpha blockers: the alpha gate in [`roadmap.md`](roadmap.md#alpha-gate) passe
   derived data for their layers, a scale factor), variables with modes and bindings, shared styles
   and variable-width strokes are written and read back; checked there: resized and scaled instances keep their size and lay their layers out for it, variables with their modes and colour bindings resolve there (a frame set to another mode shows that mode's colours, also inside instances), colour, text, effect and grid styles are listed, and variable-width strokes that are the same on both sides of the path draw with their width; number, string and boolean bindings and bindings on effects, layout guides and gradient stops come across as the values they give but did not show as bound there (their entries now also name the layer field they set, not yet checked there), and strokes wider on one side of the path are written as filled outlines, no longer editable strokes there (the stroke itself is kept as plugin data and our own import puts it back; not yet checked there),
   like effects such as glass and noise, images and prototype interactions.
-- **Missing:** connector labels, elbowed or curved connectors without a saved path (drawn straight),
-  table cells beyond their own layers, filled areas of a vector with their own fills, per-point stroke
-  joins, variables bound to fields the editor can't bind, fixed or content-sized grid tracks and video
-  fills aren't read; text lays out again with
-  local fonts. Nothing has been checked against real-world files yet (gap 3). The export is checked
-  only against our own importer: whether other apps open its files is unknown.
+- **Landed (2026-10-17, community batches #727 and #728, then #745):** the import keeps an
+  instance's own identity and the cached copies of library components a file carries, applies
+  instance overrides by key and order, lets local text values and instance overrides win over a
+  shared text style, and reads grid track sizes (fixed, content-sized and fill), slot content,
+  labels of connectors saved with their drawn path (text and background, as a static snapshot:
+  the ends aren't live), skip ink, paragraph options and hanging lists, list start numbers,
+  vertical trim, per-point stroke joins, editable text on a path, image adjustments (the tint
+  sign shared with the REST import) and images carried in the file's message; layers inside
+  instances keep their own size and resizing as overrides (#731), and auto layout and text that
+  record no sizing hug (#732). Large files open within budgets set from the file's own size (one
+  value per compressed byte, 20M–128M values, lower ceilings on 32-bit targets; a 15.4 MB
+  synthetic file with 300,000 layers opens whole). After a `.fig`, REST JSON or SVG import an
+  import report lists what was left out or changed (translated where the catalog has the note;
+  `file.open {data}` returns a `summary`), and imported file bytes stay out of the command
+  journal. File ▸ Save as… to a `.fig` name writes an export copy and the document keeps its
+  `.figcraft` path. Layers copied from another design app paste (`edit.pasteDesignLayers`, and
+  Cmd/Ctrl+V when the clipboard's HTML holds a `.fig` canvas): read like a `.fig` file, with its
+  warnings, size-checked (256 MB) before decoding.
+- **Missing:** elbowed or curved connectors without a saved path (drawn straight), labels of
+  connectors without a saved snapshot, table cells beyond their own layers, filled areas of a
+  vector with their own fills (#634, held for an owner decision on the document model), variables
+  bound to fields the editor can't bind and video fills aren't read; text lays out again with
+  local fonts. Nothing has been checked against real-world files yet (gap 3): the 2026-10-17
+  changes were tested on files built in code, and paste from another design app on clipboard HTML
+  made from our own export, never on a real clipboard. The export was checked in other software
+  on our example documents and small test files only.
 - **Evidence:** fixtures generated in code (`crates/format/src/fig/tests.rs` and `tail_tests.rs`: kiwi
   round trips, every mapped feature, vector network blobs, truncation, bit flips and junk never panic); `crates/engine/src/fig_import_tests.rs`.
+  2026-10-17: `crates/format/src/fig/{connector_label,slot,source_identity,text_style,text_list,text_paragraph,text_path,text_skip_ink,image_filter,auto_layout_sizing}_tests.rs`,
+  `map_connector_snapshot_budget_tests.rs`, `crates/engine/src/{save_format,design_paste,instance_resizing}_tests.rs`,
+  `crates/ui-egui/src/{import_report,save_as}_tests.rs`.
   Export: 60 generated documents round trip through the importer layer by layer, written files
   decode with the generic decoder and list parents first, the encoder agrees with the decoder,
   junk documents never panic (`crates/format/src/fig/export_tests.rs`,
   `crates/engine/src/fig_export_tests.rs`).
 - **Impact:** existing work can be brought across, but only real files will show how much of it.
-- **Estimate:** 5–10 h for the read tail (real-file fixes, connector labels, table cells); checking the export against real files a further 5–15 h (with gap 3).
+- **Estimate:** 5–10 h for the read tail (real-file fixes, table cells, connectors without a saved path); checking the export against real files a further 5–15 h (with gap 3). Unchanged on 2026-10-17: most of the read tail is real-file fixes, which nothing has measured yet.
 
 ### 2. Multiplayer and sharing are a preview, without accounts
 - **Missing:** accounts, teams and projects, per-person permissions, audio,
@@ -93,8 +117,11 @@ No alpha blockers: the alpha gate in [`roadmap.md`](roadmap.md#alpha-gate) passe
   `figcraft-server` keeps many files (snapshot plus log, compacted; restarts lose nothing
   confirmed), takes files published from the app and hands out share links that let people edit
   or only view; the desktop app and the browser reach it over `wss://` through a TLS reverse
-  proxy, and releases ship it with a deployment guide (`docs/server.md`). But there are no
-  accounts (a link is the access) (`docs/collab-protocol.md`).
+  proxy, and releases ship it with a deployment guide (`docs/server.md`); server message limits
+  follow `max_file_mb`, so files above 64 MiB publish and open (#705), a damaged generation field
+  no longer drops a log's flushed edits (#687), and the browser build joins from a `#join=` link
+  (#712: unit-tested, not run in a browser). But there are no accounts (a link is the access)
+  (`docs/collab-protocol.md`).
 - **Impact:** Figma's defining feature; most teams use it every day. Solo designers can work
   without it.
 - **Estimate:** 42–84 h: accounts, teams and per-person permissions, shared comments and versions
@@ -138,29 +165,43 @@ No alpha blockers: the alpha gate in [`roadmap.md`](roadmap.md#alpha-gate) passe
   cursor for every tool and modifier, panel widths, dark pages (`field_tests`, `cursor_tests`,
   `cursors_tests`, `outline_options_tests`, `hide_publishing_tests`, `panel_width_tests`,
   `theme_pages_tests`).
+- **Landed (2026-10-17, community batches #733, #735, #736 and #729):** submenus open after a
+  short hover, keep their place while the pointer heads for them (a safe triangle) and reopen
+  closed (`menu_aim_tests`; timings tuned by feel, not measured); the Actions palette has tabs,
+  ranked search over every command, a keyboard highlight and recents (`palette_tests`); menu items
+  that need a value ask for it; live font preview on hover; the colour picker opens on a new fill
+  or stroke; Shift-drag on a selected layer moves the selection; a double-click near a thin stroke
+  enters vector edit; points dropped on a point merge; a draggable divider between Pages and
+  Layers; Paste over and Paste properties from the keyboard; then (#753) Selection colors for mixed
+  selections and smart-selection spacing fields and canvas handles (no reorder rings). Each was checked in the app (on
+  Windows; the submenus by their author), none side by side with Figma, none on macOS.
 - **Evidence:** ROADMAP item 7 ("Left: tool by tool, panel by panel against the incumbent").
 - **Impact:** Figma users notice the feel within minutes; it decides whether they stay.
 - **Estimate:** 40–60 h. Detail in [`ui-parity.md`](ui-parity.md).
 
-### 5. Localization: English, reviewed Russian, plus unreviewed drafts
+### 5. Localization: English, reviewed Russian and Turkish, plus unreviewed drafts
 - **Missing:** native reviews of the Spanish, French, German, Brazilian Portuguese, Japanese,
-  Korean and Simplified Chinese drafts and the Latin American Spanish overlay, the 25 newest strings
-  in five drafts, Hindi, Arabic, Indonesian and Vietnamese, localized engine messages and number
-  formatting; CJK UI text on the web without the craft-fonts CJK build.
+  Korean, Simplified Chinese, Indonesian and Czech drafts and the Latin American Spanish
+  overlay, the strings added since each catalog was drafted (1–5% of each), Hindi, Arabic and
+  Vietnamese, localized engine messages and number formatting; CJK UI text on the web without the
+  craft-fonts CJK build.
 - **Evidence (measured from source):** the layer landed 2026-10-11: catalogs in
-  `crates/ui-egui/locales/` (1,371 UI keys plus 524 command labels and 29 menu wordings),
-  Preferences ▸ Language, `pref.language`; `en.toml` is complete, and `es.toml`, `fr.toml`,
-  `de.toml`, `pt-BR.toml`, `ja.toml`, `ko.toml` and `zh-Hans.toml` (2026-10-12) are machine drafts
-  (all but `zh-Hans.toml` lack the 25 newest strings), with `es-419.toml` a Latin American overlay
-  listing only what differs from Spanish (Spanish and Russian are held to completeness by the check; the
-  others show English for strings added later). Russian adds all 2,165 current entries,
-  reviewed and approved by VanTan, with one/few/many integer plurals.
+  `crates/ui-egui/locales/` (measured 2026-10-17: 1,680 UI keys plus 561 command labels and 31
+  menu wordings, 2,272 entries), Preferences ▸ Language, `pref.language`; `en.toml` is complete,
+  Spanish is held to completeness by the check, and the French, German, Brazilian Portuguese,
+  Japanese, Korean and Simplified Chinese machine drafts cover 95–99% (strings added since they
+  were drafted show English), with `es-419.toml` a Latin American overlay listing only what
+  differs from Spanish. Russian (reviewed and approved by VanTan, one/few/many integer plurals)
+  covers 98.8%; Indonesian and Czech drafts, a Turkish catalog whose header says a native speaker
+  reviewed it, and a Swedish catalog (with its command labels since 2026-10-17) cover 98.7–99.6% ([localization-parity](localization-parity.md#languages)).
   CJK UI text uses an installed CJK face the desktop app loads when something on screen needs it
   (`crates/ui-egui/src/cjk.rs`). Engine error messages and Dev Mode values stay English.
 - **Impact:** non-English designers get machine drafts nobody has reviewed yet, and English
   errors.
 - **Estimate:** 3–7 h per language plus native review, 4–6 h for engine messages and numbers;
-  29–51 h for the key languages left and the drafts' follow-ups. Detail in
+  29–51 h for the key languages left and the drafts' follow-ups (kept on 2026-10-17: the
+  Indonesian draft takes 2–3 h off, about what bringing the drafts that slipped to 95% back to
+  every string adds). Detail in
   [`localization-parity.md`](localization-parity.md); how to add one in
   [`translating.md`](translating.md).
 
@@ -215,7 +256,11 @@ No alpha blockers: the alpha gate in [`roadmap.md`](roadmap.md#alpha-gate) passe
   PR (Windows 11, the desktop app driven over the control channel, the same workflow through MCP):
   eight bugs fixed, among them unsaved changes lost when the app was killed or crashed,
   Ctrl+arrows and Ctrl+Backspace acting on the whole line in text, scrubbed fields snapping back
-  and skewed linear gradients.
+  and skewed linear gradients. Linux and the BSDs (2026-10-17, #693): clipboard reads run on a
+  helper thread that gives up after 2 s, and images copied in other apps paste under Wayland
+  through the data-control protocol; compiled in CI, not run on a Linux desktop here. Wayland
+  compositors without server-side decorations (GNOME) give the window winit's Adwaita controls
+  (#592: checked by its author on GNOME; KDE not run).
 - **Impact:** unknown bugs on the platforms where FigCraft is most attractive (Linux has no Figma
   desktop app).
 - **Estimate:** 10–20 h, partly human (hardware).
@@ -264,11 +309,14 @@ No alpha blockers: the alpha gate in [`roadmap.md`](roadmap.md#alpha-gate) passe
 - **Estimate:** 5–10 h (video playback in the presenter is most of it; it can reuse the GIF clock).
 
 ### 13. Vector tail: none left
+- **Landed (2026-10-22):** the transform box around points selected in several layers at once, in
+  the page's axes: its corners and edges scale them, outside a corner rotates them and inside drags
+  them, each in its own layer and one undo step for all (`transform_tests`).
 - **Landed (2026-10-12):** several Bezier handles selected with Shift-click and dragged together,
   sharp points beside curved segments rounded, a stroke cap and join per point (canvas, PNG, SVG,
   PDF, outline stroke), the Pen outside edit mode connecting to its own points and continuing a
-  selected open path. Left: corner smoothing beyond rectangles and frames, the transform box around
-  points of several layers, per-point caps and joins on dashed, variable-width and brush strokes.
+  selected open path. Left: corner smoothing beyond rectangles and frames, per-point caps and joins
+  on dashed, variable-width and brush strokes.
 - **Landed (2026-10-11):** boolean groups are clicked where their result is (a click in a
   subtracted hole reaches what's behind; with the group or an operand selected its operands are
   hit, so each can still be picked; "Select layer" lists the group only where its result is), live
@@ -327,11 +375,22 @@ No alpha blockers: the alpha gate in [`roadmap.md`](roadmap.md#alpha-gate) passe
   host, no spaces, capped) and never fetched: a link added without a name is named after its URL,
   and a link opens only when clicked. The Inspect tab lists, adds, edits and removes them;
   `get_node` / `inspect_document` return them as `devResources`.
-- **Missing:** import lines for connected instances inside a
-  generated layer tree (only the selected layer's own import is shown); publishing mappings from
-  the code repository with a CLI. An editor extension is out of scope: the MCP server already
-  serves design data, code and the connected snippets to agents and editors.
-- **Estimate:** 0–1 h.
+- **Landed (2026-10-15):** generated layer trees (React, Leptos, SwiftUI, Compose) start with the
+  import lines of the connected components they call, once each, also those in a component's
+  definition, in the slots an instance fills and placed by a connected template's instance swaps.
+  Compare changes takes any saved version as the before (`dev.compare {version}`; the view's
+  Compare with menu), for any top-level frame or section. A Dev Mode behaviour suite: the canvas
+  only inspects (presses select, pan and comment; no moving, resizing, drawing, text or vector
+  editing), the menus, shortcuts, nudges, opacity keys and paste refuse design edits with a note
+  while Dev Mode's own edits still run, drawing tools from the toolbar return to the design; the
+  ready list filters and badges Changed items (`inspect.readyForDev {status: changed}`); statuses
+  are refused on layers inside frames. Read-only plugins run from the Inspect tab show their
+  panels.
+- **Missing:** measurements kept on the canvas for others (only hover redlines); the layers panel
+  and files dropped on the canvas still edit in Dev Mode; publishing mappings from the code
+  repository with a CLI. An editor extension is out of scope: the MCP server already serves design
+  data, code and the connected snippets to agents and editors.
+- **Estimate:** 2–4 h.
 
 ### 17. Branching and merging
 - **Landed (2026-10-11):** branches of a file (`branch.*`): File ▸ Create branch… (or the Branches
@@ -396,11 +455,27 @@ No alpha blockers: the alpha gate in [`roadmap.md`](roadmap.md#alpha-gate) passe
   repository (licensing).
 - **Estimate:** 2–4 h once an openly licensed profile is found.
 
+### 24. Boards: the whiteboard tail
+- **Landed (2026-10-24, M12):** board files (`file.newBoard`) with sticky notes, shapes with text,
+  connectors that re-route when what they join moves, marker, highlighter and eraser, stamps, text
+  and sections; a board toolbar and a contextual bar; live sessions sync it all.
+- **Missing:** timer and music, voting sessions, board widgets, templates, tables, mind maps, washi
+  tape, code blocks, audio and huddles, quick-create handles, curved connectors and waypoints,
+  stamps sticking to the objects they land on, a dot grid, `.jam` files
+  ([`boards-parity.md`](boards-parity.md)).
+- **User impact:** boards cover a brainstorm or a flow sketch; facilitated workshops need the
+  timer, voting and templates.
+- **Estimate:** 30–60 h.
+
 ## Revision history
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-24 | minor | Boards (M12): a file kind of its own (`file.newBoard`, saved in `.figcraft`, carried to live-session joiners) with sticky notes, shapes with text, connectors that re-route when what they join moves (an engine recompute, the same for local edits, undo and others' edits), marker, highlighter and eraser, stamps with the placer's name, a board toolbar and a contextual bar; prototyping and Dev Mode refuse on boards; design files and boards have their own marks on tabs and file rows. New gap 24 (the board tail, 30–60 h); the ranking above it is unchanged |
+| 2026-10-15 | minor | Gap 5: Turkish reviewed by a native speaker (#263), Czech (#469) and Indonesian (#477) drafts, the Japanese draft caught up (#288); Indonesian is no longer missing; counts re-measured (2,177 entries) and corrected: only Spanish is held to completeness, Russian included. Estimate unchanged at this rounding |
+| 2026-10-17 | minor | The 2026-10-17 landings. Gap 1: a new Landed entry (community batches #727 and #728, then #745: instance identity and cached library components, overrides by key, text style precedence, grid track sizes, slot content, labels of connectors saved with their path, skip ink, paragraph options, list start numbers, vertical trim, per-point stroke joins, text on a path, image adjustments, images in the message, instance layers' size and resizing overrides, Hug where nothing is recorded; budgets from the file's size; the import report; a `.fig` copy from Save as; paste from another design app), its Missing list cut to what is still left, and the wrong "whether other apps open its files is unknown" replaced by what was checked; all on synthetic files, so the beta blocker and hours stand. Gap 2: server limits, log recovery and web join links in the evidence. Gap 4: menus, the Actions palette and the editor fixes (#733, #735, #736, #729), then Selection colors and smart-selection spacing (#753) landed, none compared side by side. Gap 5: catalog counts re-measured (2,272 entries; drafts at 95–99%; Indonesian, Czech, Turkish and Swedish listed). Gap 8: the Linux and BSD clipboard changes and Wayland window controls, not run there by the maintainers. Ranking and hours unchanged |
 | 2026-10-15 | minor | Gap 7: bounded canvas overscan for smoother panning. Estimates and ranking unchanged. |
+| 2026-10-15 | minor | Gap 16: import lines inside generated layer trees, compare with any saved version, an inspect-only Dev Mode canvas (menus and shortcuts refuse design edits), Changed in the ready list, statuses only on sections and top-level frames, read-only plugins' panels from the Inspect tab. Left: measurements kept on the canvas, a read-only layers panel, publishing mappings with a CLI; 0–1 h → 2–4 h |
 | 2026-10-14 | minor | Russian catalog (M9), reviewed and approved by VanTan: all 2,165 current entries, Русский in Preferences and regional ru tags. Russian integer plurals use one/few/many; contributor display name VanTan added. Existing estimates unchanged. |
 | 2026-10-13 | minor | Gap 1: the experimental `.fig` export writes instance sizes (resized, filling an auto layout, scaled), variables with modes and bindings, shared styles and variable-width strokes, and the import reads them back. Checked by opening written files in other software: resized and scaled instances keep their size and lay their layers out for it, variables with their modes and colour bindings resolve there (a frame set to another mode shows that mode's colours, also inside instances), colour, text, effect and grid styles are listed, and variable-width strokes that are the same on both sides of the path draw with their width; number, string and boolean bindings and bindings on effects, layout guides and gradient stops come across as the values they give but did not show as bound there (their entries now also name the layer field they set, not yet checked there), and strokes wider on one side of the path are written as filled outlines, no longer editable strokes there (the stroke itself is kept as plugin data and our own import puts it back; not yet checked there). Hours and the ranking unchanged |
 | 2026-10-12 | minor | Gap 2: your online files landed (the app records the files it put on a server with their owner tokens, Home ▸ Online lists them and opens them again as their owner, with sharing, rename, removal and forget from the list; one request per server tells which are still there; tabs mark files in a live session). What is left is unchanged: accounts, teams and per-person permissions, shared comments and versions. Hours unchanged |
diff --git a/docs/hardware-parity.md b/docs/hardware-parity.md
index a990d75b6..f5be7263d 100644
--- a/docs/hardware-parity.md
+++ b/docs/hardware-parity.md
@@ -1,6 +1,6 @@
 # Hardware and platform parity
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-14 · **Change:** minor (copy and paste in the browser; Windows QA pass; Display P3: gamut warning and soft-proof (true P3 blocked upstream); several windows; pen pressure for the Pencil and brushes on Windows and from browser styluses) · **Target:** Figma Design (desktop app 126.10.7)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-18 · **Change:** minor (zoom previews; hidden windows answer control requests; macOS file opening, the Windows start-up message, Linux packaging; copy and paste in the browser; Windows QA pass; Display P3: gamut warning and soft-proof (true P3 blocked upstream); several windows; pen pressure for the Pencil and brushes on Windows and from browser styluses; macOS: quitting ends the process once everything is kept, avoiding the Touch Bar teardown crash (#781); Linux and BSD clipboard: images under Wayland, reads time out; minimised windows under Wayland; window controls on Wayland without server decorations; canvas textures on device pixels; copy and paste in the browser; Windows QA pass; Display P3: gamut warning and soft-proof (true P3 blocked upstream); several windows; pen pressure for the Pencil and brushes on Windows and from browser styluses) · **Target:** Figma Design (desktop app 126.10.7)
 
 How FigCraft uses hardware and which platforms it runs on, against Figma. Figma's desktop app is
 Electron with a GPU helper process; its canvas renders on the GPU (WebGL, with WebGPU rolling out
@@ -12,13 +12,13 @@ since 2025). FigCraft renders the canvas on the CPU and presents it through wgpu
 
 | Feature | Figma | FigCraft (macOS / Windows / Linux / web) | Hours |
 |---|---|---|---|
-| Canvas rendering | GPU | CPU (tiny-skia), banded across cores, retained (re-renders only what an edit or pan touches), levels of detail below 50% zoom; shown through wgpu (WebGPU or WebGL2 in the browser) | 30–60 for a GPU path |
+| Canvas rendering | GPU | CPU (tiny-skia), banded across cores, retained (re-renders only what an edit or pan touches), levels of detail below 50% zoom; when renders from scratch are slow, a new zoom shows the whole view coarsely first, then refines it (#312); shown through wgpu (WebGPU or WebGL2 in the browser) | 30–60 for a GPU path |
 | Effects (blurs, glass, noise) | GPU | CPU | in the above |
-| HiDPI / Retina | yes | yes (all) | — |
+| HiDPI / Retina | yes | yes (all); a canvas image rendered at the screen's density is placed on whole device pixels, so fractional pans, zooms and display scales don't blur it (#359; geometry tests, the snapping not judged by eye) | — |
 | Wide-gamut display (Display P3) | yes, on capable displays | colours stored and exported in P3; the screen shows sRGB: eframe/egui-wgpu 0.36 configure an 8-bit sRGB surface with no colour space option, although wgpu 30 can present Display P3 or extended sRGB on Metal, DX12, Vulkan and WebGPU (see gaps #18). The colour picker warns about colours outside sRGB and View ▸ Soft-proof sRGB stripes them on the canvas | 2–5 |
 | Trackpad pinch zoom and two-finger pan | yes | yes (egui zoom delta, smooth scroll) | — |
 | Pen tablet pressure (pencil, Figma Draw brushes) | yes (forum reports of regressions in 2025) | Windows pens (winit pointer input) and browser styluses that send touch events with a force (an Apple Pencil in Safari); the Pencil records it as the stroke's width profile. A mouse, macOS and Linux tablets and pens sending only pointer events in a browser report none: constant width | 1–3 |
-| Several windows / multi-monitor | yes (a window per file; presenter in its own window) | desktop: File ▸ New window, a tab's Open in new window or a tab dragged off the strip; each window has its own tabs, panels and canvas, draws only when it needs to and asks about unsaved changes when it closes. Only the main window has a screen-reader tree (eframe 0.36), so files stay tabs while a screen reader runs; positions aren't restored at the next start; the presenter stays inside its window; one window in the browser | 1–2 |
+| Several windows / multi-monitor | yes (a window per file; presenter in its own window) | desktop: File ▸ New window, a tab's Open in new window or a tab dragged off the strip; each window has its own tabs, panels and canvas, draws only when it needs to and asks about unsaved changes when it closes; a minimised or covered window still answers control and MCP requests, while screenshots and input fail at once until it is on screen (#313, #332, #720). Only the main window has a screen-reader tree (eframe 0.36), so files stay tabs while a screen reader runs; positions aren't restored at the next start; the presenter stays inside its window; one window in the browser | 1–2 |
 | Screen readers | partial | AccessKit tree on desktop (names, roles, states), never tested with a real screen reader; none in the browser | 4–8 + human QA |
 | Keyboard layouts (non-US) | yes | keymap uses logical keys; not checked on AZERTY/QWERTZ/JIS | 1–2 |
 
@@ -39,9 +39,9 @@ Nothing has been timed against Figma on the same document (needs `.fig` import).
 
 | Platform | Figma | FigCraft | Notes |
 |---|---|---|---|
-| macOS | desktop app (Intel and Apple silicon) | universal `.dmg`, signed and notarized (v0.2.0) | where nearly all QA happens |
+| macOS | desktop app (Intel and Apple silicon) | universal `.dmg`, signed and notarized (v0.2.0) | where nearly all QA happens. Quitting ends the process once the preferences, recovery copies and live sessions are taken care of: the window's teardown crashed on Macs with a Touch Bar (#781); Quit from the menu bar, which asks nothing, keeps unsaved files' recovery copies for the next start |
 | Windows x64 / arm64 | desktop app | `.msi` and portable zip for x64, x86 and arm64 | built in CI; Windows: QA pass done 2026-10-11, findings in PR |
-| Linux | none (browser only) | AppImage, `.deb`, `.rpm`, Flatpak, tarball, x86_64 and aarch64; riscv64 tarball | CI tests run here |
+| Linux | none (browser only) | AppImage, `.deb`, `.rpm`, Flatpak, tarball, x86_64 and aarch64; riscv64 tarball | CI tests run here. Clipboard (also the BSDs): reads run on a helper thread that gives up after 2 s, and images copied in other apps paste under Wayland through the data-control protocol (#693). Under Wayland the app can't tell its window is minimised, so control requests that need a drawn frame may still wait there (#720). None of this run on a Linux desktop here. On a Wayland compositor without server-side decorations (GNOME) the window gets winit's Adwaita controls (#592: checked by its author in a GNOME Wayland session; KDE not run) |
 | FreeBSD | none | tarball | |
 | Web | primary (figma.com) | `figcraft-web` (WASM, WebGPU/WebGL2), web zip | no accessibility tree; file access through the browser; copy and paste through the system clipboard (copies written from the copy event, pastes read from the paste event; no pasting images from other apps) |
 | iOS / Android | apps: view, comment, mirror prototypes | none (the web build is not touch-first) | 20–40 h for a viewer |
@@ -50,6 +50,9 @@ Nothing has been timed against Figma on the same document (needs `.fig` import).
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-15 | minor | Community fixes (#290, #306, #312, #313, #328, #332, #346, #474): coarse zoom previews when renders from scratch are slow; a minimised or covered window answers control and MCP requests (screenshots and input fail at once while it is hidden); `.figcraft` files open from Finder on macOS; a message box when the window can't open on Windows; on Linux the window id matches the desktop entry, the RPM requires glibc 2.35 and user fonts under `XDG_DATA_HOME` are found. Numbers unchanged |
+| 2026-10-18 | minor | macOS quit crash (#781): on Macs with a Touch Bar the app could crash as it quit (an exception in AppKit's Touch Bar support while the window's content view, which the accessibility adapter subclasses, was torn down). Quitting now keeps everything (preferences, this run's recovery copies, live sessions ended) and then ends the process before that teardown. Quit from the menu bar ends the app without the unsaved-changes question, so unsaved files' recovery copies now stay and reopen at the next start instead of being removed. Numbers unchanged |
+| 2026-10-17 | minor | Linux row: clipboard reads on Linux and the BSDs time out after 2 s on a helper thread, images copied in other apps paste under Wayland (arboard's data-control feature, #693), a minimised window can't be detected under Wayland, so frame-only control requests may still wait there (#720), and Wayland compositors without server-side decorations give the window Adwaita controls (#592, checked by its author on GNOME, not by the maintainers; KDE not run); compiled in CI, not run on a Linux desktop. HiDPI row: native-density canvas images placed on whole device pixels (#359, geometry tests; not judged by eye). Numbers unchanged |
 | 2026-10-14 | minor | Copy and paste in the browser: the web build never wrote to the system clipboard, so Cmd+V after Cmd+C pasted whatever text the clipboard held before (as a text layer) instead of the copied layers. Copies (layers, Copy as SVG/CSS/text/PNG, links) now go out through egui's output, which eframe writes during the copy event (`web_clipboard_tests`). Numbers unchanged. |
 | 2026-10-11 | minor | Windows QA pass (gap 8): everyday workflows on Windows 11 through the desktop app and MCP; fixed: unsaved changes lost when the app was killed or crashed (recovery copies every few seconds, reopened at the next start), Ctrl+arrows/Backspace/Delete acting on the whole line in text (now by word; Ctrl+Home/End to the text's ends), scrubbed fields snapping back on release, typing on a field Tab reached, Escape not closing dialogs, skewed or vanishing linear gradients, hints cut off at the panel edge, the window-close question in English in the Spanish interface. Percentages and hours unchanged |
 | 2026-10-11 | minor | Display P3 honest minimum (gap 18): the colour picker of a Display P3 file warns when a colour is outside sRGB (Outside sRGB, with what the canvas and exports do), and View ▸ Soft-proof sRGB (`view.proofSrgb`) stripes the canvas pixels sRGB can't show. Why the canvas still shows sRGB: wgpu 30 can present Display P3 or extended-range sRGB surfaces (Metal, DX12, Vulkan, WebGPU canvases), but eframe/egui-wgpu 0.36 configure an 8-bit sRGB surface with no option for the format or colour space, and egui's renderer writes sRGB-encoded UI colours; showing P3 needs those two upstream (or a patched egui-wgpu). Hardware 13–27 h → 12–26 h; gap 18 6–12 h → 5–11 h; percentages, feature breadth (~79%) and ready for real work (~47%) unchanged at this rounding; full parity ~363–697 h → ~362–696 h |
diff --git a/docs/localization-parity.md b/docs/localization-parity.md
index 45a7a925a..aa4cbb524 100644
--- a/docs/localization-parity.md
+++ b/docs/localization-parity.md
@@ -1,10 +1,11 @@
 # Localization parity
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-12 · **Change:** minor (draft catalogs catch up: every draft translates every string again; Simplified Chinese draft catalog) · **Target:** Figma Design (desktop app 126.10.7)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-23 · **Change:** minor (a missing translation fails no check: `cargo xtask i18n-report` lists them; Russian and Turkish catalogs reviewed by native speakers, Russian one/few/many plurals; Czech and Indonesian drafts; the Japanese draft completed; counts re-measured; Windows UI language from the first preferred language; draft catalogs catch up: every draft translates every string again; Simplified Chinese draft catalog; macOS finds its downloadable CJK system fonts (#406); string counts re-measured: 2,272 entries, the drafts at 95–99%; Swedish command labels and menu wordings; Russian, Swedish, Turkish, Czech and Indonesian listed; a duplicated paragraph removed; draft catalogs catch up: every draft translates every string again; Simplified Chinese draft catalog) · **Target:** Figma Design (desktop app 126.10.7)
 
-FigCraft's interface has a localization layer with an English catalog and Spanish (with a Latin
-American overlay), French, German, Brazilian Portuguese, Japanese, Korean and Simplified Chinese
-drafts (machine-drafted, waiting for native speakers' review). This page lists the twelve key
+FigCraft's interface has a localization layer with an English catalog, a Russian catalog reviewed
+by a native speaker, and Spanish (with a Latin American overlay), French, German, Brazilian
+Portuguese, Japanese, Korean, Simplified Chinese, Indonesian and Czech drafts (machine-drafted,
+waiting for native speakers' review), plus Swedish and Turkish catalogs. This page lists the twelve key
 languages of the craftrules standard, then the other languages Figma ships. How to add a
 language: [`translating.md`](translating.md).
 
@@ -17,43 +18,39 @@ browser's page translation. The `.lproj` folders in `/Applications/Figma.app` (6
 Electron/Chromium locale packs, not Figma's own UI languages. Text *content* in any script is
 supported by both apps (CJK, Arabic and Devanagari shaping, IME); Figma has no vertical text.
 
-## What FigCraft has (measured 2026-10-12, from source)
+## What FigCraft has (measured 2026-10-17, from source)
 
 - **Layer:** one TOML catalog per language in `crates/ui-egui/locales/`, baked into the binary by
   the UI crate's build script (desktop and web; nothing read at run time). Keys are the English text
   (`tr("Fill")`, `trf` for `{named}` placeholders, `trn` for counts with one/few/many/other plural forms), so
   a missing translation shows English, never a raw key. One English text that needs two
   translations takes a context (`"Fill|sizing"`).
-- **Strings:** 1,417 UI keys in `en.toml` (36 with plural forms; ~110 are labels from engine and
-  document data, such as tool names, blend modes and Dev Mode properties) plus 536 command labels
-  and 29 menu wordings by command id: 1,982 entries. Command ids, the CLI, MCP and the control
+- **Strings:** 1,680 UI keys in `en.toml` (41 with plural forms; ~110 are labels from engine and
+  document data, such as tool names, blend modes and Dev Mode properties) plus 561 command labels
+  and 31 menu wordings by command id: 2,272 entries (counted against `en.toml` and the complete
+  Spanish catalog's command and menu tables). Command ids, the CLI, MCP and the control
   channel stay English. Accessibility names come from the same strings.
-- **Language preference:** Preferences ▸ Language (System, English, Deutsch, Español, Español
-  (Latinoamérica), Français, 日本語, 한국어, Português (Brasil), 简体中文), applied at once without a
+- **Language preference:** Preferences ▸ Language (System, then each catalog by its own name:
+  English, Čeština, Deutsch, Español, Español (Latinoamérica), Français, Bahasa Indonesia, 日本語,
+  한국어, Português (Brasil), Русский, Svenska, Türkçe, 简体中文), applied at once without a
   restart; System takes the first of the OS's preferred languages that has a catalog (on Windows
   only the first preferred language counts, since that list also holds the languages added for a
   keyboard; macOS AppleLanguages, `LANGUAGE` then the locale variables on Linux and BSD; a regional
   tag falls back to its language, pt-PT or pt to pt-BR, and es-419, es-MX, es-AR, es-CO and the
-  other Latin American and US Spanish tags to es-419; zh, zh-CN, zh-SG and zh-Hans read zh-Hans,
+  other Latin American and US Spanish tags to es-419; regional ru, tr, cs and id tags (ru-RU,
+  tr-TR, cs-CZ, id-ID) to their catalogs; zh, zh-CN, zh-SG and zh-Hans read zh-Hans,
   while Traditional Chinese (zh-Hant, zh-TW, zh-HK, zh-MO) has no catalog and reads English or the
   next OS language, never Simplified) or the browser's language on the web.
-  (Latinoamérica), Français, 日本語, 한국어, Português (Brasil), Svenska, 简体中文), applied at once without a
-  restart; System takes the first of the OS's preferred languages that has a catalog (Windows'
-  language list, macOS AppleLanguages, `LANGUAGE` then the locale variables on Linux and BSD; a regional tag
-  falls back to its language, pt-PT or pt to pt-BR, and es-419, es-MX, es-AR, es-CO and the other
-  Latin American and US Spanish tags to es-419; zh, zh-CN, zh-SG and zh-Hans read zh-Hans, while
-  Traditional Chinese (zh-Hant, zh-TW, zh-HK, zh-MO) has no catalog and reads English or the next OS
-  language, never Simplified) or the browser's language on the web.
   `pref.language {language}` sets it from the CLI, MCP and the control channel.
 - **Regional overlays:** a regional catalog whose language has a catalog lists only what differs
   (`es-419.toml` over `es.toml`); its UI strings, command labels and menu wordings read the
   overlay, then the base language, then English.
 - **Check:** `cargo test -p figcraft-ui-egui i18n` fails on keys the code uses that `en.toml`
-  lacks, keys no code uses, unknown command ids, placeholders that differ from English, overlay
-  entries that read as in their base language and, for complete languages (Spanish), anything
-  untranslated. The other drafts are not held to it: a string added later shows English there
-  until someone translates it. Every draft translates every string as of 2026-10-12 (checked by
-  adding each to `COMPLETE` locally and running the check).
+  lacks, keys no code uses, unknown command ids, placeholders that differ from English and overlay
+  entries that read as in their base language. No language is held to full coverage: a string
+  added later shows English until someone translates it, and `cargo xtask i18n-report` (part of
+  `cargo xtask ci`) lists what each language lacks. Every draft translated every string on
+  2026-10-12; by 2026-10-17 the strings added since left them at 95–99% (table below).
 - **Not yet localized:** messages the engine writes (errors, a few toasts, Dev Mode property values
   such as "inside"), number formatting (decimal points stay `.`), and decimal plural rules
   (`trn` takes integers: Czech uses one/few/other and Russian one/few/many; French and Brazilian
@@ -67,12 +64,15 @@ supported by both apps (CJK, Arabic and Devanagari shaping, IME); Figma has no v
 - **Script support in the UI:** menus widen to their longest label; dropdowns, the two-column
   labels of the right panel and the home screen's cards keep a long translation on one line with an
   ellipsis and show it in full on hover (checked in German, the longest); no mirrored
-  (right-to-left) layout of panels. CJK translations are shorter than English; the same ellipsis
+  (right-to-left) layout of panels. Cyrillic, Turkish and Czech letters draw from the UI fonts
+  (no font added; Russian checked in screenshots). CJK translations are shorter than English; the same ellipsis
   and tooltip cover the few that don't fit (the sizing dropdowns).
 - **CJK UI fonts:** egui's fonts and Inter have no CJK glyphs. Once the UI language, the open
   file's names or comments, typed text or the language picker needs Japanese kana, Hangul or Han,
   the desktop app adds one installed face per script to the UI's fallbacks (Windows: Yu Gothic UI,
-  Meiryo, Malgun Gothic, Microsoft YaHei; macOS: Hiragino Sans, Apple SD Gothic Neo, PingFang SC;
+  Meiryo, Malgun Gothic, Microsoft YaHei; macOS: Hiragino Sans, Apple SD Gothic Neo, PingFang SC,
+  Hiragino Sans GB, Heiti SC, also from the system's downloaded font assets
+  (`/System/Library/AssetsV2/com_apple_MobileAsset_Font*`, where current versions keep PingFang);
   Linux and BSD: Noto Sans CJK, Source Han Sans, Nanum, WenQuanYi; the craft-fonts build's BIZ
   UDPGothic first), the UI language's script first; Han without kana outside a Japanese or Korean UI
   reads as Chinese, and a Chinese UI puts its Chinese face (Microsoft YaHei, PingFang SC, Noto Sans
@@ -87,37 +87,45 @@ supported by both apps (CJK, Arabic and Devanagari shaping, IME); Figma has no v
 
 | Language | Code | UI strings translated | Dialogs / tooltips / help | Script support | Native review | Status | Hours to full |
 |---|---|---|---|---|---|---|---|
-| English | en | 2,076 / 2,076 (100%, source) | yes | Latin | yes (source) | full | 0 |
-| Simplified Chinese (Mandarin) | zh-Hans | 2,076 / 2,076 (100%, draft) | yes | CJK text and IME in documents; UI text in an installed Chinese face, ahead of Japanese ones (web: the `FIGCRAFT_EMBED_CJK` build); no Traditional Chinese catalog (zh-TW, zh-HK read English) | no | draft | 1–2 (after native review) |
-| Spanish | es, es-419 | 2,076 / 2,076 (100%, draft); es-419 overlays 98 Latin American wordings (draft) | yes | Latin | no | draft | 0–1 (after native review) |
+| English | en | 2,272 / 2,272 (100%, source) | yes | Latin | yes (source) | full | 0 |
+| Simplified Chinese (Mandarin) | zh-Hans | 2,166 / 2,272 (95.3%, draft) | yes | CJK text and IME in documents; UI text in an installed Chinese face, ahead of Japanese ones (web: the `FIGCRAFT_EMBED_CJK` build); no Traditional Chinese catalog (zh-TW, zh-HK read English) | no | draft | 1–2 (after native review) |
+| Spanish | es, es-419 | 2,272 / 2,272 (100%, draft); es-419 overlays 101 Latin American wordings (draft) | yes | Latin | no | draft | 0–1 (after native review) |
 | Hindi | hi | 0 (0%) | no | Devanagari shaping works in documents; UI font fallback to check | no | none | 4–7 |
 | Arabic | ar | 0 (0%) | no | Bidi, shaping and RTL names work; the UI does not mirror | no | none | 9–15 |
-| French | fr | 2,076 / 2,076 (100%, draft) | yes | Latin | no | draft | 1–2 (after native review) |
-| Portuguese | pt-BR | 2,076 / 2,076 (100%, draft) | yes | Latin | no | draft | 1–2 (after native review) |
-| Indonesian | id | 0 (0%) | no | Latin | no | none | 3–5 |
-| Japanese | ja | 2,076 / 2,076 (100%, draft) | yes | CJK text and IME in documents; UI text in an installed Japanese face (web: the `FIGCRAFT_EMBED_CJK` build) | no | draft | 1–2 (after native review) |
-| German | de | 2,076 / 2,076 (100%, draft) | yes | Latin; long words elide in narrow fields | no | draft | 1–2 (after native review) |
-| Korean | ko | 2,076 / 2,076 (100%, draft) | yes | Hangul text and IME in documents; UI text in an installed Korean face (web: the `FIGCRAFT_EMBED_CJK` build) | no | draft | 1–2 (after native review) |
+| French | fr | 2,167 / 2,272 (95.4%, draft) | yes | Latin | no | draft | 1–2 (after native review) |
+| Portuguese | pt-BR | 2,167 / 2,272 (95.4%, draft) | yes | Latin | no | draft | 1–2 (after native review) |
+| Indonesian | id | 2,244 / 2,272 (98.8%, draft) | yes | Latin | no | draft | 1–2 (after native review) |
+| Japanese | ja | 2,254 / 2,272 (99.2%, draft) | yes | CJK text and IME in documents; UI text in an installed Japanese face (web: the `FIGCRAFT_EMBED_CJK` build) | no | draft | 1–2 (after native review) |
+| German | de | 2,176 / 2,272 (95.8%, draft) | yes | Latin; long words elide in narrow fields | no | draft | 1–2 (after native review) |
+| Korean | ko | 2,166 / 2,272 (95.3%, draft) | yes | Hangul text and IME in documents; UI text in an installed Korean face (web: the `FIGCRAFT_EMBED_CJK` build) | no | draft | 1–2 (after native review) |
 | Vietnamese | vi | 0 (0%) | no | Latin with stacked diacritics | no | none | 3–5 |
 
-Other languages: Swedish (`sv`): every UI string translated, and 120 of the 588 command labels and
-menu wordings (the rest show in English); native review welcome. Figma ships none beyond the eight
-above.
+Other languages (measured 2026-10-17): Russian (`ru`) 2,244 / 2,272 (98.8%), reviewed and approved
+by VanTan, one/few/many integer plurals; Swedish (`sv`) 2,264 (99.6%), its command labels and menu
+wordings added 2026-10-17 (#599), native review welcome; Turkish (`tr`) 2,243 (98.7%), whose header
+says it was machine-drafted and reviewed by a native speaker; Czech (`cs`) 2,244 (98.8%), a draft
+with one/few/other plurals. Figma ships none beyond the eight above.
 
 The layer is done. Per-language hours above are agent hours for a catalog of ~1,800 entries
 (a machine draft, then a pass over the panels for overflow), plus each language's plural rule where
 it isn't one/other; every language also needs a native speaker's review (human). Left before full
 parity besides the languages: localizing engine messages and number formatting (4–6 h);
-right-to-left mirroring of the panels is in Arabic's hours. Total: **29–51 h**.
+right-to-left mirroring of the panels is in Arabic's hours. Total: **29–51 h** (kept on
+2026-10-17: Indonesian's draft takes 2–3 h off, about what bringing the drafts back from 95% to
+every string adds).
 
-Priority: native reviews of the seven drafts and the es-419 overlay (every one of Figma's languages
-and variants has one, plus Simplified Chinese, which Figma doesn't ship), then Hindi, Indonesian,
-Vietnamese and Arabic. Traditional Chinese is not planned (no catalog; its users see English).
+Priority: native reviews of the drafts and the es-419 overlay (every one of Figma's languages
+and variants has one, plus Simplified Chinese, Indonesian and Czech, which Figma doesn't ship), then
+Hindi, Vietnamese and Arabic. Traditional Chinese is not planned (no catalog; its users see English).
 
 ## Revision history
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-23 | minor | A missing translation fails no check: Spanish is no longer held to full coverage, and the tests of one language's wording, names and plural forms are gone (the plural rules and language-tag tests stay). `cargo xtask i18n-report`, run by `cargo xtask ci`, lists each language's missing UI strings, command labels and menu wordings. Grade unchanged |
+| 2026-10-15 | minor | Community catalogs (#257, #263, #469, #477, #288): Russian (`ru`, Русский, reviewed and approved by VanTan) and Turkish (`tr`, Türkçe, reviewed by a native speaker), Czech (`cs`, Čeština) and Indonesian (`id`, Bahasa Indonesia) drafts, and the Japanese draft caught up; Preferences ▸ Language lists them and System maps their regional tags. Catalogs may give few and many plural forms; Russian picks one, few or many by its integer rule (11–14 take many), the catalog supplying the text choosing the rule. Only Spanish is held to completeness. Counts re-measured: 1,587 UI keys (38 plural), 559 command labels and 31 menu wordings, 2,177 entries; Spanish 100%, Japanese 2,176, Czech and Indonesian 2,166, Russian and Turkish 2,165, the five older drafts 2,088–2,089 (95%). Localization 39% and 29–51 h unchanged at this rounding |
+| 2026-10-17 | minor | Chinese showed as boxes on macOS (#406): the font scan also walks the system's downloaded font assets (`/System/Library/AssetsV2` and the older `/System/Library/Assets`, only their `com_apple_MobileAsset_Font*` folders), where current versions keep PingFang SC, and Hiragino Sans GB and Heiti SC join the Chinese UI faces and the text fallbacks. Tested with a folder laid out the same way; not yet run on a Mac |
+| 2026-10-17 | minor | String counts re-measured from the catalogs: 1,680 UI keys, 561 command labels and 31 menu wordings (2,272 entries); Spanish complete, the other drafts at 95.3–99.2% (strings added since 2026-10-12 show English), es-419 101 entries. Indonesian has a draft (98.8%; it was listed as none); Russian (98.8%, reviewed), Swedish (99.6%, command labels and menu wordings from #599), Turkish (98.7%) and Czech (98.8%) listed with counts; the language picker's list updated; a paragraph repeated by a merge removed. Grade and hours unchanged (Indonesian's draft is offset by the drafts' new gaps) |
 | 2026-10-14 | minor | Windows UI language (#291): the interface language comes from Windows' first preferred language alone; that list is also the input-language list (a German keyboard on a Polish system adds Deutsch), and taking the first entry with a catalog turned the interface German there. A first preferred language without a catalog reads English; macOS AppleLanguages and gettext's `LANGUAGE` still take the first language with a catalog |
 | 2026-10-12 | minor | Drafts catch up again, and the counts with them: French, German, Brazilian Portuguese, Japanese, Korean and Simplified Chinese translate the 71 UI strings and 5 command labels they lacked since sharing with a join code and open hosting (the Share popover, join codes, owner tokens, reports, the .fig export notes), and with Spanish the 26 strings and 3 command labels of your online files (Home ▸ Online, its menu and dialogs, the marks on tabs); machine-drafted in each file's conventions, still drafts. The Latin American overlay adds computadora and agrega where the new Spanish says ordenador and añade (98 entries). 2,076 entries per catalog (1,503 UI strings, 544 command labels, 29 menu wordings) |
 | 2026-10-12 | minor | Draft catalogs catch up: French, German, Brazilian Portuguese, Japanese and Korean translate the 66 UI strings and 17 command labels added since they were drafted (cursor chat and spotlight, the plugin directory, Rename layers, presentation and snapping keys, list levels, the rotation origin, placing with Enter…), Simplified Chinese the 46 and 12 it lacked; machine-drafted from the English in each file's conventions, still drafts (not in `COMPLETE`). The Latin American overlay adds Control for a gamepad controller and presiona in the plugin directory hint (90 entries, with Enter for the keycap). String counts re-measured: 1,417 UI keys, 536 command labels and 29 menu wordings (1,982 entries), every draft at 100%. Localization grade unchanged |
diff --git a/docs/mcp.md b/docs/mcp.md
index 4efee72ac..ccaeb401a 100644
--- a/docs/mcp.md
+++ b/docs/mcp.md
@@ -26,6 +26,72 @@ If that connection cannot be established, the error says the request was not sen
 A connection the app closed while it sat idle is noticed before the next request is written and
 replaced then, so a pause between calls is not an error.
 
+The app keeps answering while its window is minimised or covered by other windows (see
+`docs/control-protocol.md`): edits, inspection (`inspect_ui` too), pointer, key and text input and
+renders work as usual (minimised, each request to the app takes up to about 0.1 s). Only a capture
+of the window itself (`screenshot` with `window`) needs it on screen: it is then an error at once;
+`screenshot` without `window` renders the document instead.
+
+### Confining file access
+
+The roots below belong to the **headless** side: the session `figcraft-cli mcp` runs itself, with
+no window. A server attached with `--attach` runs the commands inside the app instead, so the app
+confines them — from the flags it was started with, not from anything passed to the CLI.
+
+```sh
+figcraft-cli mcp --automation-read-root /work/project --automation-write-root /work/project/out
+```
+
+```json
+{"mcpServers": {"figcraft": {"command": "/path/to/figcraft-cli",
+  "args": ["mcp", "--automation-read-root", "/work/project", "--automation-write-root", "/work/project/out"]}}}
+```
+
+The two flags (the other Craft apps take the same ones) keep an agent to the folders you give it.
+Each may be given more than once, as `--flag DIR` or `--flag=DIR`:
+
+- Every file a tool call reads must lie inside a **read root or a write root**; every file it writes
+  inside a **write root**. Anything else is refused with an ordinary tool error the agent can read
+  and correct, for example `automation path rejected: /etc/x.png is outside the folders that may be
+  written: /work/project/out`. Nothing is written and the server keeps serving.
+- Read and write authority are separate. With only `--automation-read-root` nothing can be written
+  to disk (`export` and the export commands without a `path` still return the bytes). Without either
+  flag nothing changes.
+- The roots must be existing folders: a missing one, or a file, stops the server at startup.
+  `initialize`'s `instructions` name the folders, so the agent knows where it may work.
+- **What is covered:** everything a call does, because the engine reaches the file system through
+  one module (`crates/engine/src/file_access.rs`), and `crates/engine/clippy.toml` refuses `std::fs`
+  anywhere else in the engine, so a command added later is covered too. That is `open_file` (and the
+  `variables` file it may name), `save_file`, `export {path}`, and through `run_command` / `batch`
+  every command that names a file: `file.open`, `file.openRecent` (recent files outside the roots
+  are never listed, opened, removed or named: `index` counts the files listed), `file.import`,
+  `file.placeImage`, `image.place`, `file.save`, `file.saveAs`, `file.revert`, `file.recover`,
+  `file.export`, `file.exportSvg`, `file.exportLayers` (and the folders it makes), `file.exportFramesPdf`, the images and variables JSON read next to an imported REST API
+  file, `library.add` and the library files open documents link to, `variable.import` /
+  `variable.export`, `codeConnect.import` / `codeConnect.export`, `component.playground {path}`,
+  `plugin.import {path}`, a development plugin's module read again from disk,
+  `plugin.directory.publish {path}` and its assets, `collab.recoverFile {path}`, and the headless
+  `ui.render` / `ui.screenshot` with a `path`.
+- **How paths are resolved:** a relative path is made absolute against the server's working
+  directory, then its links are followed: the real path is what is compared and what is opened. For
+  a file that doesn't exist yet, its nearest existing folder is resolved and the rest must be plain
+  names, so `..` below a folder that doesn't exist is refused, and so is a link that leads nowhere
+  (writing through it would create its target, wherever that is). A path outside the roots gets
+  the same refusal whatever exists there, so a refusal doesn't tell what is outside. Folders are
+  compared by whole names: `/work2/x` is not inside `/work`. On Windows the case comes from the disk (`C:\WORK\x` is
+  inside `C:\work`), `\\?\` and UNC (`\\server\share\…`) paths are resolved like drive-letter ones,
+  and new names that are devices (`CON`, `NUL`, `COM1`…) or streams (`a.png:x`) are refused.
+- Not confined: the app's own folders, which no tool names (preferences, Data Recovery copies,
+  plugins installed from a plugin directory, the system fonts).
+- `--attach` with either flag is a usage error: the app runs the commands, so only the app can
+  confine them. Start it with the same flags, `figcraft --control 7979 --automation-read-root DIR
+  --automation-write-root DIR` (see [Control protocol](control-protocol.md#confining-file-access)),
+  then attach as usual. The attached `screenshot` gets its PNGs from the app as data, so no
+  temporary file is written anywhere.
+- A path is checked, then opened: another program that swaps a folder for a link in between can
+  still win that race. The roots keep an agent to the files it was given, not other software on the
+  computer; if that matters, run the server as a user that can't change the roots' folders.
+
 ### Fonts
 
 The headless server lays text out with the same fonts as the app: the fonts built into FigCraft
@@ -82,6 +148,8 @@ Or in a project's `.mcp.json`:
   there is none, so they are page coordinates then). Groups and boolean groups have no coordinate
   space of their own: a layer in a group is placed in the frame (or on the page) the group is in.
   `inspect_document` reports `x`/`y` the same way, plus `absoluteBounds` in page coordinates.
+  In `props`, `fill` and `stroke` also accept `"none"` (either case) or `null` as no paint, the
+  same as an empty `fills`/`strokes` list, so an outline-only shape can be made in one call.
 - Frames, groups, sections and masks: drawing a frame or section with the `pointer` tool around
   layers puts those fully inside it in it; sections go only on the page or in sections (moves,
   drags, pastes and new sections elsewhere are refused or land on the page); resizing a section
@@ -114,6 +182,8 @@ Or in a project's `.mcp.json`:
     columns (vertical layouts wrap top to bottom into new columns).
   - `object.convertToGroup` / `object.convertToFrame` turn a frame into a group or back in place
     (layers stay put; a group has no auto layout, fill, stroke, corner radius, clipping or grids).
+  - `object.convertToSection` turns a frame on the page or in a section into a section in place, and
+    `object.convertToFrame` turns a section back into a frame (keeping its fill, not clipping).
   - `contentAlign` (wrapping layouts): `auto` (default) packs the lines `crossGap` apart at the
     start, centre or end `crossAlign` names (lines of nothing but fill children stretch instead);
     `spaceBetween` puts the free space between the lines (one line, or no free space: like `auto`).
@@ -169,6 +239,13 @@ Or in a project's `.mcp.json`:
   user units, e.g. `{"wght": 550, "wdth": 85}` (`null` = back to what the style name implies);
   `text.setVariations {variations, replace?}` merges instead. `text.fonts {family, style?, axes: true}`
   lists a font's axes and named instances (named instances are also valid `fontStyle` values).
+  `text.missingFonts` lists the families the document names that aren't installed
+  (`{families: [{family, layers}]}`); their text draws in a fallback font. Fonts are indexed once
+  per process: after installing one, `text.rescanFonts` picks it up (`{added: [families]}`), and
+  `text.loadFont {path | data (base64)}` adds a font file without installing it (`{families}`).
+  Text boxes keep the size they were measured at: both refit the open document's auto-sizing text
+  in the new families (`refitted: [ids]`), and `text.refit {ids?}` does it for any text, e.g. a
+  file saved while its fonts were missing.
   OpenType features: `features {"liga": false, "tnum": true}`.
   Decorations: `textDecorationStyle` (`solid`, `dotted`, `wavy`), `textDecorationThickness` and
   `textDecorationOffset` (`auto`, px, or `"10%"` of the font size; the offset runs from the baseline
@@ -177,7 +254,8 @@ Or in a project's `.mcp.json`:
 - **Lists** are per paragraph: `listStyle` (`none`, `bulleted`, `numbered`) and `indentation` (the
   nesting level, 0–8) apply to the paragraphs chars `start`..`end` touch (all of them without a
   range); `get_node` reports one `listStyle` for the layer, or `lineTypes` and `lineIndentations`
-  per paragraph. `text.bulletList`, `text.numberList` and `text.listStyle` act on the selected
+  per paragraph, plus `listStartOffsets` when a numbered list starts past 1 (from a `.fig` file;
+  1 shows "2."). `text.bulletList`, `text.numberList` and `text.listStyle` act on the selected
   paragraphs while text is edited. Layer props: `listSpacing` (px between list items, in place of
   `paragraphSpacing`), `hangingList` (markers outside the box) and `hangingPunctuation`. While
   editing, `key` Tab / Shift+Tab nest an item or move it out, Enter on an empty item and Backspace
@@ -195,12 +273,18 @@ Or in a project's `.mcp.json`:
 - **Styles stay true to their layers**: editing a styled fill, stroke, effect or layout grid list
   (`node.set`, `fill.set`, `fill.add`, a bound variable…) unlinks that style (`styles.fill` etc. go
   `null`), so a later `style.update` doesn't overwrite the edit; `style.apply` replaces variables
-  bound to what the style sets; a text style goes on text layers only. Names are trimmed per `/`
-  folder part. `style.move {styles, before?, folder?}` reorders (and with `folder`, renames into it),
-  `style.duplicate {style}` adds "<name> copy" right below, `style.renameFolder {folder, name}`.
+  bound to what the style sets; a text style goes on text layers only. In one call, a style link
+  (`fillStyle`, `textStyle`…) wins over values it sets; set a deviation in a later call, which
+  unlinks it. Names are trimmed per `/` folder part. `style.move {styles, before?, folder?}`
+  reorders (and with `folder`, renames into it), `style.duplicate {style}` adds "<name> copy" right
+  below, `style.renameFolder {folder, name}`.
 - **Variables**: `variable.bind` refuses a variable of a type the field doesn't take (a colour on
   `width`); scopes only filter pickers. `variable.delete` / `variable.deleteCollection` unbind the
-  layers using them (they keep their last value) and give aliases to them their values.
+  layers using them (they keep their last value) and give aliases to them their values. An
+  explicit edit that changes a bound field's value (`node.set`, `transform.resize`,
+  `object.opacityKeys`, `text.style`, `text.set`, the text size, weight and
+  tracking shortcuts, a canvas drag) detaches that field's variable; fields the edit
+  left as they were stay bound.
   `variable.addMode {from}` duplicates a mode, `variable.moveMode {collection, mode, to}` reorders
   (index 0 is the default mode, which layers on Auto follow). `variable.update {codeSyntax: {WEB?,
   iOS?, ANDROID?}}` sets code names (`""` clears); generated CSS uses the Web one.
@@ -223,11 +307,11 @@ Or in a project's `.mcp.json`:
 | `create_node {type, x, y, width, height, parent, index, name, text, path, props}` | Create a frame, rectangle, ellipse, polygon, star, line, arrow, text, vector, section, component or slice; returns `{id, node}`. |
 | `set_properties {ids, props}` | `node.set` on layers (geometry, fills, strokes, effects, corner radius, auto layout, sizing, constraints, masks (`isMask`, `maskType: alpha\|vector\|luminance`), handoff status (`devStatus: none\|readyForDev\|completed`; marking again clears "Changed"), a section's `sectionContentsHidden`, text…); returns the updated layers. |
 | `inspect_document {depth, allPages}` | The document as JSON (layer tree, styles, selection, history). |
-| `get_node {id, depth}` | One layer as JSON. |
+| `get_node {id, depth}` | One layer as JSON; `pluginData` (`{key: value}`, values as strings) when the layer or page has layer data written with `set_properties {props: {pluginData}}`. |
 | `select {ids}` | Replace the selection (`[]` deselects). |
 | `export {ids, format, scale \| size, path?, bleed?, cropMarks?, bleedMarks?, cmyk?, contentsOnly?, includeBoundingBox?, svgOutlineText?, svgIdAttribute?, svgSimplifyStroke?}` | png, jpg, svg, webp, pdf, or `fig`: the whole file as `.fig`, experimental (see Exporting `.fig` files below); `size` is `2x`, `512w` or `512h`. The image covers what the layers paint (shadows towards their offset, strokes, unclipped children, a mask group's mask; hidden layers take no room; a slice is its area with everything under it); `contentsOnly: false` also draws every other layer showing in that area, `includeBoundingBox` exports the layers' own boxes; SVG: `svgOutlineText: false` keeps `<text>`, `svgIdAttribute` writes unique ids from layer names, `svgSimplifyStroke: false` writes every stroke as an outline. The same options go in export settings (`export.add` / `export.update`). PDF: frames one page each (sized in points), anything else together on one page; print options: `bleed` (points or a length like `"3mm"`, `"0.125in"`), crop and bleed marks, CMYK colour (see Exports below), also taken by `file.export`, `file.exportLayers`, `file.exportFramesPdf` and stored per export setting by `export.add` / `export.update`; `run_command` `file.exportFramesPdf {page?, path?}` writes every top-level frame of a page. Without `path`, images come back as MCP image content, SVG as text. Layers' own export settings: `run_command` with `export.add` / `export.update {index, size?, suffix?, format?}` / `export.remove` and `file.exportLayers {ids?, dir?, assets?}` (every layer once per setting, named `<layer><suffix>.<format>`, a slash in a layer name making a folder; `assets: true` exports the Inspect tab's assets instead: icons as SVG, images as PNG). |
 | `screenshot {ids?, scale?, maxSize?, window?}` | PNG of the page (with background) or of layers, scaled to fit `maxSize` (default 1600). `window: true` captures the app window in front when attached, a window id (see Windows below) that window. |
-| `open_file {path, variables?}` / `save_file {path?}` | Open `.figcraft`, `.json` (FigCraft JSON or REST API file JSON with its variables, see below), `.fig` (best effort, see below), `.svg` (see Importing SVG below) or an image; save as `.figcraft`. |
+| `open_file {path, variables?}` / `save_file {path?}` | Open `.figcraft`, `.json` (FigCraft JSON or REST API file JSON with its variables, see below), `.fig` (best effort, see below), `.svg` (see Importing SVG below) or an image; save as `.figcraft`. `open_file` returns `opened` (for a file opened anew, a `summary` of `name`, `pages`, `layers` and `images`, and `warnings` or `repairs`; a file that was already open just gives its `index`) and the document's `document` outline. |
 | `undo` / `redo` | Step through history. |
 | `pointer {kind, x, y, to?, steps?, tool?, shift, alt, cmd, pressure?, pressureTo?}` | Mouse gestures in page coordinates with the current tool: `click`, `double`, `drag`, `down`, `move`, `up`, `hover`. A dragged layer drops into the frame or auto layout slot under the pointer, except one inside a group, a boolean group or an instance (outside its slots), which only moves. `pressure` (0–1) is pen pressure; a drag goes from `pressure` to `pressureTo` (see Brushes and pen pressure). |
 | `key {key, shift, alt, cmd}` | A shortcut or key as if typed on the canvas (every default shortcut, tool keys, Escape, Delete, arrows, number keys for opacity, arrows that pan the view when nothing is selected; while editing text, the text shortcuts and then text editing keys). Keys are names like `A`, `0`, `Enter`, `ArrowLeft`, `=`, `/`, or egui's (`Plus`, `Questionmark`); `cmd` is Cmd on macOS and Ctrl elsewhere. |
@@ -254,6 +338,53 @@ tips; headless, it only sets the preference.
 {"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"export","arguments":{"format":"png","path":"dashboard.png"}}}
 ```
 
+### Boards
+
+A board is a file of its own kind for thinking together: `file.newBoard {name?}` opens one (its
+page is light; `inspect_document` says `kind: "board"`). Board objects are ordinary layers with a
+`board` entry `get_node` shows (`{type: sticky|shape|connector|label|stamp|ink, …}`), so the usual
+commands move, resize, recolour, copy, delete and undo them. On a design file the board commands
+refuse; on a board `proto.*`, `dev.*`, `view.prototype` and `view.devMode` refuse. Each of these is
+one undo step and returns the ids it made:
+
+- `board.sticky {x, y, text?, color?, author?, parent?}` → `{id, text}`: a sticky note (a square
+  frame whose height grows with its note; its text size shrinks as the note gets longer). `color`
+  is a board colour (`yellow orange red pink violet blue green gray`) or a hex colour; `author`
+  defaults to your name (`pref.userName`, or the one a live session gave you; `false` for none).
+- `board.nextSticky {id?, side?: right|below|left|above, edit?}` → `{id, text}`: a sticky of the
+  same colour beside the selected (or edited) one; with `edit: true` the app goes on typing in it
+  (`Shift+Cmd/Ctrl+Enter` in the app does both).
+- `board.shape {shape, x, y, width?, height?, text?, color?, parent?}` → `{id, text}`: a shape with centred,
+  wrapping text: `rectangle roundedRectangle ellipse diamond triangle speechBubble chevron`.
+- `board.connector {from, to, fromSide?, toSide?, style?: straight|elbow, startCap?, endCap?, label?}`
+  → `{id, label?}`: `from`/`to` are layer ids or `{x, y}` page points; sides are `auto` (the side
+  facing the other end) or `top right bottom left`; caps are stroke caps (default an arrow at the
+  end). The connector re-routes itself whenever what it joins moves or resizes, also when someone
+  else in a live session moves it; a deleted end stays where it was as a point. `board.label {id,
+  text}` sets its label (empty removes it).
+- `board.stamp {x, y, stamp: thumbsUp|heart|plusOne|star|question|check}` → `{id}`: a round badge
+  centred there, with your name on it for hover.
+- `board.ink {path | points, highlighter?, color?, select? (default true)}` → `{id}`: a marker (or
+  wide, see-through highlighter) stroke.
+- `board.setColor {ids?, color}`: stickies and shapes take it as their fill, connectors and ink as
+  their line. `board.setStyle {ids?, shape?, fontSize?, style?, startCap?, endCap?}`: a shape's
+  outline and text size, a connector's routing and arrowheads.
+- Tools for `pointer`: `tool.sticky {color?}`, `tool.shape {shape?}`, `tool.connector {style?}`
+  (drag from one object to another), `tool.marker {color?}`, `tool.highlighter {color?}`,
+  `tool.eraser` (drag over strokes), `tool.stamp {stamp?}`; Text and Section are the usual tools.
+
+```json
+{"command": "file.newBoard", "params": {"name": "Retro"}}
+{"command": "board.sticky", "params": {"x": 0, "y": 0, "text": "Went well", "color": "green"}}
+{"command": "board.sticky", "params": {"x": 240, "y": 0, "text": "To improve", "color": "pink"}}
+{"command": "board.connector", "params": {"from": 2, "to": 4, "style": "elbow", "label": "leads to"}}
+{"command": "board.stamp", "params": {"x": 200, "y": 0, "stamp": "plusOne"}}
+```
+
+`from` and `to` are the `id`s the two `board.sticky` calls returned (here `{"id": 2, "text": 3}` and
+`{"id": 4, "text": 5}` in a new board without an author name; a sticky with its author's name takes
+one more id). In a `batch`, step references (`{"from": {"$step": 1}, "to": {"$step": 2}}`, the `id`s steps 1 and 2 returned) avoid counting.
+
 ### Sections, handoff and arrow keys
 
 `run_command` with `object.wrapInSection {ids?, name?}` (Wrap in new section: layers on the page or
@@ -288,6 +419,10 @@ on; `key` resolves keys the way the canvas does. Commands behind keys:
 - `view.designPrototype` (`Shift+E`), `view.devMode` (`Shift+D`) and `view.leftSidebar`
   (`Shift+Cmd+\`) switch the right panel's tab or hide the left sidebar in the app (no-ops headless).
 - `doc.nextTab` / `doc.previousTab` (`Ctrl+Tab` / `Ctrl+Shift+Tab`): the next or previous open file.
+- Board tools (boards only): `tool.sticky` (`Q`), `tool.shape` (`B`), `tool.connector` (`X`),
+  `tool.marker` (`M`), `tool.highlighter` (`U`), `tool.eraser` (`E`), `tool.stamp` (`W`), and
+  `board.nextSticky` (`Shift+Cmd/Ctrl+Enter`, also while typing in a sticky). Keys no design-file
+  shortcut uses; on a design file they refuse.
 - `view.pan {dx, dy, big?}`: the arrow keys with nothing selected (`key ArrowRight` does the same)
   pan the view by 20 screen pixels a step, 200 with `big` (Shift).
 - `view.multiplayerCursors {on?}` (`Alt+Cmd+\`): show or hide others' cursors in a live session.
@@ -350,15 +485,28 @@ on; `key` resolves keys the way the canvas does. Commands behind keys:
   nested layers), Escape or a click drops it.
 - `pref.reduceMotion {on?}`: reduced motion (the interface's own animations off; the system's
   accessibility setting turns it on too). Prototype transitions still play.
+- `pref.uiScale {scale?}`: how large the whole interface is drawn, relative to the system's display
+  scale: 1 (the default) is the system's own size on every screen, 1.25 means 125 %, not 125; from
+  0.75 to 3 (outside the range it stops at the nearest end; `"auto"` is 1). Omit `scale` to read it.
+  The canvas zoom is separate. A window too small for a size above 100 % draws a smaller one until
+  it is larger; the choice is kept. In the browser the interface always follows the browser's zoom.
 - `pref.autoSave {on?}`: files that have a path save themselves a few seconds after they change
   (off by default; the desktop app's timer does it, so scripts still call `file.save`).
-- `pref.language {language: system|en|cs|ru|es|es-419|fr|de|pt-BR|ja|ko|zh-Hans|…}`: the app's interface language, applied live ("system":
-- `pref.language {language: system|en|es|es-419|fr|de|pt-BR|ja|ko|sv|zh-Hans|…}`: the app's interface language, applied live ("system":
+- `pref.startOnHome {on?}`: the desktop app starts on the Home screen instead of in a new file
+  (off by default; files named on the command line still open, and `--control` starts in a new
+  file anyway, so control callers have a document).
+- `pref.language {language: system|en|cs|ru|es|es-419|fr|de|pt-BR|ja|ka|ko|sv|zh-Hans|…}`: the app's interface language, applied live ("system":
   the OS or browser language; a language without a catalog shows English). Command ids, labels and
   every result stay English.
 
 ### Editing vectors
 
+`vector.create {path | points}` makes the layer's box from the geometry; `width`/`height` scale
+the geometry to the size asked for (with both, each side independently; with one, the other keeps
+its proportion). A path or point set that draws nothing is refused instead of making an invisible
+0×0 layer, as is a size on an axis the geometry has none of (except 0, such as a horizontal line's
+height) and a size of 0 or less on an axis it has, which would flatten it.
+
 Vector edit mode is driven with `run_command` (or `pointer`/`key` for gestures):
 `vector.edit.begin {id? | ids?}` (default the selection; converts shapes to vectors; several layers
 are edited at once, the first active; `key` Enter with shapes selected does the same),
@@ -495,7 +643,8 @@ rotation?, color?, width?, height?, responsive?}` (`None`, `iPhone 16`, `iPhone
 `Black`, `White`, `Pink`, `Teal`, `Blue` for the iPhone 16 (an error lists them), `""` for the
 default; `width` / `height` set the custom size's screen, 1–10000 points, and pick `Custom size`,
 which is a bare screen without a body). On a device the presented frame is sized to the device's
-screen: what doesn't fit is clipped, or scrolls when the frame's `overflow` allows it, while `fixed`
+screen: a frame bigger than the screen scrolls through its whole size whatever its `overflow`, content
+past the frame's own edges scrolls only as its `overflow` allows (else it's clipped), and `fixed`
 layers stay on screen (pinned to the edges their constraints name). With `responsive: true` (saved
 in the file) the presented frame is instead resized to the device's screen, or without a device to
 the presenter's window at 100%, and its constraints and auto layout respond as when it is resized
@@ -631,7 +780,9 @@ most when it can't be reached).
 
 - `instance.swap {ids?, component}` shows another component in the instances (overrides on layers
   with matching names stay; property values with the same names too). Nested instances can be
-  swapped on their own (an override of the instance they're in).
+  swapped on their own (an override of the instance they're in); a swapped nested instance keeps
+  what its outer main overrode on matching layers as its own, so later edits of those in the main
+  don't reach it.
 - `instance.swapAt {component, x, y}` swaps the instance at a page point: of the instances under
   it (innermost first), the first showing a variant of the same component set, else the innermost
   (never one inside the dropped component); only text layers keep their overrides. The Assets
@@ -816,10 +967,13 @@ path?}` writes this file's collections (default: all but library copies) as a lo
 response (`format: "json"`, the default) or as CSS custom properties (`format: "css"`: the default
 mode on `:root`, each other mode on `[data-<collection>="<mode>"]`, aliases as `var(--name)`), and
 returns `{text}` (or writes `path` and returns `{path}`). `variable.import {variables}` (an object,
-JSON text or a path) reads one back: a collection joins this file's collection of the same name
+JSON text or a path; `variableCollections` and `variables` under `meta` or at the top level) reads
+one back: a collection joins this file's collection of the same name
 (values matched by mode name, new modes and variables added, a same-named variable of another type
 skipped with a warning; library copies and extended collections are never targets), others are
-added; aliases are checked for loops; it returns `{collections, variables, updated, warnings}`. The
+added; aliases are checked for loops; it returns `{collections, variables, updated, warnings}`,
+with a warning when the JSON holds no variables (`no variables found: expected meta.variables …`)
+or fewer than its collections list in `variableIds`. The
 Variables editor's Import… and Export… buttons do the same through file dialogs.
 
 Strokes take colour styles and variables like fills: `style.apply {style, target: "stroke"}` links
@@ -902,10 +1056,11 @@ branches). Driven with `run_command`:
   name, property, branch, main, deletedBy?}]}`. `layers` are the changed layers with their property
   changes formatted like Inspect (`fill #2563EB → #DC2626`); `document` lists styles, variables,
   comments and file settings. A conflict is the same property changed on both sides to different
-  values (key `<layer id>/<property>`, e.g. `4/fills`; fills, strokes and effects compare item by
-  item, so changing different items of one list on each side, or adding items at its end on one
-  side, merges without a conflict; a layer's parent and position are one
-  property, `parent`), a layer deleted on one side while the other edited it or what's inside it
+  values (key `<layer id>/<property>`, e.g. `4/fills`; fills, strokes, effects, layout grids,
+  export settings, guides, prototype interactions, annotations and Dev Mode resources compare item
+  by item, so changing different items of one list on each side, or adding items at its end on one
+  side, merges without a conflict; other lists, such as code links, compare whole; a layer's parent
+  and position are one property, `parent`), a layer deleted on one side while the other edited it or what's inside it
   (`<layer id>/layer`, with `deletedBy`), or a document-level entry or setting changed on both sides
   (`style/<id>`, `variable/<id>`, `comment/<id>`, `doc/<property>`…).
 - `branch.merge {id?, resolutions?}` merges the branch into the main file as one undo step,
@@ -1209,7 +1364,9 @@ permissions: without it nothing is downloaded); `plugin.directory.publish {path
   strings, any other `{…}` stays as written (`unknown` lists placeholder names that aren't
   properties). Then `inspect.code` on an instance or the component returns the import line and the
   snippet instead of generated code (`connected: true`), connected instances inside a generated
-  layer tree are their snippet, and `inspect.componentCode` returns `connected: {importPath, name,
+  layer tree (also in a component's definition, in the content an instance puts in its slots, and
+  the components a connected template's instance swaps place) are their snippet with their import
+  lines once each at the top of the code, per language, and `inspect.componentCode` returns `connected: {importPath, name,
   template, import, code}` with the snippet as `usage`. Example: template `<Button
   variant="primary" icon="{Has icon ? "cart" : "none"}">{label}</Button>` with import path
   `@acme/ui` gives `import { Button } from "@acme/ui";` then `<Button variant="primary" icon="none">{"Buy
@@ -1222,7 +1379,8 @@ permissions: without it nothing is downloaded); `plugin.directory.publish {path
   warning). `get_node` lists a component's links as `codeLinks`. In the app, the Inspect tab's
   Connect to code section edits them in the Code section's language, with a live preview and a
   Connected badge. An editor extension isn't needed: agents and editors read the same snippets
-  through this server. Plugins whose manifest asks only for `read` also run from the Inspect tab.
+  through this server. Plugins whose manifest asks only for `read` also run from the Inspect tab,
+  with their panels (`plugin.ui`); their callbacks can only read.
 - **Dev resources:** links for developers (docs, code, tickets) on any layer, each a URL and a
   name. `devResource.add {id?, url, name?}` → `{id, index}` (no name: the URL without its scheme,
   `www.` and a trailing slash; no page title is looked up), `devResource.edit {id?, index, url?,
@@ -1261,17 +1419,23 @@ permissions: without it nothing is downloaded); `plugin.directory.publish {path
   tab filters the callouts by category and edits the categories (colour, name, delete, add); each
   note has a category menu.
 - **Ready for dev:** frames at the top of a page or section, and sections, carry a handoff status
-  (`node.set {devStatus: none|readyForDev|completed}`). `inspect.readyForDev {status?:
-  readyForDev|completed|any, page?}` lists them across pages (or on one page) in page and layer
-  order: `{items: [{id, name, page, status}]}`. The Inspect tab sets the status of the selected
-  frames and, with nothing selected, lists them with a status filter (click one to go to it, or its
-  focus button to open it in the focus view).
+  (`node.set {devStatus: none|readyForDev|completed}`; other layers are refused a status).
+  `inspect.readyForDev {status?: readyForDev|changed|completed|any, page?}` lists them across pages
+  (or on one page) in page and layer order: `{items: [{id, name, page, status, changed}]}`
+  (`changed`: ready for dev and edited since). The Inspect tab sets the status of the selected
+  frames and, with nothing selected, lists them with a status filter (Ready for dev, Changed,
+  Completed, Any status; changed ones carry a Changed badge; click one to go to it, or its focus
+  button to open it in the focus view). In the app's Dev Mode the canvas only inspects: presses
+  select (and pan, and comment), never move, resize, draw or edit text and vectors, and the menus
+  and shortcuts refuse commands that edit the design (Dev Mode's own annotations, statuses, dev
+  resources, code connections and comments still work); choosing a drawing tool in the toolbar
+  goes back to the design. Commands sent over MCP or the control channel aren't affected.
 - **Compare changes:** when a layer marked Ready for dev first changes (it turns "Changed"), the
   file keeps a copy of it and everything in it as it was just before that edit (saved in the
   `.figcraft` file only while there is a change; resolving the change, marking it again, another
   status or deleting it drops the copy, so the next change compares with that state).
-  `dev.compare {id?, show?}` → `{id, name, changed, snapshot, added, removed, modified, truncated,
-  changes: [{id, name, type, change: added|removed|changed, depth, layers, properties?: [{section,
+  `dev.compare {id?, version?, show?}` → `{id, name, changed, snapshot, added, removed, modified,
+  truncated, version: {id, name, time} | null, changes: [{id, name, type, change: added|removed|changed, depth, layers, properties?: [{section,
   property, before, after, text}]}]}`: layers matched by id, added and removed ones listed as a
   whole (`layers` counts what's inside), changed ones with their properties formatted like Inspect
   (`width 120 → 136`, `fill #FF0000 → #E03030`, `text “Welcome” → “Hello”`, `parent Badge → Screen`,
@@ -1279,7 +1443,11 @@ permissions: without it nothing is downloaded); `plugin.directory.publish {path
   opacity, visibility, name), nested layers and instance contents included. `snapshot: false` means
   the frame changed before copies were kept (an older file). `show: true` opens the compare view in
   the app: before and now side by side (or overlaid with a slider), changed layers outlined (added
-  green, changed orange, removed red), the list of changes and Resolve change.
+  green, changed orange, removed red), the list of changes and Resolve change. With `version` (an id
+  from `version.list`) any top-level frame or section, ready for dev or not, is compared with that
+  saved version instead (a layer the version doesn't have was added as a whole); the compare view
+  picks it at the bottom (Compare with: When marked ready, or a version; a frame that isn't ready
+  for dev compares with the newest version), and `ui.set {devCompareVersion}` sets it.
 - **Focus view:** `dev.focus {id? | direction: next|previous}` → `{id, name, page, index, count}`
   shows one top-level frame or section alone on the canvas (fitted, selected, other layers neither
   drawn nor hit), switching page when needed; `direction` steps through the ready-for-dev frames
@@ -1353,6 +1521,27 @@ through the outlines of its layers.
   clears it; no `preset` reads it). The desktop app reads pressure from pen input on Windows; in the
   browser from stylus touch events that report a force; macOS and Linux tablets report none.
 
+### Selection colors
+
+`selection.colors {ids?}` returns `{colors: [{paint, style, variable, targets}]}` across the
+selection and its descendants, deduplicating overlapping roots. Only visible solid and gradient
+paints are listed; masks and boolean operands are omitted. Styles and variables distinguish
+otherwise equal paints. Each target is `{id, fills, index, range}`; `range` is null for a node
+paint or `[start, end]` in character offsets for an effective text-range fill.
+
+Pass the returned target list to:
+
+- `selection.setPaint {targets, paint}` to replace only those slots (same paint syntax as `fill.set`).
+- `selection.selectColor {targets}` to select their distinct owning layers, without a document undo step.
+- `selection.applyColorStyle {targets, style}` to apply a document paint style. As with `style.apply`,
+  this replaces the matching node's entire fill/stroke list and links the style. Text ranges copy
+  resolved paints and keep their typography, without a paint-style link.
+
+Keep the targets fixed throughout a live interaction. A color becoming equal to another color
+must not add slots to the gesture. Invalid or missing targets fail atomically. Direct paint edits
+detach bindings on changed paint values (opacity alone keeps the color binding); a text-range edit preserves the node bindings other
+characters still inherit. Each mutating command is one undo step (an interaction can group them).
+
 ### Paint, effect and layout grid lists
 
 A layer's fills, strokes, effects and layout grids are lists kept **bottom first**: index 0 paints
@@ -1519,6 +1708,18 @@ the instance's text layer id with `get_node`):
 {"jsonrpc":"2.0","id":7,"method":"tools/call","params":{"name":"type_text","arguments":{"id":7,"text":"Grace Hopper"}}}
 ```
 
+Smart-selection spacing (movable siblings in rows, columns or aligned grids):
+
+```json
+{"jsonrpc":"2.0","id":"spacing","method":"tools/call","params":{"name":"run_command","arguments":{"command":"arrange.spacing","params":{"ids":[3,4,5],"horizontal":24}}}}
+```
+
+`horizontal` and `vertical` are optional page-unit gaps (at least one is required, magnitude at
+most 1,000,000). The first column/row stays fixed; subsequent tracks move without changing sizes,
+parents or offsets inside each track. Nonuniform gaps become uniform. Normal auto-layout flow
+children, locked/hidden layers and instance internals are excluded. Interactive callers may pass
+`fromGesture: true` inside an interaction to keep using its original tracks during a scrub.
+
 Align and distribute as one undo step:
 
 ```json
@@ -1549,7 +1750,7 @@ other key next to `$step` fails the whole batch, which is rolled back. Only an o
 value too) is read as a reference. A step that is itself a `command.batch` is passed on as written,
 so the references in its steps are to its own steps, not the outer batch's.
 
-The end-to-end tests in `crates/mcp/tests/agent_tasks.rs` are worked examples of realistic tasks
+The end-to-end tests in `crates/mcp/tests/it/agent_tasks.rs` are worked examples of realistic tasks
 (auto layout, a card built in one batch with step references, components and overrides, gradients
 and shadows, paint styles, Light/Dark variables, align/distribute/group, boolean subtract + flatten,
 export, undo/redo, drawing with tools).
diff --git a/docs/parity-checklist.md b/docs/parity-checklist.md
index bdb30e880..775a4fcb4 100644
--- a/docs/parity-checklist.md
+++ b/docs/parity-checklist.md
@@ -1,10 +1,10 @@
 # Parity checklist
 
-> **Generated:** 2026-10-13 by `cargo xtask parity`. Do not edit by hand.
+> **Generated:** 2026-10-17 by `cargo xtask parity`. Do not edit by hand.
 
-FigCraft commands registered for the incumbent's main menu and toolbar (547 commands in the engine).
+FigCraft commands registered for the incumbent's main menu and toolbar (561 commands in the engine).
 
-**211 / 211 menu items (100.0%)**
+**212 / 212 menu items (100.0%)**
 
 Every catalog item has a command.
 
diff --git a/docs/plugins.md b/docs/plugins.md
index 6f23e6ecb..9b1a8f4ef 100644
--- a/docs/plugins.md
+++ b/docs/plugins.md
@@ -237,7 +237,11 @@ Whatever its manifest says, FigCraft refuses these calls (the plugin gets the re
 it can handle):
 
 - files and the app: `file.*`, `app.*`, `pref.*`, `help.*`, `library.add`, `libraries.*`,
-  `image.place` with a `path` (pass the image as base64 `data` instead), `view.theme*`;
+  `image.place` with a `path` (pass the image as base64 `data` instead), `variable.export`,
+  `codeConnect.export` and `component.playground` with a `path` (leave it out to get the result
+  back), `codeConnect.import` with a `path` and `variable.import` with a file path instead of JSON,
+  `window.*` (new windows open files), `view.theme*`;
+- live sessions and online files: `collab.*`;
 - other documents and the version history: `doc.*` and `version.*` (except `doc.list` and
   `version.list`);
 - the undo history and nesting: `edit.undo`, `edit.redo`, `edit.repeat`, `command.batch` (a run is
@@ -456,4 +460,6 @@ import what you need from `figcraft`.
   vectors, components or variables).
 - Panels: no images, sliders or free layout inside a panel.
 - Data in the document: plugins keep data on layers (pages included) with `node.set {props:
-  {pluginData: {key: value}}}`; there is no separate per-document store.
+  {pluginData: {key: value}}}` (a `null` value removes a key) and read it back with `node.get`, which
+  reports `pluginData: {key: value}` (values as strings) when a layer has any; there is no separate
+  per-document store.
diff --git a/docs/prototyping-parity.md b/docs/prototyping-parity.md
index b92204896..d8173a118 100644
--- a/docs/prototyping-parity.md
+++ b/docs/prototyping-parity.md
@@ -1,6 +1,6 @@
 # Prototyping parity
 
-> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-13 · **Change:** minor (core editor leftovers: delays on mouse triggers and manual overlay offsets; controller buttons on key/gamepad triggers, widgets that react in prototypes, `proto.evaluate` and the mode lookup rules pinned) · **Target:** Figma Design (desktop app 126.10.7)
+> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-17 · **Change:** minor (Change to, set variable and set variable mode lay out what they change in the player, as the canvas does; presentation tabs, one per page of a file; a Present tab with device and scale controls (#537); core editor leftovers: delays on mouse triggers and manual overlay offsets; controller buttons on key/gamepad triggers, widgets that react in prototypes, `proto.evaluate` and the mode lookup rules pinned) · **Target:** Figma Design (desktop app 126.10.7)
 
 **Breadth ~92%, ready ~74% (estimated).** Every Figma trigger except media, every action except
 media control, every transition and easing exist; key/gamepad triggers take controller buttons,
@@ -54,8 +54,10 @@ case pins the current behaviour).
 | Open link | pass | always a new tab or browser window (opening in place would leave the prototype) |
 | Change to: another variant of the instance, in place, with the interaction's animation | pass | `interactive_components_change_in_place` |
 | Interactive components: every instance plays the interactions of the variant it shows; an interaction on the instance with the same trigger wins | **fixed** | instances played only interactions copied onto them when they were placed: an instance placed before its main got interactions did nothing, and one placed after kept the first variant's interactions after changing (a toggle went on but never off). New instances no longer copy them, and copies in older files give way to the variant shown; `instances_play_their_variants_interactions` |
+| Presentation tabs: one per page of a file, named "file - page" (renames follow). Play on a page that has a tab shows it as it was (from another start frame it starts again). Tabs keep their own copy of the prototype and play on after their file closes; a saved file opened again gets its tabs back. A tab never changes a file that isn't in front. Its X or Escape ends it and goes back to its file, or Home | **fixed** | one "Present" tab: a second presentation replaced the first, Play restarted it, and closing the file ended it; `present_tab_tests` |
 | Change to on a layer inside a nested instance changes the instance whose variant set holds the destination | **fixed** | the innermost instance (an icon inside a button) was changed instead |
 | Set variable, set variable mode, conditional | pass | `proto_run_tests`, `proto_conditional_tests`, `present_variables_tests` |
+| Change to, set variable and set variable mode lay out what they change as the canvas does: text sizes to what it shows, hugging frames around it | **fixed** | the player didn't lay out after them: an instance with a longer label changed to the main's width, and a bound text kept its old size; `change_to_lays_out_the_instance_around_its_own_content`, `set_variable_and_set_mode_lay_out_the_text_they_change` |
 | Expressions: a variable reads the mode where the interaction runs (a frame that chose a mode, else the page's); `name[Mode]` reads a given mode whatever is chosen; operators on numbers, text (`+` joins), booleans and comparisons | pass | `mode_lookups_read_a_given_mode_or_the_layers_current_one`, `proto_expr_mode_tests` |
 | Set variable mode, then a conditional or set variable later in the same interaction: they see the new mode | pass | `set_variable_mode_changes_what_later_expressions_read` |
 | A set variable writes every mode of the variable, so a lookup of any mode reads the new value; a frame inside the screen that chose a mode keeps it after set variable mode | silent | pinned as stated |
@@ -86,7 +88,7 @@ case pins the current behaviour).
 | Widgets react to clicks in a presented prototype | done | clicks only, like on the canvas |
 | Interactive components: instances play their variant's interactions, overridden per trigger | done | |
 | Drag-driven animations that follow the pointer, in their direction | done | |
-| Presenter: device frames and colours, rotation, custom sizes, fit/fill/100%, responsive frames | done | device bodies drawn in code |
+| Presenter: device frames and colours, rotation, custom sizes, fit/fill/100%, responsive frames | done | device bodies drawn in code. Presenting opens its own Present tab, which keeps its screen and history while you go back to the design, with a thumbnail of the current frame, previous / next, device presets and scale choices; the frame is laid out again for the device's screen on the prototype's copy (constraints and auto layout; the file is untouched); on phones and tablets overflowing content drags while the device stays put: a top-level frame bigger than the screen always scrolls (as in Figma, with no overflow setting), content past the frame's own edges as its overflow setting allows ("No scrolling" clips it); closing the window asks about unsaved changes above the presentation (#537). Devices not compared with Figma's |
 | Hotspot hints, inspect panel in the presenter, comments in the presenter | done | |
 | Preview pane following edits live | done | |
 | Edit interactions on several layers at once | done | |
@@ -100,6 +102,10 @@ case pins the current behaviour).
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-23 | patch | A top-level frame taller (or wider) than the device's screen scrolls with no overflow setting, as Figma's documentation says; before, "No scrolling" frames such as the landing page template's Phone frame only clipped. Content past a frame's own edges still scrolls only as its overflow allows. Checked in the app on macOS. Numbers unchanged |
+| 2026-10-22 | minor | Change to, set variable and set variable mode lay out what they change in the player as the canvas does: text sizes to what it shows and hugging frames follow (an instance with a longer label changed to the main's width; a bound text kept its old size). Two player tests. Breadth and ready unchanged. |
+| 2026-10-17 | minor | Presentation tabs: one per page of a file instead of a single "Present" tab, named "file - page" (renames follow); Play shows a page's tab as it was; tabs outlive their file and come back when a saved file opens again. Numbers unchanged. |
+| 2026-10-17 | minor | Community batch #753: a Present tab (#537): playback in its own tab that keeps its screen and history, a current-frame thumbnail, previous / next, device presets and scale; the frame reflows to the device's screen on the prototype's copy; phone and tablet content drags inside a fixed device as its overflow allows ("No scrolling" frames clip; iPad mini, MacBook Air and Desktop keep their bodies); the unsaved-changes question shows above the presentation. Checked in the app on Windows. Percentages and hours unchanged |
 | 2026-10-13 | minor | Prototyping, delays on mouse triggers and manual overlay offsets (M5): mouse enter, leave, down and up wait `delayMs` before their actions run (once while waiting; dropped when the screen or overlay they were on goes away; a pointer that leaves early doesn't cancel, the documentation is silent), and a manual overlay sits at `offset: [x, y]` from the top-left of the layer that opens it (without one, right below it, as before). Delay and X/Y fields in the interaction editor, the player on its own clock, REST import (`delay`, `overlayRelativePosition`), `.fig` import and export (the export's field for mouse delays is unchecked against other software). Numbers unchanged. |
 | 2026-10-12 | minor | Controller buttons on key/gamepad triggers (Controller menu, player polling on Windows and in the browser, REST import instead of skipping, control channel injection), widgets reacting to clicks in presented prototypes on the prototype's own copy, `proto.evaluate`; the mode lookup and set-variable-mode rules written as cases (they already held). Breadth 90% → 92%, ready unchanged at 74% (controllers on Windows and the browser only; no real prototype QA yet), 3–6 h → 2–5 h |
 | 2026-10-11 | minor | Behaviour suite from the public documentation (7 model tests, 12 player tests with 21 gestures) and its fixes: on drag follows its animation's direction and the pointer, key combinations, overlay timers from when they open, interactive components play their variant's interactions and change the right instance, physical springs that play until they settle, smart animate overshoots with the easing, fixed layers above scrolling content; added scroll to offsets. Breadth 88% → 90%, ready 70% → 74%, 5–9 h → 3–6 h |
diff --git a/docs/releasing.md b/docs/releasing.md
index 7e9220ff0..07492f6cd 100644
--- a/docs/releasing.md
+++ b/docs/releasing.md
@@ -95,13 +95,17 @@ examples from `packaging/server/` (systemd unit, Caddyfile, nginx; the Dockerfil
 the sources). Linux only for now; elsewhere operators build it with
 `cargo build --release -p figcraft-server`.
 
-**Fonts.** Every build job checks out [craft-fonts](https://github.com/storytold/craft-fonts) at
-`CRAFT_FONTS_REF` (top of `release.yml`) and builds with `CRAFT_FONTS_DIR` and
-`CRAFT_FONTS_REQUIRED=1`, so releases embed its fonts and fail rather than ship without them.
+**Fonts.** Every build job, the web one included (`web-craft-fonts`), checks out
+[craft-fonts](https://github.com/storytold/craft-fonts) at `craft-fonts-ref` (in `release.yml`) and
+builds with `CRAFT_FONTS_DIR` and `CRAFT_FONTS_REQUIRED=1`, so releases embed its fonts and fail
+rather than ship without them. The browser has no system fonts, so a web build without craft-fonts
+can't draw text.
 `crates/text/build.rs` reads both `fonts/manifest.txt` and `fonts/latin-manifest.txt`, so the pin
 must be a commit that has the Latin manifest (today `4391305`, on craft-fonts'
-`pr/latin-presentation-fonts` branch; re-pin to `main` once that lands). The web build embeds
-only Inter. Packages carry each embedded font's licence as `OFL-<family>.txt`
+`pr/latin-presentation-fonts` branch; re-pin to `main` once that lands). That commit has no
+Noto Sans Georgian (craft-fonts' main has it but no Latin manifest), so desktop Georgian uses an
+installed font; re-pin when one commit has both (craft-fonts#42). The web build embeds only Inter,
+Noto Sans Georgian and the Archivo SemiBold wordmark, when the pin has them. Packages carry each embedded font's licence as `OFL-<family>.txt`
 (`copy_font_licences` in `packaging/env.sh`; `Contents/Resources/Licenses` in the macOS app).
 
 ### macOS
diff --git a/docs/roadmap.md b/docs/roadmap.md
index 12f2a5fbf..8e093ac93 100644
--- a/docs/roadmap.md
+++ b/docs/roadmap.md
@@ -1,6 +1,6 @@
 # FigCraft roadmap: milestones and what's next
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-14 · **Change:** minor (recent files as cards with thumbnails on the home screen; community fixes: lost images reported on loading, SVG import budgets, Leptos code, full screen, server snapshots, owner-only preferences, ruzstd 0.9.1, layer cycle repair, batch rollback, Direct3D 12 on Windows, plugin metering; vector edit mode regions: hover hatch, selection and drag; repeat command recursion fix; the Layout panel's constrain-proportions link scales the other side, #220; Simplified Chinese draft catalog; Latin American Spanish overlay; prototyping tail: gamepad triggers, widgets in prototypes, mode lookups; plugin directory on figcraft-server; Japanese and Korean draft catalogs and CJK UI fonts; plugin widgets and the plugin panel tail; French, German and Brazilian Portuguese draft catalogs; `.fig` import, best effort; Display P3: gamut warning and soft-proof (true P3 blocked upstream); several windows; localization layer with a draft Spanish catalog; hosting figcraft-server: wss in the desktop app, server releases, deployment guide; plugin panels and settings; canvas fixes: boolean hit testing on the result, group drags, frame outlines and slices; code connect; stretch and scatter brushes, pen pressure; text on a path and pattern fills; team libraries on the server and swap library; branches: create, update from main, review and merge; animated GIF fills and TIFF images; Open recent, outlines for the selection and mask outlines: menu breadth 100%; extended collections, variables import/export, gradient stop and variant bindings; feature breadth ~79%) · **Target:** Figma Design (desktop app 126.10.7)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-24 · **Change:** minor (M12 Boards; community fixes in #507, #510, #529 and #530: auto-save, a text box by dragging, batch step references, removing someone from a live session, Russian and Turkish catalogs reviewed, Czech and Indonesian drafts, the Japanese draft completed, zoom previews, the web clipboard, Alt-drag snapping and Cmd+D repeat, recovery copies, crash and rollback fixes, colour emoji, `.fig` import fixes; earlier changes are in the revision history below) · **Target:** Figma Design (desktop app 126.10.7)
 
 Forward-looking plan. Where FigCraft stands today: [`ROADMAP.md`](../ROADMAP.md) and
 [`target-app-parity.md`](target-app-parity.md); the full ranked list: [`gaps.md`](gaps.md). Hours
@@ -16,8 +16,9 @@ are one Opus 5.5 agent; most milestones split across 4–6 agents on disjoint cr
 3. **Tool-by-tool interaction pass** against the running Figma ([`ui-parity.md`](ui-parity.md)):
    40–60 h, parallel by tool.
 4. **Languages** on the landed localization layer: native reviews of the es, fr, de, pt-BR, ja,
-   ko and zh-Hans drafts and the es-419 overlay (people), then the other key languages: 3–7 h per language
-   plus native review.
+   ko, zh-Hans, id and cs drafts and the es-419 overlay (people; Russian and Turkish are reviewed),
+   the entries added since each catalog was written, then the other key languages (Hindi,
+   Vietnamese, Arabic): 3–7 h per language plus native review.
 5. **Multiplayer M9**: accounts and teams on top of the live sessions and the standalone server (the WebSocket transport, hosting from the app, invite links that open the app, document sync, live cursors, selections, text carets, avatars and follow, per-user undo, reconnect with offline edits, collision-free ids for styles, variables, collections and comments, joining from the browser, and `figcraft-server` with persistence, publishing from the app and share links to edit or view landed), per [`collab-protocol.md`](collab-protocol.md) and [`server.md`](server.md): 45–90 h.
 
 ## Alpha gate
@@ -57,9 +58,10 @@ blockers.
 | M7 Release & fidelity (signed builds, look & feel, shortcuts) | builds done; fidelity pass started | tool-by-tool pass | 40–60 |
 | M8 Hardening & performance (bench, retained canvas, accessibility, idle) | ~60% | real-file corpus, platform QA, GPU canvas, screen readers | 60–110 |
 | M9 Real-time collaboration | core done (#103: ids, change sets, server ordering, convergence); live sessions (WebSocket transport with limits and reconnect, hosting from the app, invite links, document sync between apps, cursors, selections, avatars, follow, `collab.*` commands); per-user undo, rejection handling, offline queue and resuming after a reconnect; styles, variables, collections, modes and comments created in a session get ids from their creator's space; others' text carets and selections on the canvas; the browser client (joins desktop-hosted sessions); `figcraft://` links open the app and join (Windows registers per user; macOS and Linux packages declare the scheme); the standalone `figcraft-server` (persistence with compaction, restarts that lose nothing confirmed, publishing from the app, share links to edit or view, revocable); team libraries kept on the server and enabled by a share link, with usage counts, and swapping a library; `wss://` from the desktop app, server releases and a deployment guide | accounts, teams | 45–90 |
-| M10 Localization (new) | not started | layer + 11 languages | 60–100 |
+| M10 Localization | ~39%: the layer, English, Russian and Turkish reviewed by native speakers; Spanish (with a Latin American overlay), French, German, Brazilian Portuguese, Japanese, Korean, Simplified Chinese, Indonesian and Czech drafts | native reviews, Hindi, Vietnamese, Arabic (with mirrored panels), engine messages and number formatting ([localization-parity](localization-parity.md)) | 29–51 |
 | M11 Plugins | runtime, API, menu, manager and SDK done (#101); plugin panels and settings (ABI v2); widgets (API 3), panels side by side, colour picker on plugin fields; a plugin directory on `figcraft-server` (publish, browse, install, update) | a public catalogue, publisher accounts and signatures, the directory in the browser, richer widget events; Figma plugin compatibility is an owner decision | 8–26 |
-| M12 AI features (new, owner decision) | not started | local models | 30–60 |
+| M12 Boards (new) | first slice landed (2026-10-24): board files, sticky notes, shapes with text, connectors that follow, marker, highlighter, eraser, stamps, board toolbar and contextual bar, live sessions | timer, voting, widgets, templates, tables, mind maps ([boards-parity](boards-parity.md)) | 30–60 |
+| M13 AI features (new, owner decision) | not started | local models | 30–60 |
 
 ## Next, after the current focus
 
@@ -73,6 +75,59 @@ blockers.
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-24 | minor | Boards (M12): a file kind of its own (`file.newBoard`, saved in `.figcraft`, carried to live-session joiners) with sticky notes, shapes with text, connectors that re-route when what they join moves (an engine recompute, the same for local edits, undo and others' edits), marker, highlighter and eraser, stamps with the placer's name, a board toolbar and a contextual bar; prototyping and Dev Mode refuse on boards; design files and boards have their own marks on tabs and file rows. Milestone M12 Boards added; AI features move to M13 |
+| 2026-10-15 | minor | Auto-save (#305, #296): Preferences ▸ Save files automatically (`pref.autoSave`, off by default; desktop only, the browser has no files to save to) saves each open file that has a path 3 s after its last change, so steady editing doesn't save every few seconds, and never during a gesture, a live text preview or while a version is shown. The file is encoded on a thread of its own and written as of that moment (edits made meanwhile stay unsaved); a failed save says why in a toast and is tried again a minute later, and version history checkpoints keep coming with it on. Numbers unchanged |
+| 2026-10-15 | minor | A text box by dragging (#363, #360): a drag with the Text tool makes a fixed-size text box the size of the drag (at least one line tall); a click, or a drag shorter than the drag threshold, still makes auto-width text. Numbers unchanged |
+| 2026-10-15 | minor | Batch step references (#400): inside `command.batch` (MCP `batch`), `{"$step": n}` anywhere in a step's params stands for the `id` step n returned (`{"$step": n, "field": …}` for another field; `$step` is a reserved key), so a frame with its children takes one batch and one undo step; a malformed reference fails the batch, which rolls back, and a nested batch keeps references to its own steps. Numbers unchanged |
+| 2026-10-15 | minor | Removing someone from a live session (#338): right-click a person's avatar ▸ Remove *name* from session, or `collab.removePerson {client}`, when you host the session or own the file on a server; the session ends for them (they keep their copy), the code or link they hold no longer gets them back in while it runs, and everyone else stays. Numbers unchanged |
+| 2026-10-15 | minor | Pages list (#272, #258): a long pages list scrolls in its own area, so the layers below stay in view; page and layer drops count only inside the list's visible rows. Numbers unchanged |
+| 2026-10-15 | minor | Variables export in the browser (#368): Export… ▸ Variables JSON / CSS custom properties did nothing in the web build and now arrives as a download; importing there still needs a file picker. Numbers unchanged |
+| 2026-10-15 | minor | Font picker keys (#352, #345): Up and Down step through the font families from the current one, keeping the highlight in view and previewing it on the canvas; Enter applies it, Escape leaves the text as it was. Numbers unchanged |
+| 2026-10-15 | minor | Leaving Design ends the pen path (#308, #307): switching to Prototype or Inspect while the Pen draws ends the path and goes back to Move (pressing Design again keeps drawing), and a click on the toolbar no longer reaches the canvas under it. Numbers unchanged |
+| 2026-10-15 | minor | Vector edit mode keeps the canvas still (#322): the edit mode hints in the Design panel wrap, so entering edit mode and picking a region no longer shift the canvas by about 25 points in the middle of the click (which dragged the region picked). Numbers unchanged |
+| 2026-10-15 | minor | Drop shadows under a background blur (#317, #255): a layer with both casts its shadows from what it paints (a translucent fill casts a lighter shadow than an opaque one) and reads the backdrop only after drawing them, so a shadow shown behind transparent areas is seen through the blur. Numbers unchanged |
+| 2026-10-15 | minor | When the window can't open (#306, #261): Windows release builds have no console, so a graphics failure at start quit without a word; the error is now logged and shown in a message box in the interface language, with what to try (unset `WGPU_BACKEND`, update the driver, OpenGL) and where to report it, skipped with `--control`. Numbers unchanged |
+| 2026-10-15 | minor | Crashes on Windows (#271, #314, #337; #224 and two more): a text field focused before it was drawn aborted the screen-reader layer; double-clicking a page, creating a variable collection and renaming a style folder no longer close the app. Numbers unchanged |
+| 2026-10-15 | minor | Deeply nested layers (#330, #210): one depth guard (256) on the three recursive layout paths, so a deep file can't run the layout out of stack. Numbers unchanged |
+| 2026-10-15 | minor | Image memory budgets (#326; #203, #189): decoded images and a file's images have budgets; the decode cache evicts its least recently used entries. Numbers unchanged |
+| 2026-10-15 | minor | macOS file dialogs (#253, #250) no longer re-enter the event loop; a dialog's result goes to the file and window it was opened for, and dialogs are parented to the main window. Numbers unchanged |
+| 2026-10-15 | minor | Recovery copies (#297, #303, #331, #336; #202, #185, #187): a copy counts only after its write succeeds and a failed one is retried; saves and closes wait for the write in flight; copies keep version history and branches; a recovered copy stays until this run has its own. Numbers unchanged |
+| 2026-10-15 | minor | Text edits (#280, #278) no longer roll back earlier changes; a drag released off the canvas ends at the pointer's last canvas position. Numbers unchanged |
+| 2026-10-15 | minor | Rollback (#282, #301; #196): a failed command rolls back during a drag or other gesture too; a failed batch keeps the redo steps. Numbers unchanged |
+| 2026-10-15 | minor | Atomic save and export (#284): staging files are uniquely named and created exclusively, so a file or link already at the old fixed staging name is never written through, and two writers of one file no longer share one. Numbers unchanged |
+| 2026-10-15 | minor | Alt-drag copies (#283) snap to their original, and Duplicate (Cmd+D) then repeats the last copy's offset. Numbers unchanged |
+| 2026-10-15 | minor | The pen (#277) shows its Bezier handles while a point is dragged out. Numbers unchanged |
+| 2026-10-15 | minor | Corner handles (#293, #292): a press on a corner handle resizes instead of picking the corner-radius handle. Numbers unchanged |
+| 2026-10-15 | minor | New text (#372, #362) takes a readable colour from the frame it is drawn in, not only the page (text drawn in a white frame on a dark page was white). Numbers unchanged |
+| 2026-10-15 | minor | Outline stroke (#386) works on every selected layer. Numbers unchanged |
+| 2026-10-15 | minor | Send to back (#444) counts per parent when the selection spans frames. Numbers unchanged |
+| 2026-10-15 | minor | Align buttons (#276) are off when the selection has nothing to align to. Numbers unchanged |
+| 2026-10-15 | minor | Gradient type icons (#275) show their gradient. Numbers unchanged |
+| 2026-10-15 | minor | Corner resize cursors (#388) stay diagonal at any proportions; the text selection highlight (#390) stays inside the box on the last line. Numbers unchanged |
+| 2026-10-15 | minor | New pages (#311, #295) take the current page's background; the theme still decides a new file's page. Numbers unchanged |
+| 2026-10-15 | minor | A slice's export preview (#265) shows the content under it. Numbers unchanged |
+| 2026-10-15 | minor | SVG export (#327, #325) keeps a nested frame's fill and stroke inside its parent's clip. Numbers unchanged |
+| 2026-10-15 | minor | Home screen (#318, #324): recent files notice files deleted while it is open; a long path no longer draws over the file name. Numbers unchanged |
+| 2026-10-15 | minor | System theme on first run (#262): the first frame follows the system theme, and going back to System from a manual theme works. Numbers unchanged |
+| 2026-10-15 | minor | Web clipboard (#375): copy and paste in the browser go through the system clipboard, so a paste after a copy brings the copied layers instead of whatever text the clipboard held. Numbers unchanged |
+| 2026-10-15 | minor | Zoom previews (#312): when renders from scratch are slow, a new zoom first shows the whole view coarsely instead of the page colour, then the refined image; images of another file or page never show. Numbers unchanged |
+| 2026-10-15 | minor | Hidden windows (#313, #332; #269): a minimised or covered window answers control and MCP requests (commands, inspection, `ui.render`) at once, each window on its own; screenshots and input still wait for it to be on screen. Numbers unchanged |
+| 2026-10-15 | minor | Server (#340, #302): a compaction cut short closes the file instead of confirming lost edits (#183); each team library version is kept in its own file (#206). Numbers unchanged |
+| 2026-10-15 | minor | Counters (#343, #344, #353; #309): collab sequence numbers, layer name counters and opacity digits can't overflow. Numbers unchanged |
+| 2026-10-15 | minor | Commands refuse bad indexes and ids (#475, #384, #310): `page.select` and `doc.switch`, `effect.set` and `export.update` / `export.remove`, `page.move` with a non-page id. Numbers unchanged |
+| 2026-10-15 | minor | Find and replace (#358, #361) changes every occurrence, case-insensitively, also when the replacement contains the search text. Numbers unchanged |
+| 2026-10-15 | minor | The gradient shorthand (#254, #252) is read by the engine, so the CLI, control channel and MCP share it. Numbers unchanged |
+| 2026-10-15 | minor | .fig import (#279, #281): resized instances lay out their layers by their constraints (#266); explicit variable modes whose collection is named by its asset key, as library collections are, come across (#267). Numbers unchanged |
+| 2026-10-15 | minor | Colour emoji (#300, #268) draw from their own colour tables (sbix and CBDT/EBDT bitmap strikes, COLR v0 layers), a colour face tried first; COLR v1 still draws outlines. Numbers unchanged |
+| 2026-10-15 | minor | macOS (#290, #289): `.figcraft` files open from Finder, Open With and the Dock. Numbers unchanged |
+| 2026-10-15 | minor | Windows (#294, #291): the first preferred language alone picks the UI language. Numbers unchanged |
+| 2026-10-15 | minor | Unix font discovery (#474) follows `XDG_DATA_HOME`. Numbers unchanged |
+| 2026-10-15 | minor | Linux packaging (#346, #328): the window id matches the desktop entry (FreeBSD keeps its class); the RPM requires glibc 2.35. Numbers unchanged |
+| 2026-10-15 | minor | Tests (#472, #471, #339): the rename shortcut test, the hanging punctuation test and the font-scanning tests no longer depend on the platform, font or test order. Numbers unchanged |
+| 2026-10-15 | minor | Languages (#257, #263, #469, #477, #288): Russian (with one/few/many plural forms) and Turkish catalogs, reviewed by native speakers; Czech and Indonesian drafts; the Japanese draft completed. 2,177 entries now (1,587 UI strings, 559 command labels, 31 menu wordings); strings added since a catalog was written read English there. Localization 39% and 29–51 h unchanged at this rounding (Indonesian is now a draft, while the five older drafts lack 88 newer entries) |
+| 2026-10-17 | minor | Community batch #753 (10 PRs): Selection colors for mixed selections (#403); smart-selection spacing fields and canvas handles (#402); a Present tab with device and scale controls (#537); adding auto layout to an empty frame keeps its size (#369); `node.set` applies auto layout keys to frames only and warns about font styles a family lacks (#603); canvas images on whole device pixels (#359); Adwaita window controls on Wayland without server decorations (#592, not run on GNOME or KDE by the maintainers); the keyboard shortcuts panel closes on the home screen (#548); macOS paste modifiers in tests (#750); credits column tests (#347). Numbers unchanged. |
+| 2026-10-17 | minor | Community fixes from #524 up (batches #727, #728, #733, #735, #736 and #729; 55 PRs) and a crash guard. `.fig` import: explicit instance identity, overrides by key, text style precedence, grid track sizes, slot content, connector labels, skip ink, paragraph options and hanging lists, list start numbers, vertical trim, per-point stroke joins, text on a path, image adjustments and embedded images; large files open within budgets from the file's own size; an import report after opening; imported bytes stay out of the command journal. Files and paste: save a copy as `.fig`; Cmd/Ctrl+V pastes images copied in other apps and layers copied from another design app (`edit.pasteDesignLayers`); paste over and paste properties; clipboard reads on Linux and the BSDs time out after 2 s. Editor: live font preview on hover; Shift+I and Resources open Assets; Shift-drag moves the selection; thin strokes take a nearby double-click; dropped points merge; Flatten keeps open paths; the Actions palette gets tabs, ranked search, a keyboard highlight and recents; the colour picker opens on a new fill or stroke; text strokes follow their alignment; selection highlights after line breaks; a draggable pages/layers divider; variant properties reorder by drag; submenus keep their hover with a safe triangle; menu actions that need a value ask for it; File ▸ Rename edits the name in place. Engine: bad paint indexes, non-finite geometry and pages in copy/cut are refused; a param naming a layer says so when it isn't one; a CLI script is one undo step and resolves `$step`. Server and collaboration: message limits follow `max_file_mb` (client capped at 1 GiB); a damaged generation field no longer drops flushed edits; the web build joins a session from a `#join=` link. Also Swedish command labels, Nix CI through the shared workflow, paint bounds once per render, and a guard that turns a panic inside the boolean-op library into bad input (the stroke draws unclipped). Numbers unchanged. |
+| 2026-10-16 | minor | Community fixes from #478 up (batches #591, #598, #602; 69 PRs) and a control-channel fix: a line that isn't JSON now ends a `--control` connection, so a web page can't drive the app through a browser request (#589). Highlights: page copies keep navigation, flows, prototype settings and guides; Find and Replace keeps line endings and case-insensitive matches; text hyperlinks survive import and export; recent colours record only what was picked; MCP screenshots respect `maxSize`; Swedish catalog (UI strings), Czech plurals; bounded canvas overscan while panning; Korean fallback at the run's weight; many vector-edit, guide, page and .fig round-trip fixes. Numbers unchanged |
 | 2026-10-14 | minor | M7: the Small caps button in Type settings showed a box where the UI font has no small-capital `ɢ` (builds without Inter use egui's fonts); its sample is now a capital and a smaller capital, drawn from ordinary letters every UI font has. Numbers unchanged |
 | 2026-10-14 | minor | M7: Home screen recent files as cards: each card shows the picture its file carries on its first page's colour, the file's icon, name and "Edited ... ago"; sort by name, creation or last change either way; a table view; a click selects, a double-click or Enter opens, arrow keys move; Open, Show in folder and Remove from recents on right-click. Numbers unchanged. |
 | 2026-10-14 | minor | Lost images reported on loading (#207): a `.figcraft` file whose image member is damaged, too large or missing no longer loads in silence; each lost image (up to 20, then a count) is listed in `repairs` on `file.open` with its hash and the reason, and the app shows it as a toast. Saving still writes the file without the lost images. Numbers unchanged |
diff --git a/docs/server.md b/docs/server.md
index f2e4820ca..87e68b3d9 100644
--- a/docs/server.md
+++ b/docs/server.md
@@ -282,7 +282,7 @@ are errors):
 | `data` | `figcraft-data` | The data directory |
 | `public_url` | (the listen address) | How links name the server, when people reach it another way (a reverse proxy: `wss://figcraft.example.com/`) |
 | `max_files` | 1000 | Most files kept |
-| `max_file_mb` | 64 (16 when open) | Largest file (its snapshot), in MiB; a welcome carries the whole file, and messages are at most 64 MiB |
+| `max_file_mb` | 64 (16 when open) | Largest file (its snapshot), in MiB; a welcome carries the whole file, so messages may be as large as a file and 1 MiB (at least 64 MiB on a private server). The app opens files of up to 1023 MiB; above 64 with `open_publish` the server warns |
 | `max_links` | 100 | Most share links per file |
 | `max_connections` | 512 | Most open connections |
 | `max_people` | 256 | Most people in one file at once |
@@ -337,8 +337,9 @@ the address it came from and when it was last opened (for expiry).
   before the server tells anyone about the change.
 - **Compaction** writes the file's state as the next snapshot and starts an empty log, after
   `compact_after` entries or `compact_mb` of log, when the last person leaves, and when the server
-  stops. A log left over from a compaction cut short is recognised and ignored (the snapshot holds
-  it all).
+  stops. A log left over from a compaction cut short is replayed over the snapshot, which already
+  holds it all, so nothing changes. If a damaged generation field made a current log look like such
+  a leftover, its edits the snapshot lacks are recovered the same way and the damage is reported.
 - **Damage is skipped and reported, never deleted.** At startup a folder whose description, links
   or snapshot can't be read is left out and logged; a log that ends in a cut-short or damaged
   record loses only that end (logged when the file opens). Leftover temporary files are removed.
@@ -489,7 +490,7 @@ are larger.
 
 | Resource | Limit |
 |---|---|
-| Message size | A file's size and 1 MiB (`max_file_mb`, 16 by default when open, or `max_plugin_mb` if larger): checked as the message is read, before anything is decoded; 64 KiB on a connection that only browses plugins (a client sending more is disconnected with the limit as the reason; the app keeps its own copy). The core's 64 MiB otherwise |
+| Message size | A file's size and 1 MiB (`max_file_mb`, 16 by default when open, or `max_plugin_mb` if larger): checked as the message is read, before anything is decoded; 64 KiB on a connection that only browses plugins (a client sending more is disconnected with the limit as the reason; the app keeps its own copy). On a private server, the larger of that and the core's 64 MiB |
 | A file as it grows | Every batch is checked first (*always*): past `max_file_mb`, past its publisher's `max_mb_per_ip` or past `max_total_mb`, it is refused with the reason and the app rolls it back. A long log is compacted to make room at most once a minute per file (a compaction rewrites the whole file). A file's snapshot also holds the recent batches kept for reconnecting clients, at most a quarter of `max_file_mb` |
 | Recent batches in memory | A quarter of `max_file_mb` (256 KiB at least) per open file; older ones are dropped (a client that missed them catches up with the whole file) |
 | Bytes queued for slow clients | The largest message and 1 MiB per connection, 32 MiB per block of addresses, 256 MiB for everyone. A message sent to many people counts once for everyone and once per block (twenty colleagues behind one office address cost their block one copy of a broadcast), and welcomes (bounded by the file's size) don't count against blocks, so a whole office can join a file at once. A client that doesn't read its answers is dropped; when everyone's budget runs out, the connection holding the most is dropped |
diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md
index 4a6cec25a..a7d3402e4 100644
--- a/docs/target-app-parity.md
+++ b/docs/target-app-parity.md
@@ -1,6 +1,6 @@
 # FigCraft parity with Figma
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-16 · **Change:** minor (system theme follows the freedesktop colour scheme on Linux and the BSDs; reviewed Russian catalog and integer plurals; vector edit mode regions: hover hatch, selection and drag; plugin log byte/count limits (#191); core editor leftovers: component playground, auto gap handles, variables inside styles, inner shadows and background blur on groups, command-made text readable on dark pages, a one-step frame/group convert, delays on mouse triggers and manual overlay offsets, wrapped-line alignment; starter templates, a Templates tab and Getting started tips on the home screen: essentials ~57% → ~59%; everyday editing partials: number fields, outline options, Hide when publishing, cursors, panel widths, dark pages, numbers unchanged but menu breadth 211/211; text box sizes measured against documents re-saved by other software: whole-pixel line heights, advances on a 1024-per-em grid, letter spacing between glyphs only, numbers unchanged; .fig export checked by opening written files in other software, numbers unchanged; a public figcraft-server: open hosting, owner tokens, per-address limits, idle expiry, moderation, install.sh; experimental .fig export; keyboard shortcut parity suite and bindings; Simplified Chinese draft catalog; Latin American Spanish overlay; prototyping tail: gamepad triggers, widgets in prototypes, mode lookups; plugin directory on figcraft-server; Japanese and Korean draft catalogs and CJK UI fonts; plugin widgets and the plugin panel tail; French, German and Brazilian Portuguese draft catalogs; cursor chat and spotlight in live sessions; layers and assets panels behaviour suite and fixes; vector multi-edit and edit tail; dev resources links; extended collections tail; branch version history and finer list merges; headline percentages recomputed from the area table: feature breadth ~84%, core ~94%, mainstream ~50%; text lists, hanging punctuation and decoration styles; comments and version history behaviour suite and fixes; canvas navigation, guides and grids behaviour suite and fixes; export and inspect behaviour suite and fixes; .fig import: editable vector networks and more layer kinds; shapes and vector behaviour suite and fixes; paint and effects behaviour suite and fixes; frames, groups, sections and masks behaviour suite and fixes; styles and variables behaviour suite and fixes; prototyping behaviour suite and fixes; components behaviour suite and fixes; embedded image colour profiles; layers panel keyboard: F2 rename, Shift+F10 context menu, keyboard box selection, 10k-layer QA; per-side stroke weight variables; text behaviour suite: CJK line breaking, metrics, vertical trim; selection and transform behaviour suite and fixes; `.fig` import, best effort; auto layout behaviour suite and fixes; Display P3: gamut warning and soft-proof (true P3 blocked upstream); several windows; localization layer with a draft Spanish catalog; hosting figcraft-server: wss in the desktop app, server releases, deployment guide; plugin panels and settings; canvas fixes: boolean hit testing on the result, group drags, frame outlines and slices; code connect; stretch and scatter brushes, pen pressure; text on a path and pattern fills; team libraries on the server and swap library; branches: create, update from main, review and merge; animated GIF fills and TIFF images; Open recent, outlines for the selection and mask outlines: menu breadth 100%; extended collections, variables import/export, gradient stop and variant bindings; feature breadth ~80%; ready ~49%; last major: full re-measure against Figma desktop 126.10.7) · **Target:** Figma Design (desktop app 126.10.7, macOS)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-24 · **Change:** minor (boards: area 22 (weight 0, outside the weighted sum; Turkish reviewed, Czech and Indonesian drafts, the Japanese draft completed; reviewed Russian catalog and integer plurals; vector edit mode regions: hover hatch, selection and drag; plugin log byte/count limits (#191); core editor leftovers: component playground, auto gap handles, variables inside styles, inner shadows and background blur on groups, command-made text readable on dark pages, a one-step frame/group convert, delays on mouse triggers and manual overlay offsets, wrapped-line alignment; starter templates, a Templates tab and Getting started tips on the home screen: essentials ~57% → ~59%; everyday editing partials: number fields, outline options, Hide when publishing, cursors, panel widths, dark pages, numbers unchanged but menu breadth 211/211; text box sizes measured against documents re-saved by other software: whole-pixel line heights, advances on a 1024-per-em grid, letter spacing between glyphs only, numbers unchanged; .fig export checked by opening written files in other software, numbers unchanged; a public figcraft-server: open hosting, owner tokens, per-address limits, idle expiry, moderation, install.sh; experimental .fig export; keyboard shortcut parity suite and bindings; Simplified Chinese draft catalog; Latin American Spanish overlay; prototyping tail: gamepad triggers, widgets in prototypes, mode lookups; plugin directory on figcraft-server; Japanese and Korean draft catalogs and CJK UI fonts; plugin widgets and the plugin panel tail; French, German and Brazilian Portuguese draft catalogs; cursor chat and spotlight in live sessions; layers and assets panels behaviour suite and fixes; vector multi-edit and edit tail; dev resources links; extended collections tail; branch version history and finer list merges; headline percentages recomputed from the area table: feature breadth ~84%, core ~94%, mainstream ~50%; text lists, hanging punctuation and decoration styles; comments and version history behaviour suite and fixes; canvas navigation, guides and grids behaviour suite and fixes; export and inspect behaviour suite and fixes; .fig import: editable vector networks and more layer kinds; shapes and vector behaviour suite and fixes; paint and effects behaviour suite and fixes; frames, groups, sections and masks behaviour suite and fixes; styles and variables behaviour suite and fixes; prototyping behaviour suite and fixes; components behaviour suite and fixes; embedded image colour profiles; layers panel keyboard: F2 rename, Shift+F10 context menu, keyboard box selection, 10k-layer QA; per-side stroke weight variables; text behaviour suite: CJK line breaking, metrics, vertical trim; selection and transform behaviour suite and fixes; `.fig` import, best effort; auto layout behaviour suite and fixes; Display P3: gamut warning and soft-proof (true P3 blocked upstream); several windows; localization layer with a draft Spanish catalog; hosting figcraft-server: wss in the desktop app, server releases, deployment guide; plugin panels and settings; canvas fixes: boolean hit testing on the result, group drags, frame outlines and slices; code connect; stretch and scatter brushes, pen pressure; text on a path and pattern fills; team libraries on the server and swap library; branches: create, update from main, review and merge; animated GIF fills and TIFF images; Open recent, outlines for the selection and mask outlines: menu breadth 100%; extended collections, variables import/export, gradient stop and variant bindings; feature breadth ~80%; ready ~49%; last major: full re-measure against Figma desktop 126.10.7; rows for the community batches: Selection colors, smart-selection spacing and a Present tab (#753), `.fig` import fidelity, paste from another design app, a `.fig` copy from Save as; control requests while the window is minimised (#720); catalog counts re-measured; automation roots (#715); number variables in the text content picker (#629); frames and sections convert into each other (#719); reviewed Russian catalog and integer plurals; vector edit mode regions: hover hatch, selection and drag; plugin log byte/count limits (#191); core editor leftovers: component playground, auto gap handles, variables inside styles, inner shadows and background blur on groups, command-made text readable on dark pages, a one-step frame/group convert, delays on mouse triggers and manual overlay offsets, wrapped-line alignment; starter templates, a Templates tab and Getting started tips on the home screen: essentials ~57% → ~59%; everyday editing partials: number fields, outline options, Hide when publishing, cursors, panel widths, dark pages, numbers unchanged but menu breadth 211/211; text box sizes measured against documents re-saved by other software: whole-pixel line heights, advances on a 1024-per-em grid, letter spacing between glyphs only, numbers unchanged; .fig export checked by opening written files in other software, numbers unchanged; a public figcraft-server: open hosting, owner tokens, per-address limits, idle expiry, moderation, install.sh; experimental .fig export; keyboard shortcut parity suite and bindings; Simplified Chinese draft catalog; Latin American Spanish overlay; prototyping tail: gamepad triggers, widgets in prototypes, mode lookups; plugin directory on figcraft-server; Japanese and Korean draft catalogs and CJK UI fonts; plugin widgets and the plugin panel tail; French, German and Brazilian Portuguese draft catalogs; cursor chat and spotlight in live sessions; layers and assets panels behaviour suite and fixes; vector multi-edit and edit tail; dev resources links; extended collections tail; branch version history and finer list merges; headline percentages recomputed from the area table: feature breadth ~84%, core ~94%, mainstream ~50%; text lists, hanging punctuation and decoration styles; comments and version history behaviour suite and fixes; canvas navigation, guides and grids behaviour suite and fixes; export and inspect behaviour suite and fixes; .fig import: editable vector networks and more layer kinds; shapes and vector behaviour suite and fixes; paint and effects behaviour suite and fixes; frames, groups, sections and masks behaviour suite and fixes; styles and variables behaviour suite and fixes; prototyping behaviour suite and fixes; components behaviour suite and fixes; embedded image colour profiles; layers panel keyboard: F2 rename, Shift+F10 context menu, keyboard box selection, 10k-layer QA; per-side stroke weight variables; text behaviour suite: CJK line breaking, metrics, vertical trim; selection and transform behaviour suite and fixes; `.fig` import, best effort; auto layout behaviour suite and fixes; Display P3: gamut warning and soft-proof (true P3 blocked upstream); several windows; localization layer with a draft Spanish catalog; hosting figcraft-server: wss in the desktop app, server releases, deployment guide; plugin panels and settings; canvas fixes: boolean hit testing on the result, group drags, frame outlines and slices; code connect; stretch and scatter brushes, pen pressure; text on a path and pattern fills; team libraries on the server and swap library; branches: create, update from main, review and merge; animated GIF fills and TIFF images; Open recent, outlines for the selection and mask outlines: menu breadth 100%; extended collections, variables import/export, gradient stop and variant bindings; feature breadth ~80%; ready ~49%; last major: full re-measure against Figma desktop 126.10.7) · **Target:** Figma Design (desktop app 126.10.7, macOS)
 
 The authoritative assessment of how close FigCraft is to Figma Design. [`ROADMAP.md`](../ROADMAP.md)
 summarizes it; [`gaps.md`](gaps.md) is the ranked work list; the measured menu checklist is
@@ -9,13 +9,13 @@ summarizes it; [`gaps.md`](gaps.md) is the ranked work list; the measured menu c
 [`hardware-parity.md`](hardware-parity.md), [`localization-parity.md`](localization-parity.md),
 [`auto-layout-parity.md`](auto-layout-parity.md), [`components-parity.md`](components-parity.md),
 [`prototyping-parity.md`](prototyping-parity.md), [`dev-mode-parity.md`](dev-mode-parity.md),
-[`collaboration-parity.md`](collaboration-parity.md).
+[`collaboration-parity.md`](collaboration-parity.md), [`boards-parity.md`](boards-parity.md).
 
 ## Headline
 
 | Number | Value | Kind |
 |---|---|---|
-| Menu/command breadth | **100%** (211 / 211 catalogued menu items have a live command) | **measured** (`cargo xtask parity`, 2026-10-12) |
+| Menu/command breadth | **100%** (212 / 212 catalogued menu items have a live command) | **measured** (`cargo xtask parity`, 2026-10-17) |
 | Feature breadth (does each Figma Design feature exist, weighted) | **~85%** (core editor areas 1–16: ~94%) | estimated from the area table below |
 | Ready for real work | **~53%** | estimated (dimension table below: written weights × written per-dimension scores) |
 | Essentials user | **~59%** | estimated ([below](#essentials-user): core features 77.8% × discounts 0.92 × 0.94 × 0.88) |
@@ -84,8 +84,10 @@ Weights are the share of a typical product designer's working time in Figma Desi
 so they can be argued with. Areas 1–16 keep the original rubric's weights (they sum to 94, not the 100 the rubric claimed);
 areas 17–21 are added (sum 19) because Figma users depend on them. Percentages below divide by the
 total, 113.
-Out of scope as separate products: FigJam, Figma Slides, Sites, Make, Buzz, Weave (the `.jam` and
-`.deck` document kinds belong to them).
+Out of scope as separate products: Figma Slides, Sites, Make, Buzz, Weave (the `.deck` document
+kind belongs to them). Whiteboarding is covered by FigCraft's boards (area 22, weight 0: a separate
+workflow, tracked here but not in the weighted sum; [`boards-parity.md`](boards-parity.md)); the
+`.jam` document kind is not read or written.
 
 ## By feature area
 
@@ -97,24 +99,25 @@ Breadth: does it exist. Ready: depth, correctness and fidelity for real projects
 | 1 | Canvas & navigation | 6 | 98% | 74% | Outline mode's Include hidden layers and Include object bounds, Display P3 on screen, QA at extreme zooms (behaviour suite for navigation, rulers, guides, layout grids and outline mode landed: guide selection, Auto grid counts, outline-mode clicks) | 1–4 |
 | 2 | Selection & transform | 8 | 97% | 72% | Handles, measuring and snapping checked tool by tool against Figma and real files (snap distance, handle reach, cursors); children turned off a right angle scale without skew, approximately (behaviour suite from the documentation, rotated groups and mixed selections, equal spacing snapping, Cmd/Ctrl to ignore constraints and marquees inside frames landed) | 3–5 |
 | 3 | Layers panel | 5 | 99% | 85% | QA with long real files (behaviour suite from the documentation, Rename layers dialog, sweeping eyes and padlocks, page dragging and dividers, several layers dropped together, keyboard box selection, F2 rename, Shift+F10 context menu and 10k-layer timings landed) | 1–2 |
-| 4 | Shapes & vector | 8 | 99% | 73% | Corner smoothing on polygons, stars and vectors; the transform box around points of several layers; per-point caps and joins on dashed, variable-width and brush strokes; vector QA with real files (behaviour suites from the documentation, corner radius and star ratio handles, rounded vector points drawn, also beside curved segments, a cap and join per point, several handles dragged together, cut and paint bucket drags, delete and heal along the curve, a boolean group's look by operation and the miter angle landed) | 1–3 |
+| 4 | Shapes & vector | 8 | 99% | 73% | Corner smoothing on polygons, stars and vectors; per-point caps and joins on dashed, variable-width and brush strokes; vector QA with real files (behaviour suites from the documentation, corner radius and star ratio handles, rounded vector points drawn, also beside curved segments, a cap and join per point, several handles dragged together, cut and paint bucket drags, delete and heal along the curve, a boolean group's look by operation and the miter angle landed) | 1–3 |
 | 5 | Paint | 7 | 90% | 71% | Video fills, wide-gamut canvas, HEIC images; plus darker in PDF (behaviour suite from the documentation, pass-through and isolating groups, clipping frames that don't isolate, plus darker, animated GIF fills, TIFF images and embedded image colour profiles landed) | 2–5 |
 | 6 | Strokes | 3 | 95% | 75% | Stroke QA with real files (colour styles on strokes, stroke weight and per-side weight variables, brush strokes landed, see 20) | 1–2 |
 | 7 | Effects | 4 | 100% | 75% | Glass and progressive blur tuned side by side (behaviour suite from the documentation, inner shadows and background blur on groups, shadows hidden behind translucent layers on the canvas and in every export landed) | 2–5 |
 | 8 | Frames, groups, sections, masks | 5 | 97% | 80% | Visual QA with real files (a one-step frame/group convert, and a behaviour suite from the documentation landed: masked-out areas don't take clicks, mask group bounds and exports follow the mask, sections kept out of frames and groups, frames and sections drawn around layers take them, section resizing leaves contents in place, X/Y measured in the frame) | 1–3 |
 | 9 | Auto layout & constraints | 9 | 98% | 74% | Behaviour against real Figma files (behaviour suite from the documentation, `fr` tracks like CSS, vertical wrap, auto gaps evenly/around, cell alignment and wrapped-line alignment landed) ([auto-layout-parity](auto-layout-parity.md)) | 3–6 |
 | 10 | Text | 8 | 90% | 70% | Spell check, text metrics on real files and in other fonts (text box sizes measured against documents re-saved by other software: all 230 self-sizing boxes in 7 documents come out to the pixel, one font family; behaviour suite with CJK line breaking, vertical trim and carets by grapheme cluster landed; lists per paragraph with nesting and list spacing, hanging punctuation and lists, decoration style, thickness, offset, skip ink and colour landed) | 3–7 |
-| 11 | Components & variants | 9 | 96% | 72% | Real (not synthetic) libraries, `.fig` libraries (a component playground for variant, boolean and text properties, a behaviour suite from the documentation, overrides of padding, gap, grids, exports and interactions, refused geometry overrides, variant-switch and Assets-swap override rules, top-left default variant landed) ([components-parity](components-parity.md)) | 4–9 |
+| 11 | Components & variants | 9 | 96% | 72% | Real (not synthetic) libraries, `.fig` libraries (a component playground for variant, boolean, text and instance-swap properties, a behaviour suite from the documentation, overrides of padding, gap, grids, exports and interactions, refused geometry overrides, variant-switch and Assets-swap override rules, top-left default variant landed) ([components-parity](components-parity.md)) | 4–9 |
 | 12 | Styles & variables | 5 | 95% | 76% | Real-library QA (variables inside styles, behaviour suite from the documentation, style folders and order, mode order, code syntax, extended collections with their tail (new library variables as updates, chains through libraries) and variables import/export landed) ([components-parity](components-parity.md)) | 2–4 |
 | 13 | Prototyping | 6 | 92% | 74% | Video triggers and media actions, controllers on macOS, Linux and FreeBSD, real prototype QA (behaviour suite from the documentation, delays on mouse triggers, manual overlay offsets, key combinations, controller buttons on key/gamepad triggers (Windows and the browser), widgets reacting in prototypes, interactive components playing their variants, drag-driven animations, physical springs landed) ([prototyping-parity](prototyping-parity.md)) | 2–5 |
-| 14 | Import/export | 6 | 86% | 58% | `.fig` import's tail (best-effort import, editable vector networks, stand-ins for non-design layers and variable prototype actions landed; no real-file checks yet), checking the rest of the experimental `.fig` export (landed; written files open and draw in other software) on effects, images, prototypes and real files, HEIC/video import, CMYK output intent ([file-format-parity](file-format-parity.md)) | 5–10 |
+| 14 | Import/export | 6 | 86% | 58% | `.fig` import's tail (best-effort import, editable vector networks, stand-ins for non-design layers and variable prototype actions landed, then (2026-10-17) grid tracks, slots, labels of connectors saved with their path, per-point joins, text on a path, image adjustments, budgets for large files, an import report and paste from another design app; all on synthetic files, no real-file checks yet), checking the rest of the experimental `.fig` export (landed; written files open and draw in other software) on effects, images, prototypes and real files, HEIC/video import, CMYK output intent ([file-format-parity](file-format-parity.md)) | 5–10 |
 | 15 | Dev Mode / inspect | 2 | 96% | 72% | Import lines for connected instances inside generated layer trees; an editor extension is left to the MCP server (inspect behaviour suite with colour formats, rem and icon and image assets, code connect, plugins in Dev Mode and dev resources links landed) ([dev-mode-parity](dev-mode-parity.md)) | 0–1 |
 | 16 | Comments, versions, find, misc | 3 | 87% | 63% | Comments are local only; comparing two versions; branches in live sessions; text runs and other lists besides fills, strokes and effects merge whole (branches with review and merge, their own version history and per-item list merges, and a comments and version history behaviour suite from the documentation landed) | 1–3 |
 | 17 | Multiplayer & sharing | 8 | 17% | 5% | Core landed (`crates/collab`: ids, change sets, server ordering, convergence tested); live sessions (preview): WebSocket transport, hosting from the desktop app, joining from the app or the browser, invite links that open the app, cursors, selections and follow, cursor chat and spotlight, per-person undo, offline resume; a self-hosted `figcraft-server` with persistence and share links to edit or view, which can be open to the public (owner tokens, limits per address, expiry, moderation). Left: accounts and teams, audio ([collaboration-parity](collaboration-parity.md)) | 42–84 |
-| 18 | Plugins & widgets | 4 | 60% | 35% | Own sandboxed WASM plugins landed (#101: manifest, permissions, menu, Run last, Manage, SDK), with log byte/count limits checked before allocation and host forwarding ([logging limits](plugins.md#logging-limits)), plugin panels called back per button or changed value and per-plugin settings (ABI v2), then widgets (API 3: plugin-drawn layers on the canvas with state kept in the document, redrawn on clicks; a Counter example), panels side by side and a colour picker for plugin colour fields, then a plugin directory on `figcraft-server` (publish with the server key, browse, install after a permissions confirmation, hash-checked downloads, updates by version). Left: a public catalogue, publisher accounts and signatures, ratings, background update checks, the directory in the browser; widgets take clicks only (no text input, property menus, hover or timers) and draw frames, text, shapes and images only; Figma's plugins are JavaScript and don't run (a JS engine would be an owner decision) ([plugins.md](plugins.md)) | 8–26 |
+| 18 | Plugins & widgets | 4 | 60% | 35% | Own sandboxed WASM plugins landed (#101: manifest, permissions, menu, Run last, Manage, SDK), with log byte/count limits checked before allocation and host forwarding ([logging limits](plugins.md#logging-limits)), plugin panels called back per button or changed value and per-plugin settings (ABI v2), then widgets (API 3: plugin-drawn layers on the canvas with state kept in the document, redrawn on clicks; a Counter example), panels side by side and a colour picker for plugin colour fields, then a plugin directory on `figcraft-server` (publish with the server key, browse, install after a permissions confirmation, hash-checked downloads, updates by version); layer data written with `node.set {props: {pluginData}}` reads back through `node.get` (#879). Left: a public catalogue, publisher accounts and signatures, ratings, background update checks, the directory in the browser; widgets take clicks only (no text input, property menus, hover or timers) and draw frames, text, shapes and images only; Figma's plugins are JavaScript and don't run (a JS engine would be an owner decision) ([plugins.md](plugins.md)) | 8–26 |
 | 19 | Team libraries & organization | 2 | 70% | 40% | Libraries kept on `figcraft-server` under their file and enabled by a share link (per-asset versions, background update checks, overrides kept), usage counts per component and file, swapping a library by names. Left: team-wide library lists, accounts and permissions, analytics over time, pushed update notices | 4–8 |
 | 20 | Figma Draw extras | 2 | 88% | 60% | Have: variable width, lasso, shape builder, noise/texture, text on a path, pattern fills, stretch and scatter brushes, pen pressure (Windows pens, browser styluses), multi-edit (several vector layers in edit mode at once). Missing: pressure from macOS/Linux tablets | 1–3 |
 | 21 | AI features | 3 | 0% | 0% | First draft, rename layers, image edit/remove background, visual search, Make: needs local models (owner decision) | 30–60 |
+| 22 | Boards (whiteboarding) | 0 | ~35% | ~20% | Board files with sticky notes, shapes with text, connectors that follow what they join, marker, highlighter and eraser, stamps, text and sections, in live sessions (M12); missing: timer, voting, board widgets, templates, tables, mind maps, washi tape, audio, quick-create handles, stamps sticking to objects, `.jam` files ([boards-parity](boards-parity.md)). Not in the weighted sum | 30–60 |
 | | **Weighted (÷113)** | 113 | **~85%** | **~63%** | | **117–255** |
 | | Core editor only (1–16, ÷94) | 94 | ~94% | ~72% | | 32–74 |
 
@@ -124,12 +127,12 @@ Breadth: does it exist. Ready: depth, correctness and fidelity for real projects
 |---|---|---|---|---|---|
 | Features (depth) | 35 | 63% | 28–67 (areas 1–13, 15, 16, 20) | The table above; core editor ~72% | this file |
 | UI/UX fidelity | 15 | 58% | 40–60 | Look & feel compared side by side with UI3 (~65% by the builders); tool-by-tool interaction (modifiers while dragging, hover states, popovers) not yet compared (a cursor for every tool and modifier, number fields and panel widths built from the documentation, not compared); accessibility names and keyboard navigation landed | [ui-parity](ui-parity.md) |
-| File formats | 12 | 60% | 5–10 | `.fig` read, best effort, with editable vector networks (tested on generated fixtures, not real files), `.fig` write experimental (round trips through our own importer; written files open and draw in other software); REST JSON import, SVG in/out, PNG/JPG/WebP/PDF export solid, with a behaviour suite from the documentation | [file-format-parity](file-format-parity.md) |
+| File formats | 12 | 60% | 5–10 | `.fig` read, best effort, with editable vector networks and (2026-10-17) more fidelity, budgets for large files and an import report (tested on generated fixtures, not real files); layers copied from another design app paste the same way (tested only with clipboard HTML made from our own export), `.fig` write experimental (round trips through our own importer; written files open and draw in other software); REST JSON import, SVG in/out, PNG/JPG/WebP/PDF export solid, with a behaviour suite from the documentation | [file-format-parity](file-format-parity.md) |
 | Collaboration | 10 | 13% | 52–104 | Local comments, version history and branches with review and merge; the multiplayer core (sync model, server ordering, client reconciliation, convergence tests) landed in #103, and live sessions (preview) co-edit a file hosted by a desktop app or kept on a self-hosted `figcraft-server` with edit and view links, joined from the app or the browser, with cursor chat and spotlight (`docs/collab-protocol.md`) | [collaboration-parity](collaboration-parity.md) |
 | Stability | 8 | 55% | 20–40 | Never-crash lints, command guard with rollback, recovery copies, 963 tests incl. junk-parameter sweeps and a seeded retained-render walk; but two days old, one release (v0.2.0), no field reports, QA mostly on macOS | [gaps](gaps.md) |
 | Performance | 6 | 60% | 30–60 | `cargo xtask bench`: 50k-layer page ~8 ms zoomed out, 10k-layer edits ~0.2 ms, 2,000-instance design system edits 4–64 ms; CPU (tiny-skia) canvas where Figma renders on the GPU; nothing timed against Figma on the same file | [hardware-parity](hardware-parity.md) |
 | Hardware | 3 | 60% | 10–21 | Trackpad pinch and HiDPI yes; pen pressure on Windows and from browser styluses (none from macOS/Linux tablets); several windows (screen-reader tree in the main one only); no GPU canvas, no P3 on screen | [hardware-parity](hardware-parity.md) |
-| Localization | 3 | 39% | 29–51 | The layer, English, Russian reviewed by VanTan, and machine drafts of Spanish (with a Latin American overlay), French, German, Brazilian Portuguese, Japanese, Korean and Simplified Chinese (none reviewed by a native speaker; every draft covers all current strings), CJK UI text in installed faces loaded on demand (web: only the craft-fonts CJK build); engine messages stay English | [localization-parity](localization-parity.md) |
+| Localization | 3 | 39% | 29–51 | The layer, English, Russian reviewed by VanTan, and machine drafts of Spanish (with a Latin American overlay), French, German, Brazilian Portuguese, Japanese, Korean, Simplified Chinese, Indonesian and Czech (none reviewed by a native speaker; measured 2026-10-17, the drafts cover 95–99% of the 2,272 current strings), Swedish and Turkish catalogs, CJK UI text in installed faces loaded on demand (web: only the craft-fonts CJK build); engine messages stay English | [localization-parity](localization-parity.md) |
 | Platforms | 3 | 75% | 10–20 | macOS, Windows (x64/x86/arm64), Linux, FreeBSD, web all packaged (v0.2.0); Figma also has iOS/Android apps; non-macOS QA thin | [hardware-parity](hardware-parity.md) |
 | Ecosystem/plugins | 3 | 38% | 8–26 | Own WASM plugins with a Rust SDK and three examples (#101), plugin panels and settings (ABI v2), widgets that take clicks (API 3), a self-hosted plugin directory on `figcraft-server`; no Figma plugin compatibility, no public catalogue or community files; the CLI, control channel and MCP server are ahead of Figma for agents | [gaps](gaps.md) |
 | AI features | 2 | 0% | 30–60 | None | [gaps](gaps.md) |
@@ -423,7 +426,11 @@ Hours in this narrative are the builders' estimates; the tables above supersede
    JPG, WebP, SVG and PDF, suffix, advanced options: contents only, include bounding box, and for
    SVG outline text, id attributes and simplified strokes), a preview, and "Export N layers" (`file.exportLayers`) in the
    panel and the Export dialog. Paste from other apps: images, SVG and text (the newest clipboard
-   content wins over our own copy; pasted SVG lands centred in the view). SVG import is editable and
+   content wins over our own copy; pasted SVG lands centred in the view), and layers copied from
+   another design app (`edit.pasteDesignLayers`: the `.fig` canvas in the clipboard's HTML read
+   like a `.fig` file, best effort; tested with clipboard HTML made from our own export only).
+   File ▸ Save as… to a `.fig` name writes an experimental export copy and the document keeps its
+   `.figcraft` path. SVG import is editable and
    checked against a corpus of synthetic files (expected pixels worked out by hand, layer structure,
    export and re-import): groups named from their ids with transforms baked into the layers;
    rectangles (corner radius), ellipses and lines kept as those shapes; gradients with exact
@@ -621,14 +628,27 @@ Carried over from the ROADMAP's "Shipped so far" (2026-10-10). The test count th
   focus ring) and screen-reader names for the custom controls (AccessKit), presentation player with
   transitions, light and dark themes, home screen, About/Preferences/shortcuts/variables dialogs.
 - **Automation:** desktop control channel (`--control <port>`: execute commands, inspect document/UI,
-  synthetic pointer/keys/typing, menu invocation, screenshots, renders).
+  synthetic pointer/keys/typing, menu invocation, screenshots, renders). What agents read and write
+  on disk can be confined to chosen folders (`--automation-read-root` / `--automation-write-root` on
+  `figcraft-cli mcp` and the desktop app, #715). A minimised or covered window answers every
+  request that acts on the app's state without drawing (about 100 ms each on Windows), and the
+  ones that need a drawn frame (`ui.screenshot`, `ui.input`, `window.new`) fail at once instead of
+  waiting 60 s (#720; not tested on macOS, and under Wayland a minimised window can't be told
+  apart).
 - **Tests:** 963 `#[test]` functions (2026-10-10) including junk-parameter sweeps over every command (and every vector-edit command while editing), importer fuzzing and render regressions.
 
 ## Revision history
 
 | Date | Change | Summary |
 |---|---|---|
-| 2026-10-16 | minor | Fix: the "system" interface theme followed the OS only where the windowing stack reports a theme; winit gives none on Linux and the BSDs, so the desktop app always drew light there. The interface now falls back to the freedesktop colour scheme (`org.freedesktop.portal.Settings`, read once and watched through a D-Bus signal, the `Services::system_dark` platform services), so system mode follows GNOME's and KDE Plasma 6's appearance setting live; the OS theme keeps winning where winit does report one (macOS, Windows, web), and without any answer the light fallback stands. Numbers unchanged. |
+| 2026-10-24 | minor | Boards (M12): a file kind of its own (`file.newBoard`, saved in `.figcraft`, carried to live-session joiners) with sticky notes, shapes with text, connectors that re-route when what they join moves (an engine recompute, the same for local edits, undo and others' edits), marker, highlighter and eraser, stamps with the placer's name, a board toolbar and a contextual bar; prototyping and Dev Mode refuse on boards; design files and boards have their own marks on tabs and file rows. Area 22 added at weight 0 (breadth ~35%, ready ~20%); headline numbers unchanged (the weighted sum leaves area 22 out) |
+| 2026-10-15 | minor | Localization (#263, #469, #477, #288): Turkish reviewed by a native speaker, Czech and Indonesian drafts, the Japanese draft caught up; coverage re-measured (2,177 entries; the five older drafts at 95%). Localization 39% and 29–51 h unchanged at this rounding (see [localization-parity](localization-parity.md)) |
+| 2026-10-22 | minor | Vector edit mode: the transform box around points selected in several layers (in the page's axes; scale, rotate and drag in one undo step). Shapes & vector's remaining work loses that item; numbers unchanged |
+| 2026-10-20 | minor | Layer data reads back (#879): `node.get` (the command, the control method and MCP `get_node`) and `document.inspect` report a layer's or page's `pluginData` as `{key: value}` when it has any, so a tool that keeps state in a file with `node.set {props: {pluginData}}` can read it on its next run (`plugin_data_tests`). Numbers unchanged |
+| 2026-10-17 | minor | Menu breadth re-run with `cargo xtask parity`: 212 / 212 (100%; the catalog gained View ▸ Full screen with #227 on 2026-10-14), 561 commands. Rows for the 2026-10-17 landings: import/export (area 14) and the file formats dimension name the `.fig` import's new fidelity (instance identity, overrides by key, text style precedence, grid tracks, slots, connector labels, per-point joins, text on a path, image adjustments, list start numbers, vertical trim), budgets from the file's size, the import report, a `.fig` copy from Save as and paste from another design app; the localization evidence takes the re-measured catalog counts (2,272 entries, drafts at 95–99%, Indonesian and Czech drafts, Swedish and Turkish catalogs); the Automation line adds control requests answered while the window is minimised (#720); batch #753's Selection colors, smart-selection spacing, Present tab and auto layout on empty frames are in ui-parity, prototyping-parity and auto-layout-parity. Numbers unchanged: every `.fig` and paste change is checked on synthetic files or clipboard HTML made from our own export, and real files are what gap 1's blocker and the file-exchange discounts wait for; the UI changes (menus, the Actions palette, editor fixes) are not compared side by side, so UI/UX stays at 58%; the localization grade and hours stay (Indonesian's draft is offset by the drafts' new gaps) |
+| 2026-10-17 | minor | Automation roots (M8, #715, #481): `figcraft-cli mcp --automation-read-root DIR --automation-write-root DIR` (each repeatable, existing folders) and the desktop app with the same flags confine every file a command reads to the read and write roots and every file it writes to the write roots; paths are resolved (links followed, `..`, Windows `\\?\` and UNC paths, case) and compared by whole folder names, anything else is an ordinary error. The engine reaches the file system through one module (enforced by `crates/engine/clippy.toml`), and a sweep runs every command with paths outside the roots. `--attach` refuses the flags (the app confines itself); `ui.screenshot` and `ui.render` return PNG data without a `path`, so the attached MCP server writes no temporary files. Numbers unchanged. |
+| 2026-10-17 | minor | Number variables on text content (M3, #629): the Typography section's variable picker also lists number variables for a text layer's content, as the engine already accepted (the text shows the number, e.g. 42.5, and follows the variable). Other text fields keep their own types. Numbers unchanged. |
+| 2026-10-17 | minor | Frames and sections convert into each other (M1, #719): `object.convertToSection` turns a frame on the page or in a section into a section in place (same box, name, fill and layers, which stay where they are; what only a frame has goes: auto layout, clipping, layout grids, guides, scrolling), and `object.convertToFrame` now also turns a section into a frame that keeps its fill and doesn't clip, so the look stays. Nested frames, instances, main components and sections holding sections are refused with the reason; one undo step each. Both are in the canvas context menu (Convert to section / Convert to frame) and in Spanish. Numbers unchanged. |
 | 2026-10-14 | minor | Russian catalog (M9), reviewed and approved by VanTan: all 2,165 current entries, Русский in Preferences and regional ru tags. Russian integer plurals use one/few/many; contributor display name VanTan added. Existing estimates unchanged. |
 | 2026-10-13 | minor | Vector edit mode regions: the filled area under the pointer is hatched (clear of points and segments, holes left out, spacing by octave folding fitted to measurements at several zoom levels, fixed to the shape); click, Shift-click and drag select and move areas with their points (drawn unselected); a click on an empty spot clears them and stays in edit mode (see [ui-parity](ui-parity.md)) |
 | 2026-10-13 | minor | Plugin log limits (#191): cap each UTF-8 line at 8 KiB, total log bytes at 1 MiB and lines at 1,000 per run/callback before copying guest memory or forwarding to the host. Over-budget runs fail and roll back document edits; callbacks get fresh budgets. Added sandbox boundary/forwarding tests and an engine rollback regression. Percentages and hours unchanged. |
diff --git a/docs/translating.md b/docs/translating.md
index d93c02554..9dfca60c3 100644
--- a/docs/translating.md
+++ b/docs/translating.md
@@ -15,14 +15,14 @@ Simplified.
 `pref.language {language}` does the same from the CLI, MCP and the control channel.
 
 The catalogs: English (`en`, the source), and Spanish (`es`, with the Latin American overlay
-`es-419`), French (`fr`), German (`de`), Brazilian Portuguese (`pt-BR`), Japanese (`ja`), Korean (`ko`),
-Simplified Chinese (`zh-Hans`), Czech (`cs`) and Indonesian (`id`), machine-drafted and waiting for
-native speakers' review. Russian (`ru`, Русский) was reviewed and approved by VanTan; its catalog
-keeps Frame, Dev Mode and Smart animate as familiar tool names and uses « » quotes. Turkish (`tr`)
-was machine-drafted and reviewed by a native speaker.
-`es-419`), French (`fr`), German (`de`), Brazilian Portuguese (`pt-BR`), Japanese (`ja`), Korean (`ko`)
-and Simplified Chinese (`zh-Hans`), machine-drafted and waiting for native speakers' review, and
-Swedish (`sv`), which translates every UI string and some command labels.
+`es-419`), French (`fr`), German (`de`), Dutch (`nl`), Brazilian Portuguese (`pt-BR`), Japanese
+(`ja`), Korean (`ko`), Simplified Chinese (`zh-Hans`), Czech (`cs`), Indonesian (`id`), Finnish
+(`fi`), Polish (`pl`) and Bengali (`bn`), machine-drafted and waiting for native speakers' review. Georgian
+(`ka`) was written with AI assistance and reviewed by a native speaker, and stays a draft until a
+maintainer changes its status. Russian (`ru`, Русский) was
+reviewed and approved by VanTan; its catalog keeps Frame, Dev Mode and Smart animate as familiar
+tool names and uses « » quotes. Turkish (`tr`) was machine-drafted and reviewed by a native speaker,
+and Swedish (`sv`) translates every UI string, command label and menu wording.
 
 ## The catalogs
 
@@ -59,14 +59,20 @@ komponenta, instance, varianta, automatické rozvržení, omezení, výplň, tah
 proměnná, styl). Indonesian uses bare imperatives for buttons and menu items (Simpan, Hapus), the
 formal Anda (never kamu), keeps established design terms in English (frame, layer, component,
 instance, auto layout, plugin, file) and keeps a noun unchanged after a count, so its plural entries
-give only `other`.
+give only `other`. Georgian has no letter case (never write Mtavruli for capitals), uses verbal nouns
+for commands (გვერდის დამატება) and keeps a noun singular after a numeral, so counts read
+"შრე: {n}" and its plural entries give the same text for `one` and `other`.
 
 CJK text needs a CJK font, which egui and Inter lack: the desktop app adds an installed one when
 something on screen needs it (see `crates/ui-egui/src/cjk.rs`). The web build has no system fonts,
 so Japanese, Korean and Chinese appear there only in a build with craft-fonts and
 `FIGCRAFT_EMBED_CJK=1` (Noto Sans CJK SC, +16 MB); otherwise they are left out of the picker. A
-Chinese UI puts its Chinese face first so Han takes Simplified Chinese shapes. A new CJK or other non-Latin
-language also needs its script in `cjk::language`.
+Chinese UI puts its Chinese face first so Han takes Simplified Chinese shapes. Georgian is drawn in
+craft-fonts' Noto Sans Georgian, one of the built-in faces in `theme::install_fonts`, or else in an
+installed font on the desktop. Web builds keep it only when the craft-fonts they're built with has
+it (`crates/text/build.rs`); the commit releases pin doesn't yet (`docs/releasing.md`), so the web
+picker leaves Georgian out. A new CJK or other non-Latin language also needs its script in
+`cjk::language`, or a built-in craft-fonts face.
 
 ## Adding a language
 
@@ -83,13 +89,11 @@ language also needs its script in `cjk::language`.
    a missing key uses the fallback catalog's own plural rule. Czech uses `one` for 1, `few` for
    2–4 and `other` for 0 and 5+ (e.g. `{n} vrstva`, `{n} vrstvy`, `{n} vrstev`). Keep `{n}` in all
    three forms. Czech's CLDR `many` applies only to decimals; `trn` takes integer counts.
-4. To require full coverage, add the code to `COMPLETE` in
-   [`crates/ui-egui/src/i18n_tests.rs`](../crates/ui-egui/src/i18n_tests.rs). Every later PR that
-   adds a string then has to translate it into each complete language, so only Spanish is there:
-   French, German, Brazilian Portuguese, Japanese, Korean, Simplified Chinese, Czech and Indonesian
-   are registered as drafts, Russian and Turkish are reviewed but not required, and a string added
-   later shows English in them until it is translated. To list what a draft lacks,
-   add its code to `COMPLETE` locally and run the check.
+   Polish uses `one` for 1 only, `few` like Russian (2–4, 22–24… except 12–14) and `many` for
+   the other integers, including 0 and 21 (e.g. `{n} warstwa`, `{n} warstwy`, `{n} warstw`).
+4. A string added later shows English in every language until someone translates it; a missing
+   translation never fails a check or a build. `cargo xtask i18n-report` lists what each language
+   lacks (UI strings, command labels, menu wordings), and `cargo xtask ci` prints the same list.
 5. Run the check and look at the panels in the app (longer words must fit the right panel):
 
        cargo test -p figcraft-ui-egui i18n
@@ -98,9 +102,9 @@ language also needs its script in `cjk::language`.
    with "…" and show it in full on hover; elsewhere, look for clipped or wrapped text.
 
 The check fails on keys the code uses that `en.toml` lacks (it prints the lines to paste), keys no
-code uses, unknown command ids, placeholders that don't match English, and, for complete languages,
-anything untranslated. Machine-drafted catalogs stay marked as drafts until a native speaker has
-reviewed them.
+code uses, unknown command ids and placeholders that don't match English. Machine-drafted catalogs
+stay marked as drafts until a native speaker has reviewed them; a reviewed catalog stays a draft
+until a maintainer approves it (its `status` says which).
 
 ## Adding strings in code
 
@@ -108,7 +112,11 @@ Wrap every string a user sees or a screen reader hears: `tr` for plain text, `tr
 placeholders, `trn` for counts, `tr_noop` for literals in `const` tables that are looked up later
 with `tr(label)`. The key must be a string literal as the first argument (the check reads the
 source). Don't wrap ids, command ids, JSON, log messages, file extensions or document content. Then
-add the key to `en.toml` and to each complete language (Spanish and Russian); the drafts may follow later.
+add the key to `en.toml`; translations may follow later.
 
 Labels from the engine and document crates (tool names, blend modes, easing curves…) are looked up
 at display with `tr(x.label())`; they are listed in `dynamic_labels` in `i18n_tests.rs`.
+
+The importers' fixed notes (the string literals passed to `warn` in `crates/format/src/fig` and
+`crates/format/src/rest`) are keys too: the import report shows them in the UI language, so a new
+note goes into `en.toml`. Notes built with `format!` show in English.
diff --git a/docs/ui-parity.md b/docs/ui-parity.md
index 62001715e..e999ed468 100644
--- a/docs/ui-parity.md
+++ b/docs/ui-parity.md
@@ -1,6 +1,6 @@
 # UI and interaction parity
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-15 · **Change:** minor (fields select their text on focus; Typography spacing icons support scrubbing (#373); CSS colour names in hex fields; the Small caps sample in Type settings drawn from capitals; recent files as cards; vector edit mode: hovering, hatching, selecting and dragging filled regions; home screen: Templates tab, first-run templates and Getting started tips; number fields: scrub rates, arrow steps, arithmetic with brackets, relative edits of mixed values; outline mode's hidden layers and object bounds; Hide when publishing; cursors per tool and modifier; panel widths; dark pages for files made in the dark theme; drag threshold and double-clicks into text in groups; rotation origin on Alt+R and placing with Enter: no documented shortcut missing; keyboard shortcut parity suite and bindings; cursor chat and spotlight in live sessions; layers and assets panels behaviour suite and fixes; vector multi-edit and the vector edit tail; canvas navigation, guides and grids behaviour suite and fixes; shapes and vector behaviour suite and fixes; paint and effects behaviour suite and fixes; frames, groups, sections and masks behaviour suite and fixes; layers panel keyboard: F2 rename, Shift+F10 context menu, F8 box selection; selection and transform behaviour suite and fixes; Display P3: gamut warning and soft-proof (true P3 blocked upstream); several windows; boolean hit testing on the result, group drags, frame outlines and slices; outlines for the selection, mask outlines; arc fields, live boolean editing, shape builder on strokes, one-sided widths) · **Target:** Figma Design UI3 (desktop app 126.10.7)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-24 · **Change:** minor (board tool keys pinned; community fixes: the text box by dragging, the font picker keys, the pen path on leaving Design, a still canvas in vector edit mode, a scrolling pages list, colour emoji, readable new text in frames, system theme on first run; the Small caps sample in Type settings drawn from capitals; recent files as cards; vector edit mode: hovering, hatching, selecting and dragging filled regions; home screen: Templates tab, first-run templates and Getting started tips; number fields: scrub rates, arrow steps, arithmetic with brackets, relative edits of mixed values; outline mode's hidden layers and object bounds; Hide when publishing; cursors per tool and modifier; panel widths; dark pages for files made in the dark theme; drag threshold and double-clicks into text in groups; rotation origin on Alt+R and placing with Enter: no documented shortcut missing; keyboard shortcut parity suite and bindings; cursor chat and spotlight in live sessions; layers and assets panels behaviour suite and fixes; vector multi-edit and the vector edit tail; canvas navigation, guides and grids behaviour suite and fixes; shapes and vector behaviour suite and fixes; paint and effects behaviour suite and fixes; frames, groups, sections and masks behaviour suite and fixes; layers panel keyboard: F2 rename, Shift+F10 context menu, F8 box selection; selection and transform behaviour suite and fixes; Display P3: gamut warning and soft-proof (true P3 blocked upstream); several windows; boolean hit testing on the result, group drags, frame outlines and slices; outlines for the selection, mask outlines; arc fields, live boolean editing, shape builder on strokes, one-sided widths; fields select their text on focus; Typography spacing icons support scrubbing (#373); CSS colour names in hex fields; the Small caps sample in Type settings drawn from capitals; recent files as cards; vector edit mode: hovering, hatching, selecting and dragging filled regions; home screen: Templates tab, first-run templates and Getting started tips; number fields: scrub rates, arrow steps, arithmetic with brackets, relative edits of mixed values; outline mode's hidden layers and object bounds; Hide when publishing; cursors per tool and modifier; panel widths; dark pages for files made in the dark theme; drag threshold and double-clicks into text in groups; rotation origin on Alt+R and placing with Enter: no documented shortcut missing; keyboard shortcut parity suite and bindings; cursor chat and spotlight in live sessions; layers and assets panels behaviour suite and fixes; vector multi-edit and the vector edit tail; canvas navigation, guides and grids behaviour suite and fixes; shapes and vector behaviour suite and fixes; paint and effects behaviour suite and fixes; frames, groups, sections and masks behaviour suite and fixes; layers panel keyboard: F2 rename, Shift+F10 context menu, F8 box selection; selection and transform behaviour suite and fixes; Display P3: gamut warning and soft-proof (true P3 blocked upstream); several windows; boolean hit testing on the result, group drags, frame outlines and slices; outlines for the selection, mask outlines; arc fields, live boolean editing, shape builder on strokes, one-sided widths; a rename selects the whole name, so typing replaces it; Escape or Enter after a pen path stays on the same vector (#760); IME composition kept on through idle frames of a text edit, candidates at the caret (#747); Selection colors for mixed selections and smart-selection spacing (#753); submenus with a hover delay and a safe triangle; the Actions palette's tabs, ranked search, highlight and recents; menu items that ask for a value; editor fixes from the community batches; fields select their text on focus; Typography spacing icons support scrubbing (#373); CSS colour names in hex fields; the Small caps sample in Type settings drawn from capitals; recent files as cards; vector edit mode: hovering, hatching, selecting and dragging filled regions; home screen: Templates tab, first-run templates and Getting started tips; number fields: scrub rates, arrow steps, arithmetic with brackets, relative edits of mixed values; outline mode's hidden layers and object bounds; Hide when publishing; cursors per tool and modifier; panel widths; dark pages for files made in the dark theme; drag threshold and double-clicks into text in groups; rotation origin on Alt+R and placing with Enter: no documented shortcut missing; keyboard shortcut parity suite and bindings; cursor chat and spotlight in live sessions; layers and assets panels behaviour suite and fixes; vector multi-edit and the vector edit tail; canvas navigation, guides and grids behaviour suite and fixes; shapes and vector behaviour suite and fixes; paint and effects behaviour suite and fixes; frames, groups, sections and masks behaviour suite and fixes; layers panel keyboard: F2 rename, Shift+F10 context menu, F8 box selection; selection and transform behaviour suite and fixes; Display P3: gamut warning and soft-proof (true P3 blocked upstream); several windows; boolean hit testing on the result, group drags, frame outlines and slices; outlines for the selection, mask outlines; arc fields, live boolean editing, shape builder on strokes, one-sided widths) · **Target:** Figma Design UI3 (desktop app 126.10.7)
 
 Fine canvas control is what Figma users feel first: handles, snapping, nudging, modifier keys,
 drag behaviour, numeric precision. This checklist covers the tools, gestures and panels. Status:
@@ -15,19 +15,20 @@ interaction feel not yet compared.
 
 | Item | Status | Notes |
 |---|---|---|
-| UI3 layout: tab strip as title bar, icon rail, file header, pages + layers, floating bottom toolbar with flyouts, Design / Prototype / Inspect panels | done | frameless window on Windows/Linux with drawn buttons |
+| UI3 layout: tab strip as title bar, icon rail, file header, pages + layers, floating bottom toolbar with flyouts, Design / Prototype / Inspect panels | done | frameless window on Windows/Linux with drawn buttons; on a Wayland compositor that offers no server-side decorations (GNOME) the window gets winit's Adwaita controls instead (#592; checked by its author on GNOME, KDE not run) |
 | Light and dark themes | done | colours from `theme::Tokens`; a file or a page made while the dark theme shows gets a `#1E1E1E` page (`#F5F5F5` in the light theme), its own from then on: changing the theme repaints no page and opened files keep theirs; the file the app opens with takes the theme once it is known; the CLI, MCP and exports have no theme and keep `#F5F5F5`; text drawn with the Text tool is white on a dark page and black on a light one (so is text a command makes in the app without naming a fill; headless sessions keep black) (`theme_pages_tests`, `dark_page_text_tests`) |
 | Minimize UI (Cmd+\\) | done | |
 | Resizable panels | done | each panel's edge drags its width (left 200–480, right 240–480, 240 by default; a double-click on the edge or View ▸ Panels ▸ Reset panel widths puts the default back); the widths are each window's own, the main window's are kept in the preferences when a drag ends and come back at the next start, a new window opens with those of the window it comes from; Minimize UI hides the panels and brings them back as they were; the view keeps its centre and zoom while a panel is resized; in a window too small for them the panels give way so the canvas keeps 160 px (the left one first), down to the smallest window (800×500) (`panel_width_tests`). Not compared with Figma's widths; no snap points |
-| Actions palette (Cmd+K, Cmd+/) | done | commands; no assets search parity |
-| Context menus | done | canvas and layers; Shift+F10 opens them from the keyboard (at the focused layer row or below the canvas selection) and the menu takes the keyboard; the Menu key isn't delivered by the windowing layer (egui 0.36 has no key for it) |
+| Actions palette (Cmd+K, Cmd+/) | done | tabs: All (every command, grouped by menu, or Other), Assets (components and styles) and Plugins & widgets; results ranked prefix first, then shortest, at most 60 rows; Up/Down move a highlight and Enter runs it; Recents list what was run from the palette (matching translated labels); one open/toggle path from every entry point (`palette_tests`). Ranking and the Assets results not compared with Figma's |
+| Context menus | done | canvas and layers; submenus as in the main menu below, and a right-click in a new spot starts a fresh menu (Select layer closed); Shift+F10 opens them from the keyboard (at the focused layer row or below the canvas selection) and the menu takes the keyboard; the Menu key isn't delivered by the windowing layer (egui 0.36 has no key for it) |
 | Home screen: Recents, Online and Templates | done (ours) | The sidebar switches between the three (`ui.set {homeSection}`). Online: your online files (see the collaboration checklist). Recents: new file, open, join with a code, open files, recent files (cards with the picture each file carries on its page colour, the file's icon, name and "Edited ... ago" or "File not found", full path on hover; or a Name, Last modified and Created table with sortable headers; sorted by name, creation or last change either way; grid or list and the sort kept in the preferences, `ui.set {homeRecentsView, homeRecentsSort, homeRecentsOrder}`; a click selects, a double-click or Enter opens, arrow keys move the selection; Open, Show in folder and Remove from recents on right-click), a Getting started card (six tips with their shortcuts from the keymap; its close button is remembered in the preferences and Help ▸ Getting started brings it back) and, while there are no recent files, four templates to start from. Templates: the eight starter templates as cards (thumbnail rendered from the document, cached per theme; name, description, kind and size), a search field and a kind filter, an empty state; Tab reaches every card and Enter opens it; cards and tabs are named for screen readers. A first run opens here. No Community files or drafts folder |
-| Main menu from the logo | done | generated from `catalog.rs`; popups sized to content |
-| Keyboard shortcuts panel | done | docked, tabbed by group like the documentation, searchable, per-platform keycaps; held keys, gestures and presentation keys listed beside the bindings; a label too long for its column ends with "…" and shows in full on hover |
+| Main menu from the logo | done | generated from `catalog.rs`; popups sized to content. Submenus open after 0.15 s on their row (a click or the keyboard opens one at once) and close at once when another row is hovered; while the pointer heads for an open submenu inside the triangle to its near edge, the rows it crosses don't take over, and resting 0.3 s on one hands over; closing the menu, however it closes, clears which submenus were open, so it reopens with none (`menu_aim_tests`, 10 tests; timings tuned by feel, not measured against Figma). Menu and palette items that need a value ask for it first: Create link, Offset path and Move to page in a dialog of the shared controls, the language, user name, server and nudge items in Preferences, Open recent on the home screen's Recents; File ▸ Rename edits the file name in place |
+| Keyboard shortcuts panel | done | closes when the home screen shows (#548); docked, tabbed by group like the documentation, searchable, per-platform keycaps; held keys, gestures and presentation keys listed beside the bindings; a label too long for its column ends with "…" and shows in full on hover |
 | Several windows | partial | File ▸ New window, Open in new window on a tab, a tab dragged off the strip; screen-reader tree in the main window only; positions not restored |
 | Multiplayer avatars, Share button | missing | waits for multiplayer |
 | Colour names in hex fields | done | every hex field (fills, strokes, text ranges, effects, layout grids, colour variables, page and prototype backgrounds, the colour picker's Hex) takes a CSS colour name as well: `red` becomes `FF0000`; case, spaces and hyphens are ignored (`Light Blue`); names are opaque and keep the colour's opacity; hex wins where both could match. The picker's CSS field takes every CSS name too (`Color::from_hex_or_name`, `color::named`) |
-| Fields select their text on focus | done | a click or Tab into a one-line field selects all of its text, so typing replaces the value: hex and colour fields, number fields, inline fields (a fill's hex, variable values, renames), names, search boxes and dialog fields; a drag from the press selects only what it covers; multi-line fields (descriptions, comments) keep the caret where clicked. The first click into an inline field (a fill's hex) now takes the keyboard; it took a second click (`widgets::select_all_on_focus`, `select_all_tests`) |
+| Fields select their text on focus | done | a click or Tab into a one-line field selects all of its text, so typing replaces the value: hex and colour fields, number fields, inline fields (a fill's hex, variable values, renames), names, search boxes and dialog fields; a drag from the press selects only what it covers; multi-line fields (descriptions, comments) keep the caret where clicked. The first click into an inline field (a fill's hex) now takes the keyboard; it took a second click. A rename (double-click, F2, File ▸ Rename, a page) selects the whole name before its field first draws, so a key typed in that same frame replaces the name; it was appended (`widgets::select_all_on_focus`, `select_all_tests`, `layers_rename_tests`) |
+| Colour picker on a new fill or stroke | done | + opens the picker on the new paint when the selection shares one paint list; on a mixed selection + adds a paint to each layer and no picker opens (#404) |
 | Blend mode menus: the layer's (Design panel) and each paint's (colour picker) | done | Pass through and Normal are distinct (Normal isolates a group's or frame's children); paints have no pass-through; plus darker drawn exactly on the canvas |
 
 ## Layers and Assets panels
@@ -40,15 +41,15 @@ interaction feel not yet compared.
 | Eye and padlock: click, or drag across rows to set several in one step; layers in a locked frame show a faint padlock | done | the toggles no longer vanish under the pointer (clicks on them could miss) |
 | Rename: double click, F2 / Cmd+R, Tab to the next row; several layers open Rename layers (match, regular expressions, current name and number codes, start value, preview) | done | numbered in stacking order, pinned |
 | Find layers (filter by name) | done | not covered by the documentation |
-| Pages: add, rename, drag to reorder, duplicate ("Copy of"), delete, dividers (a blank page named with a hyphen) | done | |
-| Assets panel: folders from page, frames and slash names (fold away), search, thumbnails, drag onto the canvas or into frames and auto layout, Alt-drop swap, enabled libraries | done | |
+| Pages: add, rename, drag to reorder, duplicate ("Copy of"), delete, dividers (a blank page named with a hyphen) | done | the line between Pages and Layers drags to size the pages list, kept in the preferences; a long list scrolls in its own area and a page dropped outside the visible list stays put (#272) (`layers_behaviour_tests`) |
+| Assets panel: folders from page, frames and slash names (fold away), search, thumbnails, drag onto the canvas or into frames and auto layout, Alt-drop swap, enabled libraries | done | Shift+I (Quick insert) and the toolbar's Resources open it (they didn't, #710) |
 | Hide when publishing from the Assets panel's context menu | done | a right-click on one of this file's components (also Libraries ▸ Hide when publishing for the selection, `component.hideWhenPublishing {ids?, on?}`): the model's sign of it is the name, so hiding puts a `.` before the name and showing takes the leading `.` and `_` away (one undo step, saved and synced like a rename; a variant or a layer inside hides its whole component or set); a hidden component shows a crossed eye on its tile and a dimmer name, the menu item its check mark; the next publish leaves it out and brings it back when shown again (`hide_publishing_tests`). Library components (read-only here) have no such menu |
 
 ## Selection and transform
 
 | Item | Status | Notes |
 |---|---|---|
-| Click, Shift-click, marquee, Shift-marquee toggle | done | a marquee selects what it touches; from a top-level frame's background, the layers inside it; locked and hidden layers are skipped (`selection_behaviour_tests`) |
+| Click, Shift-click, marquee, Shift-marquee toggle | done | Shift-drag on a selected layer moves the selection, kept to one axis (#498); a marquee selects what it touches; from a top-level frame's background, the layers inside it; locked and hidden layers are skipped (`selection_behaviour_tests`) |
 | Deep select (Cmd/Ctrl-click, Cmd/Ctrl-marquee) | done | |
 | Select layer menu (every layer under the click) | done | |
 | Enter / Shift+Enter (children / parent), Tab / Shift+Tab (siblings) | done | Tab renames the next layer while renaming |
@@ -63,11 +64,13 @@ interaction feel not yet compared.
 | Nudge 1 / Shift 10 (preference), Cmd+arrows resize | done | arrows reorder auto layout children |
 | Smart guides: edges, centres, equal spacing (between two layers or continuing a row's gap, labelled), spacing labels, parent, layout grid, ruler guides | done | red, `snap.rs`; thresholds not yet compared with Figma's |
 | Ctrl to suspend snapping while dragging (macOS) | done | Control on macOS (Cmd keeps working), Ctrl elsewhere; moving, resizing and drawing |
-| Measure (Alt hover, Cmd+Alt nested, Shift+Alt padding/gaps) | done | labels never overlap |
+| Measure (Alt hover, Cmd+Alt nested, Shift+Alt padding/gaps) | done | labels never overlap; the arrows still nudge while measuring (Shift: the big step) and the distances follow; the selection's handles and size label hide while measuring (`measure_nudge_tests`, #894) |
 | Pixel grid snapping, pixel preview, 2x preview | done | moves, resizes and new shapes land on whole pixels; the pixel grid shows from 400% (`view_behaviour_tests`) |
 | Numeric fields: arithmetic, scrubbing by dragging the label, mixed values | done | Numeric panels use `widgets::number_field`; Typography line height, letter spacing and paragraph spacing share its leading-icon scrub logic (#373), retaining their existing unit parsing, Auto/Mixed values, variable chips and selected-character targeting (`typography_scrub_tests`). Scrubbing the label: a step a point (1 px; 1% of opacity, 1° of rotation), ten with Shift, a tenth with Alt, each stretch at the rate held while it was dragged, one undo step when let go; past the edge of the screen it goes on where the platform reports the mouse's own motion (desktop), otherwise it stops there. Arrow keys: Up/Down step a pixel field by the small nudge and Shift by the big nudge (the preferences), other fields by their own step and ten of it; they work while typing (from what is typed) and with the keyboard on the field. Typing: `+ - * /`, brackets, units (`px`, `°`, `%`, `x`, `ms`), a decimal comma; `+10`, `*2`, `/4` are relative to the value, and `50%`, `+10%`, `-10%` too in a field that isn't a percentage. Enter, Tab or a click elsewhere commits (Tab and Shift+Tab move to the next and previous control), Escape restores; a field left as it was commits nothing (no undo step, and a rounded display isn't written back). Mixed values show "Mixed": a number sets them all, a relative edit or an arrow key goes to each layer from its own value in one undo step, for X, Y, W, H, rotation, opacity, corner radius and stroke weight (elsewhere `+10` on Mixed sets 10 and `*2` does nothing) (`field_tests`). Left: scrubbing a Mixed field (nothing happens), `x2`-style suffix edits, the pointer isn't wrapped to the other side of the screen; rates not compared with Figma's |
 | Transform box at small sizes | done | a press inside a layer smaller than its handles moves it, the nearest handle wins, handles answer just outside and are hidden under 16 px on screen; cursors follow each handle and the box's rotation |
 | Locked layers | done | selectable from the layers panel; no handles, not dragged with the rest of a selection |
+| Smart selection spacing | partial | with layers in a row, a column or an aligned grid selected, the Layout section shows horizontal and vertical spacing ("Mixed" until set; typed, scrubbed, fractional and negative) and pink handles in the gaps on the canvas drag them, one undo step, Escape cancels (`arrange.spacing`; sizes, parents and offsets within each track kept; at most 2,000 layers; flow children, locked layers and layers inside instances left out). No reorder rings for swapping layers; checked by its author on macOS and in the app on Windows (#402) |
+| Selection colors | partial | for a mixed selection the Design panel lists their solid and gradient paints (children and text ranges included; hidden paints, masks, images, patterns and boolean operands left out; styles and variables listed apart): editing a colour changes every matching fill and stroke in one undo step, a row selects the layers that use it or applies a colour style of the document (`selection.colors`, `selection.setPaint`, `selection.applyColorStyle`, `selection.selectColor`). No library styles or variable binding from there (#403) |
 | Keyboard box selection | done | Alt+Space on macOS, Ctrl+Space on Windows and Linux, or F8 (`select.area`): a box around the selection or in the middle of the view; arrows move it, Cmd/Ctrl+arrows or Shift+arrows size it (Shift with Cmd/Ctrl: farther), Enter selects like a marquee (Shift+Enter toggles, Cmd/Ctrl+Enter nested), Escape closes |
 
 ## Tools
@@ -78,11 +81,11 @@ interaction feel not yet compared.
 | Frame (presets panel, swap orientation), section, slice | done | |
 | Rectangle, ellipse (arc handles and Design panel arc fields), polygon, star, line, arrow; Shift/Alt | done | Alt draws lines from the centre too (`shapes_behaviour_tests`) |
 | Corner radius handles (inside each corner of a rectangle or frame, a polygon's or star's top point; Alt: one corner), star ratio handle; Count and Ratio fields | done | handles hide under 48 px on screen; no count handle on the canvas (the Count field instead); corner smoothing rounds rectangles and frames only |
-| Pen: vector networks, branch, close, bend; pencil | done | pen pressure on Windows and from browser styluses only; outside edit mode the Pen closes on its first point, connects to its other points and continues a selected open path from an end point (`vector_multi_behaviour_tests`) |
-| Vector edit mode: bend, paint bucket, lasso, cut, eraser, transform box, point snapping, mirroring | done | paint bucket drags across areas; cut drags divide a shape into layers; delete and heal follows the curve; rounded points are drawn; Shift-click deselects a point at a corner of the box (`vector_behaviour_tests`); several vectors edited at once, Shift-click handles to drag them together, a cap and join per point, rounded points beside curves (`vector_multi_behaviour_tests`); filled regions with the Move tool: the area under the pointer is hatched ("/" lines in the selection colour, clipped by the area's own fill rule, holes left out, gone 3.5 px from a point or 2 px from a segment at any zoom), the line spacing follows octave folding (fitted to measurements at several zoom levels: 8 px at every power-of-two zoom, growing with the zoom and stepping back at √2 · 2ⁿ) and stays fixed to the shape when panning; a click selects the area and its points (moved with it but drawn unselected), Shift adds or removes an area, a press on a selected area drags the whole selection, no hover hatch during drags, a click on an empty spot (a hole) clears it and stays in edit mode; `vector.edit.select {regions}` (`regions_tests`, `vector_regions_tests`). Not yet: the transform box around points of several layers; areas of other layers edited at once |
+| Pen: vector networks, branch, close, bend; pencil | done | pen pressure on Windows and from browser styluses only; outside edit mode the Pen closes on its first point, connects to its other points and continues a selected open path from an end point (`vector_multi_behaviour_tests`); Escape or Enter ends the path and keeps its layer in edit mode with the pen, so the next path joins the same vector and another Escape leaves edit mode (#760, `pen_end_tests`); switching from Design to Prototype or Inspect ends the path and returns to Move (#308) |
+| Vector edit mode: bend, paint bucket, lasso, cut, eraser, transform box, point snapping, mirroring | done | a double-click a few pixels off a thin stroke enters edit mode (#646); entering edit mode and picking a region keep the canvas still (#322); a point dropped on another point merges with it, and dropping one end of an open path on the other closes it (a 2-point line's end just moves, #401); Flatten keeps open paths open (#377); paint bucket drags across areas; cut drags divide a shape into layers; delete and heal follows the curve; rounded points are drawn; Shift-click deselects a point at a corner of the box (`vector_behaviour_tests`); several vectors edited at once, Shift-click handles to drag them together, a cap and join per point, rounded points beside curves (`vector_multi_behaviour_tests`); filled regions with the Move tool: the area under the pointer is hatched ("/" lines in the selection colour, clipped by the area's own fill rule, holes left out, gone 3.5 px from a point or 2 px from a segment at any zoom), the line spacing follows octave folding (fitted to measurements at several zoom levels: 8 px at every power-of-two zoom, growing with the zoom and stepping back at √2 · 2ⁿ) and stays fixed to the shape when panning; a click selects the area and its points (moved with it but drawn unselected), Shift adds or removes an area, a press on a selected area drags the whole selection, no hover hatch during drags, a click on an empty spot (a hole) clears it and stays in edit mode; `vector.edit.select {regions}` (`regions_tests`, `vector_regions_tests`). Not yet: the transform box around points of several layers; areas of other layers edited at once |
 | Shape builder (Shift+M) on fills, strokes and open paths; variable width (Shift+W), one side with Alt | done | |
 | Boolean groups: clicked where the result is, double-click or Cmd/Ctrl-click into operands, live results while dragging or editing points, per-operand operations | done | |
-| Text: point, auto height, fixed; caret, words, lines, IME | done | carets step over whole emoji and accented letters; CJK words by script run (no dictionary); vertical trim in Type settings; no spell check |
+| Text: point, auto height, fixed; caret, words, lines, IME | done | the font picker previews a family on the canvas while hovered (no undo step; Escape restores, #653) and Up/Down step through it (#352); a selection highlight after a line break starts at that line's start and an empty last line shows its mark (#665); carets step over whole emoji and accented letters; colour emoji draw from their colour tables (#300); IME composition replayed in tests as macOS sends it, not yet checked on a Mac (#747); CJK words by script run (no dictionary); vertical trim in Type settings; no spell check |
 | Eyedropper (I) | done | picks the colour seen under the pointer (opaque) into the selection's fill and the recent colours, one undo step (`fx_behaviour_tests`) |
 | Comment (C), Shift+C to show/hide | done | local only |
 | Text on a path (Figma Draw) | done | put on from the Design panel or `text.onPath`, not by clicking a path with the Text tool; the path is edited by resizing only |
@@ -126,7 +129,7 @@ in the table. `crates/ui-egui/src/shortcut_keys_tests.rs` drives the keys a look
 | Bound on other keys (documented conflict) | 1 | Run last plugin: the documentation also gives Ctrl+Alt+P to pixel preview on Windows; the plugin takes Ctrl+Alt+Shift+P there |
 | Missing | 0 | moving the rotation origin (Alt+R, `transform.rotationOrigin`) and placing an object with Enter after choosing its tool (`tool.place`) were the last two |
 | Documented keys a platform keeps | 2 | Ctrl+Space (Windows/Linux keyboard box selection) switches some CJK input methods; F6 goes to a browser's address bar in the web build |
-| Undocumented bindings pinned | 49 | of which Cmd/Ctrl+W, Cmd/Ctrl+N and Ctrl+Tab are taken by browsers (web build) and Ctrl+Alt+T / Ctrl+Alt+L by some Linux desktops |
+| Undocumented bindings pinned | 57 | of which Cmd/Ctrl+W, Cmd/Ctrl+N and Ctrl+Tab are taken by browsers (web build) and Ctrl+Alt+T / Ctrl+Alt+L by some Linux desktops |
 
 - **Newly bound:** A for the Frame tool, Shift+' for the pixel grid (Cmd+' kept: the articles
   disagree), Alt+Cmd+\ / Ctrl+Alt+\ for others' cursors (`view.multiplayerCursors`, new), Ctrl+F6
@@ -137,6 +140,9 @@ in the table. `crates/ui-egui/src/shortcut_keys_tests.rs` drives the keys a look
   Ctrl+Alt+Shift+K to go to the main component, the arrows panning the view when nothing is
   selected (`view.pan`, new), Control suspending snapping on macOS, and Space, N, C and F while
   presenting. The paint bucket's tooltip shows Shift+B (B still works).
+- **Fixed (2026-10-17):** Shift+Cmd/Ctrl+V (Paste over selection) and Alt+Cmd/Ctrl+V (Paste
+  properties) work on the desktop (they were bound but didn't act there, #716); Cmd/Ctrl+V pastes an
+  image copied in another app (#663). Counts above unchanged (the suite checks bindings).
 - **Where the documentation disagrees with itself** (noted per row): pixel grid (Shift+' or
   Cmd+'), letter spacing (Alt or Cmd with < >; Cmd would be the font size keys, Alt bound),
   Windows remove fill (Alt+/ or Alt+,; Alt+, is letter spacing), the Layers panel on Windows (Alt+1
@@ -159,13 +165,22 @@ in the table. `crates/ui-egui/src/shortcut_keys_tests.rs` drives the keys a look
 | Keyboard navigation: F6 regions, Tab within, focus ring | done | |
 | Layers panel from the keyboard: arrows, F2 / Cmd+R rename (the row gets the keyboard back), Shift+F10 context menu; 10k-layer lists | done | revealing a layer, expanding, collapsing and arrow keys timed in `cargo xtask bench` |
 | Reduced motion | done | system setting or preference |
-| WCAG AA contrast of secondary and accent text | done | |
+| WCAG AA contrast of secondary and accent text | done | disabled and dim text at least 3:1 against panels, fields and selected rows, selected text at least 3:1 on its highlight, in both themes (`theme::tests`, #890) |
 | Tested with VoiceOver, NVDA, Narrator, Orca | missing | human QA |
 
 ## Revision history
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-24 | minor | Boards (M12): eight board bindings pinned (tool keys Q sticky, B shapes, X connector, M marker, U highlighter, E eraser, W stamp, and Shift+Cmd/Ctrl+Enter for the next sticky; boards only, on keys no design-file shortcut uses): 49 → 57 pinned |
+| 2026-10-15 | minor | Community fixes (#262, #272, #277, #300, #308, #311, #322, #352, #363, #372, #390): first runs follow the system theme; new text is readable on the frame it is drawn in; a long pages list scrolls on its own and new pages take the current page's colour; the pen shows its handles while dragging a point out and ends its path when you leave Design; vector edit mode keeps the canvas still; a drag with the Text tool makes a fixed-size box; colour emoji; the selection highlight on the last line; Up and Down in the font picker with a live preview. Numbers unchanged |
+| 2026-10-22 | minor | Vector edit mode: points selected in several layers get the transform box, in the page's axes since the layers can be turned differently; its corners and edges scale them, outside a corner rotates them and inside drags them, each layer's points in its own coordinates and one undo step for all, and a click inside clears every layer's points (`transform_tests`). Numbers unchanged |
+| 2026-10-20 | minor | Readable disabled and selected text (#890): the dim text colour (disabled buttons, placeholders, hints) is at least 3:1 against panels, fields and selected rows in both themes (it was 2.1:1 in the light theme), a disabled button is grey with that text instead of fading to 40%, and selected text (renaming a page or layer, any text box) takes the theme's readable green on the highlight (1.4:1 in the dark theme before, now 4.2:1 or more); checked with the colour contrast helper (`theme::tests`). Numbers unchanged |
+| 2026-10-20 | minor | Measuring while nudging (#894): with Alt held over another layer, the arrows nudge the selection (Shift: the big step) and the distances follow every nudge (Alt+arrows used to do nothing); while measuring, the selection's handles and size label hide and both layers keep their outlines (`measure_nudge_tests`). Numbers unchanged |
+| 2026-10-18 | minor | A rename (layers double-click, F2, File ▸ Rename, a page) selects the whole name in the frame its field first draws, so the first key replaces the name instead of being appended. Checked in the app on Windows over the control channel |
+| 2026-10-17 | minor | Escape or Enter while the pen draws ends the path and keeps its vector in edit mode with the pen, so the next path is drawn into the same layer (unconnected); another Escape leaves edit mode (#760). Entering edit mode on a layer that already is a vector no longer records an empty undo step. Numbers unchanged |
+| 2026-10-17 | minor | Text layers keep the platform IME on for every frame of an edit, not only frames with input (an idle frame turned it off and macOS dropped each composition, #747); the candidate window opens at the caret instead of the canvas corner; keys pressed while composing go to the IME |
+| 2026-10-17 | minor | The community batches #733, #735, #736, #729 and #753: submenus open after a short hover, keep their place along a safe triangle and reopen closed (main and context menus); the Actions palette's tabs, ranked search, keyboard highlight and recents; menu items that need a value ask for it, File ▸ Rename edits in place; Shift+I and Resources open Assets; a draggable Pages/Layers divider; Shift-drag moves the selection; a double-click near a thin stroke, merging dropped points and Flatten keeping open paths in vector editing; live font preview and the selection highlight after line breaks; the colour picker on a new fill or stroke; Paste over and Paste properties from the keyboard; Selection colors (partial: no library styles or variables there) and smart-selection spacing fields and canvas handles (partial: no reorder rings), both also checked by their author on macOS; the keyboard shortcuts panel closes on the home screen; Adwaita window controls on Wayland compositors without server decorations (checked by its author on GNOME; KDE not run). Checked in the app on Windows (submenus by their author), not side by side with Figma. Summary and hours unchanged |
 | 2026-10-15 | minor | Hex fields take CSS colour names (`red` → `FF0000`): fills, strokes, effects, grids, variables, backgrounds and the colour picker |
 | 2026-10-15 | minor | Typography: drag the line-height, letter-spacing and paragraph-spacing icons to scrub their values; shared numeric-field rates, resize cursor and one Undo step per gesture (#373). |
 | 2026-10-15 | minor | A click or Tab into a one-line field selects all of its text (hex, inline, name, search and dialog fields); the first click into a fill's hex takes the keyboard |
diff --git a/packaging/check-app-specific.sh b/packaging/check-app-specific.sh
new file mode 100644
index 000000000..e9b039462
--- /dev/null
+++ b/packaging/check-app-specific.sh
@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+# App-specific checks retained alongside shared packaging lint.
+set -euo pipefail
+cd "$(dirname "${BASH_SOURCE[0]}")/.."
+
+bash packaging/server/install-test.sh
+if grep -rniE 'photoshop|psd|photocraft|vectorcraft|illustrator|adobe|figma' packaging/ .github/ \
+    --exclude=packaging-lint.yml --exclude=check-app-specific.sh; then
+  echo "::error::package metadata mentions another product (see above)" >&2
+  exit 1
+fi
+
+python3 - <<'PYEOF'
+import yaml
+manifests = []
+for name in ("ai.storyteller.figcraft.yml", "ai.storyteller.figcraft.bundle.yml"):
+    with open("packaging/linux/flatpak/" + name) as source:
+        manifest = yaml.safe_load(source)
+    assert manifest["id"] == "ai.storyteller.figcraft" and manifest["command"] == "figcraft", name
+    manifests.append(manifest)
+for key in ("runtime", "runtime-version", "sdk", "finish-args"):
+    assert manifests[0][key] == manifests[1][key], f"Flatpak manifests disagree on {key}"
+print("FigCraft package identity ok")
+PYEOF
diff --git a/packaging/env.sh b/packaging/env.sh
index b68406a01..eb6547c9e 100644
--- a/packaging/env.sh
+++ b/packaging/env.sh
@@ -24,10 +24,11 @@ workspace_version() {
     /^\[/ { in_pkg = ($0 == "[workspace.package]") ; next }
     in_pkg && $1 == "version" { gsub(/[" ]/, "", $3); print $3; exit }
   ' "$ROOT/Cargo.toml"
+  return $?
 }
 
 VERSION="${FIGCRAFT_VERSION:-$(workspace_version)}"
-if [ -z "$VERSION" ]; then
+if [[ -z "$VERSION" ]]; then
   echo "error: could not read [workspace.package] version from $ROOT/Cargo.toml" >&2
   exit 1
 fi
@@ -37,7 +38,7 @@ DIST="${DIST:-$ROOT/dist/release}"
 mkdir -p "$DIST"
 export DIST
 
-if [ -z "${FIGCRAFT_BUILD_SHA:-}" ]; then
+if [[ -z "${FIGCRAFT_BUILD_SHA:-}" ]]; then
   FIGCRAFT_BUILD_SHA="$(git -C "$ROOT" rev-parse HEAD 2>/dev/null || true)"
 fi
 export FIGCRAFT_BUILD_SHA
@@ -47,7 +48,7 @@ export CARGO_TARGET_DIR="${CARGO_TARGET_DIR:-$ROOT/target}"
 # The headless CLI ships next to the app once apps/figcraft-cli exists.
 BINS=(figcraft)
 HAS_CLI=0
-if [ -f "$ROOT/apps/figcraft-cli/Cargo.toml" ]; then
+if [[ -f "$ROOT/apps/figcraft-cli/Cargo.toml" ]]; then
   BINS+=(figcraft-cli)
   HAS_CLI=1
 fi
@@ -58,7 +59,8 @@ unset _bin
 # The binary used for a `--version` smoke test: the CLI when shipped, else the app (which answers
 # --version before opening a window).
 smoke_bin() {
-  if [ "$HAS_CLI" = 1 ]; then echo figcraft-cli; else echo figcraft; fi
+  if [[ "$HAS_CLI" = 1 ]]; then echo figcraft-cli; else echo figcraft; fi
+  return 0
 }
 
 # Emit a GitHub Actions warning (plain stderr outside Actions).
@@ -68,31 +70,33 @@ retry() {
   local attempt
   for attempt in 1 2 3 4 5; do
     "$@" && return 0
-    [ "$attempt" = 5 ] || { echo "retrying ($attempt/5): $*" >&2; sleep 15; }
+    [[ "$attempt" = 5 ]] || { echo "retrying ($attempt/5): $*" >&2; sleep 15; }
   done
   return 1
 }
 
 warn() {
-  if [ -n "${GITHUB_ACTIONS:-}" ]; then echo "::warning::$*"; else echo "warning: $*" >&2; fi
+  if [[ -n "${GITHUB_ACTIONS:-}" ]]; then echo "::warning::$*"; else echo "warning: $*" >&2; fi
+  return 0
 }
 
 # Copy licence and readme files that exist into a package directory.
 copy_docs() {
   local dest="$1" f
   for f in README.md LICENSE LICENSE-MIT LICENSE-APACHE NOTICE COPYRIGHT; do
-    if [ -f "$ROOT/$f" ]; then cp "$ROOT/$f" "$dest/"; fi
+    if [[ -f "$ROOT/$f" ]]; then cp "$ROOT/$f" "$dest/"; fi
   done
   copy_font_licences "$dest"
+  return $?
 }
 
 # Builds made with craft-fonts (CRAFT_FONTS_DIR, all official releases) embed its fonts, which
 # are OFL-1.1: ship each font's licence as OFL-<family-dir>.txt. No-op without CRAFT_FONTS_DIR.
 copy_font_licences() {
   local dest="$1" lic fam
-  [ -n "${CRAFT_FONTS_DIR:-}" ] || return 0
+  [[ -n "${CRAFT_FONTS_DIR:-}" ]] || return 0
   for lic in "$CRAFT_FONTS_DIR"/fonts/*/OFL.txt; do
-    [ -f "$lic" ] || continue
+    [[ -f "$lic" ]] || continue
     fam="$(basename "$(dirname "$lic")")"
     cp "$lic" "$dest/OFL-$fam.txt"
   done
@@ -100,5 +104,7 @@ copy_font_licences() {
 
 # Portable SHA-256 of a file (prints just the hash).
 sha256() {
-  if command -v sha256sum >/dev/null; then sha256sum "$1" | cut -d' ' -f1; else shasum -a 256 "$1" | cut -d' ' -f1; fi
+  local file="$1"
+  if command -v sha256sum >/dev/null; then sha256sum "$file" | cut -d' ' -f1; else shasum -a 256 "$file" | cut -d' ' -f1; fi
+  return $?
 }
diff --git a/packaging/freebsd/package.sh b/packaging/freebsd/package.sh
index bb9a77994..9ee0394bd 100755
--- a/packaging/freebsd/package.sh
+++ b/packaging/freebsd/package.sh
@@ -21,7 +21,7 @@ APP_ID=ai.storyteller.figcraft
 
 SKIP_BUILD=0
 DRY_RUN=0
-while [ $# -gt 0 ]; do
+while [[ $# -gt 0 ]]; do
   case "$1" in
     --skip-build) SKIP_BUILD=1; shift ;;
     --dry-run) DRY_RUN=1; SKIP_BUILD=1; shift ;;
@@ -31,13 +31,29 @@ while [ $# -gt 0 ]; do
 done
 
 # FreeBSD's uname says amd64; release file names use x86_64 like the Linux and Windows ones.
-MACHINE="$(uname -m)"
-case "$MACHINE" in
-  amd64 | x86_64) ARCH=x86_64 ;;
-  arm64 | aarch64) ARCH=aarch64 ;;
-  *) echo "unsupported architecture $MACHINE" >&2; exit 2 ;;
+release_arch() {
+  local arch="$1"
+  case "$arch" in
+    amd64 | x86_64) echo x86_64 ;;
+    arm64 | aarch64) echo aarch64 ;;
+    *) echo "unsupported architecture $arch" >&2; return 2 ;;
+  esac
+  return
+}
+# The release workflow cross-compiles aarch64 in an x86_64 VM with CARGO_BUILD_TARGET set to
+# aarch64-unknown-freebsd (craft-common-actions#39): name the archive after the target.
+case "${CARGO_BUILD_TARGET:-}" in
+  "") ARCH="$(release_arch "$(uname -m)")" ;;
+  aarch64-unknown-freebsd | x86_64-unknown-freebsd) ARCH="$(release_arch "${CARGO_BUILD_TARGET%%-*}")" ;;
+  *) echo "CARGO_BUILD_TARGET=$CARGO_BUILD_TARGET is not a supported FreeBSD target" >&2; exit 2 ;;
 esac
-if [ "$DRY_RUN" = 0 ] && [ "$(uname -s)" != FreeBSD ]; then
+# Only binaries for this machine run here (the --version check at the end); a FreeBSD target built
+# on another OS never does.
+HOST_ARCH="$(release_arch "$(uname -m)" 2>/dev/null)" || HOST_ARCH="$(uname -m)"
+if [[ -n "${CARGO_BUILD_TARGET:-}" ]] && [[ "$(uname -s)" != FreeBSD ]]; then
+  HOST_ARCH="$(uname -s) $HOST_ARCH"
+fi
+if [[ "$DRY_RUN" = 0 ]] && [[ "$(uname -s)" != FreeBSD ]]; then
   echo "error: build on FreeBSD (or pass --dry-run to check the tree layout)" >&2
   exit 2
 fi
@@ -47,7 +63,7 @@ echo "==> FigCraft $VERSION for FreeBSD $ARCH"
 
 # The release VM has 12 GB; full parallelism on the biggest crates runs it out of memory.
 export CARGO_BUILD_JOBS="${CARGO_BUILD_JOBS:-4}"
-if [ "$SKIP_BUILD" = 0 ]; then
+if [[ "$SKIP_BUILD" = 0 ]]; then
   (cd "$ROOT" && cargo build --release --locked "${CARGO_PKGS[@]}")
 fi
 WORK="$CARGO_TARGET_DIR/freebsd-package"
@@ -55,9 +71,10 @@ STAGE="$WORK/$BASENAME"
 rm -rf "$WORK"
 mkdir -p "$WORK"
 
-BIN="$CARGO_TARGET_DIR/release"
+# Cargo puts a cross build under target/<triple>/release.
+BIN="$CARGO_TARGET_DIR/${CARGO_BUILD_TARGET:+$CARGO_BUILD_TARGET/}release"
 OUT_DIR="$DIST"
-if [ "$DRY_RUN" = 1 ]; then
+if [[ "$DRY_RUN" = 1 ]]; then
   # Stub binaries, and the tarball stays in the work dir so dist/ only ever holds real builds.
   BIN="$WORK/stub-bin"
   OUT_DIR="$WORK"
@@ -86,12 +103,12 @@ sed -e "s/@VERSION@/$VERSION/g" -e "s/@DATE@/$FIGCRAFT_BUILD_DATE/g" \
   "$LINUX/$APP_ID.metainfo.xml.in" >"$STAGE/share/metainfo/$APP_ID.metainfo.xml"
 cp -R "$ROOT/assets/app-icon/hicolor" "$STAGE/share/icons/"
 copy_docs "$STAGE/share/doc/figcraft"
-if [ -f "$ROOT/ATTRIBUTION.md" ]; then install -m 644 "$ROOT/ATTRIBUTION.md" "$STAGE/share/doc/figcraft/"; fi
+if [[ -f "$ROOT/ATTRIBUTION.md" ]]; then install -m 644 "$ROOT/ATTRIBUTION.md" "$STAGE/share/doc/figcraft/"; fi
 
 for f in "${BINS[@]/#/bin/}" "share/applications/$APP_ID.desktop" \
   "share/icons/hicolor/256x256/apps/$APP_ID.png" \
   share/doc/figcraft/LICENSE-MIT share/doc/figcraft/LICENSE-APACHE; do
-  if [ ! -e "$STAGE/$f" ]; then echo "error: $f is missing from the package" >&2; exit 1; fi
+  if [[ ! -e "$STAGE/$f" ]]; then echo "error: $f is missing from the package" >&2; exit 1; fi
 done
 
 # ---- .tar.gz ------------------------------------------------------------------------------------
@@ -99,8 +116,21 @@ mkdir -p "$OUT_DIR"
 tar -C "$WORK" -czf "$OUT_DIR/$BASENAME.tar.gz" "$BASENAME"
 echo "wrote $OUT_DIR/$BASENAME.tar.gz"
 
-"$STAGE/bin/$(smoke_bin)" --version
-if [ "$DRY_RUN" = 1 ]; then
+if [[ "$DRY_RUN" = 1 ]] || [[ "$ARCH" = "$HOST_ARCH" ]]; then
+  "$STAGE/bin/$(smoke_bin)" --version
+else
+  # They cannot run here, so check what they are instead: executables, not libraries or objects.
+  # An older file(1) calls a PIE a shared object; its interpreter still marks it as a program.
+  want="$ARCH"; [[ "$ARCH" != x86_64 ]] || want=x86-64
+  for b in "$STAGE"/bin/*; do
+    case "$(file -b "$b")" in
+      ELF*" executable, "*"$want"*FreeBSD* | ELF*"$want"*FreeBSD*interpreter*) ;;
+      *) echo "error: $b is not a FreeBSD $ARCH executable: $(file -b "$b")" >&2; exit 1 ;;
+    esac
+  done
+  echo "skipping --version: an $ARCH binary does not run on this $HOST_ARCH machine"
+fi
+if [[ "$DRY_RUN" = 1 ]]; then
   echo "==> dry run: tarball contents"
   tar -tzvf "$OUT_DIR/$BASENAME.tar.gz"
 fi
diff --git a/packaging/linux/apprun-test.sh b/packaging/linux/apprun-test.sh
index c6d98da0d..75625480b 100755
--- a/packaging/linux/apprun-test.sh
+++ b/packaging/linux/apprun-test.sh
@@ -37,10 +37,10 @@ fail() {
 
 # 1. Launch works and passes arguments through.
 out="$("$APPDIR/AppRun" open file.png)" || fail "AppRun exited non-zero"
-[ "$out" = "stub: open file.png" ] || fail "arguments not forwarded: $out"
+[[ "$out" = "stub: open file.png" ]] || fail "arguments not forwarded: $out"
 
 DESKTOP="$XDG_DATA_HOME/applications/$APP_ID.desktop"
-[ -f "$DESKTOP" ] || fail "desktop entry not installed"
+[[ -f "$DESKTOP" ]] || fail "desktop entry not installed"
 
 # 2. Exec rewritten to the AppImage (quoted, spaces intact), TryExec dropped,
 #    everything else preserved from the packaged entry.
@@ -55,15 +55,15 @@ fi
 
 # 3. Icons landed under the name the .desktop entry references.
 for f in "16x16/apps/$APP_ID.png" "256x256/apps/$APP_ID.png" "scalable/apps/$APP_ID.svg"; do
-  [ -f "$XDG_DATA_HOME/icons/hicolor/$f" ] || fail "icon missing: $f"
+  [[ -f "$XDG_DATA_HOME/icons/hicolor/$f" ]] || fail "icon missing: $f"
 done
 
 # 4. Idempotent: a second launch must not rewrite anything (inode unchanged).
 before="$(stat -c %i "$DESKTOP")"
 out="$("$APPDIR/AppRun")" || fail "second launch exited non-zero"
-[ "$out" = "stub: " ] || fail "second launch output: $out"
+[[ "$out" = "stub: " ]] || fail "second launch output: $out"
 after="$(stat -c %i "$DESKTOP")"
-[ "$before" = "$after" ] || fail "desktop entry rewritten although unchanged"
+[[ "$before" = "$after" ]] || fail "desktop entry rewritten although unchanged"
 
 # 5. Moving the AppImage refreshes Exec.
 mv "$APPIMAGE" "$TMP/moved.AppImage"
@@ -74,40 +74,40 @@ grep -Fxq "Exec=\"$(readlink -f "$APPIMAGE")\" %U" "$DESKTOP" || fail "Exec not
 # 6. Opt-out installs nothing.
 rm -rf "$XDG_DATA_HOME"
 FIGCRAFT_NO_DESKTOP_INTEGRATION=1 "$APPDIR/AppRun" >/dev/null || fail "opt-out launch exited non-zero"
-[ ! -e "$XDG_DATA_HOME" ] || fail "opt-out still integrated"
+[[ ! -e "$XDG_DATA_HOME" ]] || fail "opt-out still integrated"
 
 # 7. An unwritable data dir never blocks the launch.
 mkdir -p "$TMP/ro" && chmod a-w "$TMP/ro"
 out="$(XDG_DATA_HOME="$TMP/ro/data" "$APPDIR/AppRun" out.txt)" || fail "launch blocked by unwritable data dir"
-[ "$out" = "stub: out.txt" ] || fail "stub not run against unwritable data dir: $out"
+[[ "$out" = "stub: out.txt" ]] || fail "stub not run against unwritable data dir: $out"
 chmod u+w "$TMP/ro"
 
 # 8. No $APPIMAGE (extracted AppDir): launch only, nothing installed.
 rm -rf "$XDG_DATA_HOME"
 env -u APPIMAGE "$APPDIR/AppRun" >/dev/null || fail "extracted-AppDir launch exited non-zero"
-[ ! -e "$XDG_DATA_HOME" ] || fail "integrated without $APPIMAGE"
+[[ ! -e "$XDG_DATA_HOME" ]] || fail "integrated without $APPIMAGE"
 
 # 9. A path that would need Exec escaping (here a `$`): launch only, nothing installed.
 rm -rf "$XDG_DATA_HOME"
 odd="$TMP/odd\$(id).AppImage"
 : >"$odd"
 out="$(APPIMAGE="$odd" "$APPDIR/AppRun" x)" || fail "launch with an odd path exited non-zero"
-[ "$out" = "stub: x" ] || fail "odd path: $out"
-[ ! -e "$XDG_DATA_HOME" ] || fail "integrated an AppImage path that needs escaping"
+[[ "$out" = "stub: x" ]] || fail "odd path: $out"
+[[ ! -e "$XDG_DATA_HOME" ]] || fail "integrated an AppImage path that needs escaping"
 
 # 10. `cli <args>` runs figcraft-cli with the remaining arguments and integrates nothing.
 rm -rf "$XDG_DATA_HOME"
 out="$("$APPDIR/AppRun" cli mcp --attach 7979 2>&1)" && fail "cli ran without figcraft-cli in the AppDir"
-[ "$out" = "figcraft: this AppImage was built without figcraft-cli" ] || fail "missing cli: $out"
+[[ "$out" = "figcraft: this AppImage was built without figcraft-cli" ]] || fail "missing cli: $out"
 printf '#!/bin/sh\necho "cli stub: $*"\n' >"$APPDIR/usr/bin/figcraft-cli"
 chmod +x "$APPDIR/usr/bin/figcraft-cli"
 out="$("$APPDIR/AppRun" cli mcp --attach 7979)" || fail "cli launch exited non-zero"
-[ "$out" = "cli stub: mcp --attach 7979" ] || fail "cli arguments not forwarded: $out"
+[[ "$out" = "cli stub: mcp --attach 7979" ]] || fail "cli arguments not forwarded: $out"
 out="$("$APPDIR/AppRun" cli)" || fail "bare cli launch exited non-zero"
-[ "$out" = "cli stub: " ] || fail "bare cli output: $out"
-[ ! -e "$XDG_DATA_HOME" ] || fail "cli launch integrated the desktop"
+[[ "$out" = "cli stub: " ]] || fail "bare cli output: $out"
+[[ ! -e "$XDG_DATA_HOME" ]] || fail "cli launch integrated the desktop"
 # Only the first argument selects the CLI.
 out="$("$APPDIR/AppRun" file.figcraft cli)" || fail "app launch with a later cli argument exited non-zero"
-[ "$out" = "stub: file.figcraft cli" ] || fail "later cli argument hijacked the launch: $out"
+[[ "$out" = "stub: file.figcraft cli" ]] || fail "later cli argument hijacked the launch: $out"
 
 echo "AppRun desktop integration ok"
diff --git a/packaging/linux/flatpak-bundle.sh b/packaging/linux/flatpak-bundle.sh
index 127c3af96..b3353b386 100755
--- a/packaging/linux/flatpak-bundle.sh
+++ b/packaging/linux/flatpak-bundle.sh
@@ -22,7 +22,7 @@ FLATHUB=https://dl.flathub.org/repo/flathub.flatpakrepo
 
 TEST=1
 TARBALL=""
-while [ $# -gt 0 ]; do
+while [[ $# -gt 0 ]]; do
   case "$1" in
     --no-test) TEST=0; shift ;;
     -h | --help) sed -n '2,14p' "$0"; exit 0 ;;
@@ -39,7 +39,7 @@ case "$ARCH" in
 esac
 BASENAME="figcraft-$VERSION-linux-$ARCH"
 TARBALL="${TARBALL:-$DIST/$BASENAME.tar.gz}"
-[ -f "$TARBALL" ] || { echo "error: $TARBALL not found (run packaging/linux/package.sh --formats tar first)" >&2; exit 1; }
+[[ -f "$TARBALL" ]] || { echo "error: $TARBALL not found (run packaging/linux/package.sh --formats tar first)" >&2; exit 1; }
 for tool in flatpak flatpak-builder; do
   command -v "$tool" >/dev/null || { echo "error: $tool not found (apt install flatpak flatpak-builder librsvg2-common)" >&2; exit 1; }
 done
@@ -50,7 +50,7 @@ WORK="$CARGO_TARGET_DIR/flatpak-bundle"
 rm -rf "$WORK"
 mkdir -p "$WORK/stage"
 tar -xzf "$TARBALL" -C "$WORK/stage" --strip-components=1
-[ -x "$WORK/stage/bin/figcraft" ] || { echo "error: $TARBALL has no bin/figcraft" >&2; exit 1; }
+[[ -x "$WORK/stage/bin/figcraft" ]] || { echo "error: $TARBALL has no bin/figcraft" >&2; exit 1; }
 cp "$HERE/flatpak/$APP_ID.bundle.yml" "$WORK/$APP_ID.yml"
 
 flatpak remote-add --user --if-not-exists flathub "$FLATHUB"
@@ -63,10 +63,10 @@ OUT="$DIST/$BASENAME.flatpak"
 flatpak build-bundle --runtime-repo="$FLATHUB" "$WORK/repo" "$OUT" "$APP_ID" stable
 echo "wrote $OUT"
 
-if [ "$TEST" = 1 ]; then
+if [[ "$TEST" = 1 ]]; then
   flatpak install --user -y --noninteractive --reinstall "$OUT"
   flatpak info --user "$APP_ID"
-  if [ -x "$WORK/stage/bin/figcraft-cli" ]; then smoke=figcraft-cli; else smoke=figcraft; fi
+  if [[ -x "$WORK/stage/bin/figcraft-cli" ]]; then smoke=figcraft-cli; else smoke=figcraft; fi
   flatpak run --command="$smoke" "$APP_ID" --version
   flatpak run --command=sh "$APP_ID" -c 'ls /app/share/applications /app/share/metainfo /app/share/mime/packages /app/share/icons/hicolor/256x256/apps'
 fi
diff --git a/packaging/linux/package.sh b/packaging/linux/package.sh
index 20da2f764..a3ea29b13 100755
--- a/packaging/linux/package.sh
+++ b/packaging/linux/package.sh
@@ -27,7 +27,7 @@ APP_ID=ai.storyteller.figcraft
 
 SKIP_BUILD=0
 FORMATS="appimage deb rpm tar"
-while [ $# -gt 0 ]; do
+while [[ $# -gt 0 ]]; do
   case "$1" in
     --skip-build) SKIP_BUILD=1; shift ;;
     --formats) FORMATS="$2"; shift 2 ;;
@@ -48,7 +48,7 @@ BASENAME="figcraft-$VERSION-linux-$ARCH"
 
 echo "==> FigCraft $VERSION for Linux $ARCH ($FORMATS; ${BINS[*]})"
 
-if [ "$SKIP_BUILD" = 0 ]; then
+if [[ "$SKIP_BUILD" = 0 ]]; then
   (cd "$ROOT" && cargo build --release --locked "${CARGO_PKGS[@]}" ${CROSS_TARGET:+--target "$CROSS_TARGET"})
 fi
 BIN="$CARGO_TARGET_DIR/${CROSS_TARGET:+$CROSS_TARGET/}release"
@@ -78,7 +78,7 @@ if command -v appstreamcli >/dev/null; then
   appstreamcli validate --no-net --explain "$STAGE/usr/share/metainfo/$APP_ID.metainfo.xml"
 fi
 
-has() { case " $FORMATS " in *" $1 "*) return 0 ;; *) return 1 ;; esac; }
+has() { local format="$1"; case " $FORMATS " in *" $format "*) return 0 ;; *) return 1 ;; esac; }
 
 # ---- .tar.gz ------------------------------------------------------------------------------------
 if has tar; then
@@ -96,7 +96,7 @@ if has deb || has rpm; then
   # nfpm expands env vars in fields like `version` and `arch`, but not in `contents[].src`.
   # Without the CLI, drop its `#cli` lines.
   cli_filter='/#cli$/d'
-  [ "$HAS_CLI" = 1 ] && cli_filter='s/ #cli$//'
+  [[ "$HAS_CLI" = 1 ]] && cli_filter='s/ #cli$//'
   sed -e "s|\${STAGE}|$STAGE|g" -e "$cli_filter" "$HERE/nfpm.yaml" >"$WORK/nfpm.yaml"
   for fmt in deb rpm; do
     if has "$fmt"; then (cd "$ROOT" && nfpm package -f "$WORK/nfpm.yaml" -p "$fmt" -t "$DIST/$BASENAME.$fmt"); fi
@@ -105,6 +105,23 @@ fi
 
 # ---- AppImage -----------------------------------------------------------------------------------
 if has appimage; then
+  APPIMAGETOOL_VERSION=1.9.1
+  case "$ARCH" in
+    x86_64) APPIMAGETOOL_SHA256=ed4ce84f0d9caff66f50bcca6ff6f35aae54ce8135408b3fa33abfc3cb384eb0 ;;
+    aarch64) APPIMAGETOOL_SHA256=f0837e7448a0c1e4e650a93bb3e85802546e60654ef287576f46c71c126a9158 ;;
+    *) APPIMAGETOOL_SHA256='' ;;
+  esac
+  # appimagetool otherwise fetches the unpinned type2-runtime `continuous` build and embeds it.
+  APPIMAGE_RUNTIME_VERSION=20251108
+  case "$ARCH" in
+    x86_64) APPIMAGE_RUNTIME_SHA256=2fca8b443c92510f1483a883f60061ad09b46b978b2631c807cd873a47ec260d ;;
+    aarch64) APPIMAGE_RUNTIME_SHA256=00cbdfcf917cc6c0ff6d3347d59e0ca1f7f45a6df1a428a0d6d8a78664d87444 ;;
+    *) APPIMAGE_RUNTIME_SHA256='' ;;
+  esac
+  if [[ -z "$APPIMAGE_RUNTIME_SHA256" ]]; then
+    echo "no pinned AppImage runtime for $ARCH; build the AppImage on x86_64 or aarch64" >&2
+    exit 2
+  fi
   APPDIR="$WORK/FigCraft.AppDir"
   cp -R "$STAGE" "$APPDIR"
   mv "$APPDIR/usr/share/doc" "$WORK/doc-unused"
@@ -118,18 +135,37 @@ if has appimage; then
   ln -s "$APP_ID.png" "$APPDIR/.DirIcon"
 
   TOOL="${APPIMAGETOOL:-$(command -v appimagetool || true)}"
-  if [ -z "$TOOL" ]; then
-    TOOL="$CARGO_TARGET_DIR/appimagetool-$ARCH.AppImage"
-    if [ ! -x "$TOOL" ]; then
-      curl -fsSL -o "$TOOL" "https://github.com/AppImage/appimagetool/releases/download/continuous/appimagetool-$ARCH.AppImage"
-      chmod +x "$TOOL"
+  if [[ -z "$TOOL" ]]; then
+    if [[ -z "$APPIMAGETOOL_SHA256" ]]; then
+      echo "no pinned appimagetool for $ARCH; set APPIMAGETOOL or put appimagetool on PATH" >&2
+      exit 2
     fi
+    TOOL="$CARGO_TARGET_DIR/appimagetool-$APPIMAGETOOL_VERSION-$ARCH.AppImage"
+    if [[ ! -x "$TOOL" ]]; then
+      download="$TOOL.download"
+      curl --proto '=https' -fsSL -o "$download" \
+        "https://github.com/AppImage/appimagetool/releases/download/$APPIMAGETOOL_VERSION/appimagetool-$ARCH.AppImage"
+      printf '%s  %s\n' "$APPIMAGETOOL_SHA256" "$download" | sha256sum -c -
+      chmod 755 "$download"
+      mv "$download" "$TOOL"
+    fi
+    printf '%s  %s\n' "$APPIMAGETOOL_SHA256" "$TOOL" | sha256sum -c -
   fi
+  RUNTIME="$CARGO_TARGET_DIR/appimage-runtime-$APPIMAGE_RUNTIME_VERSION-$ARCH"
+  if [[ ! -f "$RUNTIME" ]]; then
+    download="$RUNTIME.download"
+    curl --proto '=https' -fsSL -o "$download" \
+      "https://github.com/AppImage/type2-runtime/releases/download/$APPIMAGE_RUNTIME_VERSION/runtime-$ARCH"
+    printf '%s  %s\n' "$APPIMAGE_RUNTIME_SHA256" "$download" | sha256sum -c -
+    mv "$download" "$RUNTIME"
+  fi
+  printf '%s  %s\n' "$APPIMAGE_RUNTIME_SHA256" "$RUNTIME" | sha256sum -c -
   # Absolute, because appimagetool runs in $DIST below (CARGO_TARGET_DIR or APPIMAGETOOL may be
   # relative, e.g. target/agent-<name>).
   OUT="$(cd "$DIST" && pwd)/$BASENAME.AppImage"
   APPDIR="$(cd "$APPDIR" && pwd)"
   TOOL="$(cd "$(dirname "$TOOL")" && pwd)/$(basename "$TOOL")"
+  RUNTIME="$(cd "$(dirname "$RUNTIME")" && pwd)/$(basename "$RUNTIME")"
   # A .zsync left by an earlier run would hide a missing zsyncmake and describe another file.
   rm -f "$OUT.zsync"
   # Update information: AppImageUpdate, AppImageLauncher and the like read it from the
@@ -141,18 +177,18 @@ if has appimage; then
   # Extract-and-run: works without FUSE (containers, CI). The output embeds the static runtime,
   # so users don't need libfuse2 either. With zsyncmake on the host (CI installs the zsync
   # package) appimagetool also writes the .zsync, into its working directory, hence the cd.
-  (cd "$DIST" && ARCH="$ARCH" APPIMAGE_EXTRACT_AND_RUN=1 "$TOOL" --no-appstream -u "$UPDATE_INFO" "$APPDIR" "$OUT")
+  (cd "$DIST" && ARCH="$ARCH" APPIMAGE_EXTRACT_AND_RUN=1 "$TOOL" --no-appstream --runtime-file "$RUNTIME" -u "$UPDATE_INFO" "$APPDIR" "$OUT")
   echo "wrote $OUT"
-  if [ -s "$OUT.zsync" ]; then
+  if [[ -s "$OUT.zsync" ]]; then
     echo "wrote $OUT.zsync"
   else
     warn "zsyncmake not found, so $OUT.zsync was not written; AppImage delta updates need it"
   fi
 fi
 
-if [ -z "${CROSS_TARGET:-}" ]; then
+if [[ -z "${CROSS_TARGET:-}" ]]; then
   "$STAGE/usr/bin/$(smoke_bin)" --version
-elif [ -n "${EMULATOR:-}" ]; then
+elif [[ -n "${EMULATOR:-}" ]]; then
   "$EMULATOR" "$STAGE/usr/bin/$(smoke_bin)" --version
 fi
 echo "==> done"
diff --git a/packaging/macos/import-cert.sh b/packaging/macos/import-cert.sh
index 1150163e5..776115378 100755
--- a/packaging/macos/import-cert.sh
+++ b/packaging/macos/import-cert.sh
@@ -12,7 +12,7 @@ umask 077
 # shellcheck source=../env.sh
 . "$(dirname "${BASH_SOURCE[0]}")/../env.sh"
 
-if [ -z "${APPLE_CERTIFICATE:-}" ]; then
+if [[ -z "${APPLE_CERTIFICATE:-}" ]]; then
   warn "APPLE_CERTIFICATE is not set: macOS builds will be ad-hoc signed and not notarized"
   exit 0
 fi
@@ -36,13 +36,13 @@ security set-key-partition-list -S apple-tool:,apple:,codesign: -s -k "$KC_PASS"
 security list-keychains -d user -s "$KEYCHAIN" $(security list-keychains -d user | tr -d '"')
 
 IDENTITY="$(security find-identity -v -p codesigning "$KEYCHAIN" | awk '/Developer ID Application/ { print $2; exit }')"
-if [ -z "$IDENTITY" ]; then
+if [[ -z "$IDENTITY" ]]; then
   security find-identity -v -p codesigning "$KEYCHAIN" >&2
   echo "error: no 'Developer ID Application' identity in APPLE_CERTIFICATE" >&2
   exit 1
 fi
 echo "Imported signing identity $IDENTITY"
-if [ -n "${GITHUB_ENV:-}" ]; then
+if [[ -n "${GITHUB_ENV:-}" ]]; then
   { echo "MACOS_SIGN_IDENTITY=$IDENTITY"; echo "MACOS_KEYCHAIN=$KEYCHAIN"; } >>"$GITHUB_ENV"
 else
   echo "MACOS_SIGN_IDENTITY=$IDENTITY"
diff --git a/packaging/macos/package.sh b/packaging/macos/package.sh
index 87abe94c7..7407af7be 100755
--- a/packaging/macos/package.sh
+++ b/packaging/macos/package.sh
@@ -19,7 +19,7 @@ HERE="$ROOT/packaging/macos"
 
 ARCH=universal
 SKIP_BUILD=0
-while [ $# -gt 0 ]; do
+while [[ $# -gt 0 ]]; do
   case "$1" in
     --arch) ARCH="$2"; shift 2 ;;
     --skip-build) SKIP_BUILD=1; shift ;;
@@ -44,9 +44,9 @@ DMG="$DIST/figcraft-$VERSION-macos-$ARCH.dmg"
 CLI_ZIP="$DIST/figcraft-cli-$VERSION-macos-$ARCH.zip"
 
 NOTARIZE=0
-if [ "$IDENTITY" = "-" ]; then
+if [[ "$IDENTITY" = "-" ]]; then
   warn "macOS: ad-hoc signing (no MACOS_SIGN_IDENTITY); artifacts are not notarized"
-elif [ -n "${APPLE_ID:-}" ] && [ -n "${APPLE_PASSWORD:-}" ] && [ -n "${APPLE_TEAM_ID:-}" ]; then
+elif [[ -n "${APPLE_ID:-}" ]] && [[ -n "${APPLE_PASSWORD:-}" ]] && [[ -n "${APPLE_TEAM_ID:-}" ]]; then
   NOTARIZE=1
 else
   warn "macOS: APPLE_ID / APPLE_PASSWORD / APPLE_TEAM_ID incomplete; signed but not notarized"
@@ -55,7 +55,7 @@ fi
 echo "==> FigCraft $VERSION for macOS ($ARCH; ${BINS[*]}), identity: $IDENTITY, notarize: $NOTARIZE"
 
 # ---- build -------------------------------------------------------------------------------------
-if [ "$SKIP_BUILD" = 0 ]; then
+if [[ "$SKIP_BUILD" = 0 ]]; then
   args=()
   for t in "${TARGETS[@]}"; do args+=(--target "$t"); done
   (cd "$ROOT" && cargo build --release --locked "${CARGO_PKGS[@]}" "${args[@]}")
@@ -74,9 +74,9 @@ done
 sign() {
   # Hardened runtime + secure timestamp for a real identity; ad-hoc can't be timestamped.
   local ts=(--timestamp)
-  [ "$IDENTITY" = "-" ] && ts=(--timestamp=none)
+  [[ "$IDENTITY" = "-" ]] && ts=(--timestamp=none)
   local kc=()
-  [ -n "${MACOS_KEYCHAIN:-}" ] && kc=(--keychain "$MACOS_KEYCHAIN")
+  [[ -n "${MACOS_KEYCHAIN:-}" ]] && kc=(--keychain "$MACOS_KEYCHAIN")
   codesign --force --sign "$IDENTITY" ${kc[@]+"${kc[@]}"} "${ts[@]}" "$@"
 }
 
@@ -88,8 +88,8 @@ notarize() {
   echo "$out"
   id="$(printf '%s' "$out" | plutil -extract id raw -o - - 2>/dev/null || true)"
   status="$(printf '%s' "$out" | plutil -extract status raw -o - - 2>/dev/null || true)"
-  if [ "$status" != "Accepted" ]; then
-    if [ -n "$id" ]; then
+  if [[ "$status" != "Accepted" ]]; then
+    if [[ -n "$id" ]]; then
       xcrun notarytool log "$id" --apple-id "$APPLE_ID" --password "$APPLE_PASSWORD" --team-id "$APPLE_TEAM_ID" || true
     fi
     echo "error: notarization of $(basename "$file") failed (status: ${status:-unknown})" >&2
@@ -116,7 +116,7 @@ mkdir -p "$APP/Contents/MacOS" "$APP/Contents/Resources"
 cp "$WORK/bin/figcraft" "$APP/Contents/MacOS/FigCraft"
 cp "$WORK/FigCraft.icns" "$APP/Contents/Resources/FigCraft.icns"
 # Licences of the embedded craft-fonts fonts (only when built with CRAFT_FONTS_DIR).
-if [ -n "${CRAFT_FONTS_DIR:-}" ]; then
+if [[ -n "${CRAFT_FONTS_DIR:-}" ]]; then
   mkdir -p "$APP/Contents/Resources/Licenses"
   copy_font_licences "$APP/Contents/Resources/Licenses"
 fi
@@ -132,7 +132,7 @@ sign --options runtime --entitlements "$HERE/entitlements.plist" "$APP/Contents/
 sign --options runtime --entitlements "$HERE/entitlements.plist" "$APP"
 codesign --verify --strict --deep --verbose=2 "$APP"
 
-if [ "$NOTARIZE" = 1 ]; then
+if [[ "$NOTARIZE" = 1 ]]; then
   ditto -c -k --keepParent "$APP" "$WORK/FigCraft-notarize.zip"
   notarize "$WORK/FigCraft-notarize.zip"
   retry xcrun stapler staple "$APP"
@@ -154,7 +154,7 @@ hdiutil convert "$WORK/raw.dmg" -format UDZO -imagekey zlib-level=9 -o "$DMG"
 rm -f "$WORK/raw.dmg"
 sign "$DMG"
 codesign --verify --strict --verbose=2 "$DMG"
-if [ "$NOTARIZE" = 1 ]; then
+if [[ "$NOTARIZE" = 1 ]]; then
   notarize "$DMG"
   retry xcrun stapler staple "$DMG"
   retry xcrun stapler validate "$DMG"
@@ -162,7 +162,7 @@ if [ "$NOTARIZE" = 1 ]; then
 fi
 
 # ---- CLI ---------------------------------------------------------------------------------------
-if [ "$HAS_CLI" = 1 ]; then
+if [[ "$HAS_CLI" = 1 ]]; then
   echo "==> building $CLI_ZIP"
   CLI_DIR="$WORK/figcraft-cli-$VERSION-macos-$ARCH"
   mkdir -p "$CLI_DIR"
@@ -176,7 +176,7 @@ if [ "$HAS_CLI" = 1 ]; then
   ditto -c -k --keepParent "$CLI_DIR" "$CLI_ZIP"
   # notarytool accepts a zip of the bare binary. A bare Mach-O can't carry a stapled ticket, so
   # Gatekeeper looks the notarization up online when a quarantined copy first runs.
-  if [ "$NOTARIZE" = 1 ]; then notarize "$CLI_ZIP"; fi
+  if [[ "$NOTARIZE" = 1 ]]; then notarize "$CLI_ZIP"; fi
   "$WORK/bin/figcraft-cli" --version
 else
   warn "apps/figcraft-cli is not in this workspace: no CLI zip"
diff --git a/packaging/macos/verify.sh b/packaging/macos/verify.sh
index 6080cf879..071629cbe 100755
--- a/packaging/macos/verify.sh
+++ b/packaging/macos/verify.sh
@@ -23,7 +23,7 @@ set -euo pipefail
 . "$(dirname "${BASH_SOURCE[0]}")/../env.sh"
 
 ARCH=universal
-while [ $# -gt 0 ]; do
+while [[ $# -gt 0 ]]; do
   case "$1" in
     --arch) ARCH="$2"; shift 2 ;;
     -h | --help) sed -n '2,20p' "$0"; exit 0 ;;
@@ -41,13 +41,13 @@ DMG="$DIST/figcraft-$VERSION-macos-$ARCH.dmg"
 CLI_ZIP="$DIST/figcraft-cli-$VERSION-macos-$ARCH.zip"
 IDENTITY="${MACOS_SIGN_IDENTITY:--}"
 STRICT=0
-if [ "$IDENTITY" != "-" ] && [ -n "${APPLE_ID:-}" ] && [ -n "${APPLE_PASSWORD:-}" ] && [ -n "${APPLE_TEAM_ID:-}" ]; then
+if [[ "$IDENTITY" != "-" ]] && [[ -n "${APPLE_ID:-}" ]] && [[ -n "${APPLE_PASSWORD:-}" ]] && [[ -n "${APPLE_TEAM_ID:-}" ]]; then
   STRICT=1
 fi
 
 FAILED=0
 fail() {
-  if [ "$STRICT" = 1 ]; then
+  if [[ "$STRICT" = 1 ]]; then
     echo "error: $*" >&2
     FAILED=1
   else
@@ -58,22 +58,22 @@ fail() {
 # spctl's online ticket lookup can lag a few seconds behind notarytool's "Accepted".
 assess() {
   local out attempt tries=1
-  [ "$STRICT" = 1 ] && tries=5
+  [[ "$STRICT" = 1 ]] && tries=5
   for attempt in $(seq "$tries"); do
     if out="$(spctl "$@" 2>&1)"; then
       printf '%s\n' "$out"
       return 0
     fi
-    [ "$attempt" = "$tries" ] || sleep 10
+    [[ "$attempt" = "$tries" ]] || sleep 10
   done
   printf '%s\n' "$out"
   return 1
 }
 
 FILES=("$DMG")
-if [ "$HAS_CLI" = 1 ]; then FILES+=("$CLI_ZIP"); fi
+if [[ "$HAS_CLI" = 1 ]]; then FILES+=("$CLI_ZIP"); fi
 for f in "${FILES[@]}"; do
-  if [ ! -f "$f" ]; then
+  if [[ ! -f "$f" ]]; then
     echo "error: missing $f" >&2
     exit 1
   fi
@@ -83,11 +83,11 @@ WORK="$(mktemp -d "${RUNNER_TEMP:-${TMPDIR:-/tmp}}/figcraft-verify.XXXXXX")"
 trap 'rm -rf "$WORK"' EXIT
 
 # ---- CLI zip (when apps/figcraft-cli exists) ----------------------------------------------------
-if [ "$HAS_CLI" = 1 ]; then
+if [[ "$HAS_CLI" = 1 ]]; then
   echo "==> $(basename "$CLI_ZIP")"
   ditto -x -k "$CLI_ZIP" "$WORK/cli"
   CLI="$WORK/cli/figcraft-cli-$VERSION-macos-$ARCH/figcraft-cli"
-  if [ ! -x "$CLI" ]; then
+  if [[ ! -x "$CLI" ]]; then
     echo "error: $(basename "$CLI_ZIP") has no executable figcraft-cli-$VERSION-macos-$ARCH/figcraft-cli" >&2
     exit 1
   fi
@@ -111,7 +111,7 @@ if [ "$HAS_CLI" = 1 ]; then
     || fail "figcraft-cli is not signed with a Developer ID Application identity"
   printf '%s\n' "$details" | grep -q '^Timestamp=' \
     || fail "figcraft-cli signature has no secure timestamp"
-  if [ -n "${APPLE_TEAM_ID:-}" ]; then
+  if [[ -n "${APPLE_TEAM_ID:-}" ]]; then
     printf '%s\n' "$details" | grep -qx "TeamIdentifier=$APPLE_TEAM_ID" \
       || fail "figcraft-cli is signed by a different team"
   fi
@@ -129,25 +129,25 @@ fi
 # ---- DMG ---------------------------------------------------------------------------------------
 echo "==> $(basename "$DMG")"
 codesign --verify --strict --verbose=2 "$DMG"
-if [ "$STRICT" = 1 ]; then
+if [[ "$STRICT" = 1 ]]; then
   retry xcrun stapler validate "$DMG" || fail "no notarization ticket stapled to the DMG"
   assess --assess --type open --context context:primary-signature -vv "$DMG" \
     || fail "Gatekeeper rejects the DMG"
 fi
 
-if [ "$FAILED" != 0 ]; then
+if [[ "$FAILED" != 0 ]]; then
   echo "error: macOS artifacts failed verification" >&2
   exit 1
 fi
 
-if [ "$STRICT" = 1 ]; then
+if [[ "$STRICT" = 1 ]]; then
   result="signed (Developer ID, hardened runtime), notarized; DMG stapled"
 else
   result="signature intact; Developer ID and notarization not required (no signing secrets)"
 fi
 echo "==> verified: $result"
-if [ -n "${GITHUB_STEP_SUMMARY:-}" ]; then
+if [[ -n "${GITHUB_STEP_SUMMARY:-}" ]]; then
   names="\`$(basename "$DMG")\`"
-  if [ "$HAS_CLI" = 1 ]; then names="$names, \`$(basename "$CLI_ZIP")\`"; fi
+  if [[ "$HAS_CLI" = 1 ]]; then names="$names, \`$(basename "$CLI_ZIP")\`"; fi
   echo "- macOS $names: $result" >>"$GITHUB_STEP_SUMMARY"
 fi
diff --git a/packaging/server/install-test.sh b/packaging/server/install-test.sh
index 303d08de0..2ebe51760 100755
--- a/packaging/server/install-test.sh
+++ b/packaging/server/install-test.sh
@@ -10,7 +10,7 @@ WORK="$(mktemp -d)"
 trap 'rm -rf "$WORK"' EXIT
 FAILED=0
 
-main() { bash "$HERE/install.sh" --caddy-main "$1" ops@example.com; }
+main() { local caddyfile="$1"; bash "$HERE/install.sh" --caddy-main "$caddyfile" ops@example.com; }
 fail() { printf 'FAIL: %s\n' "$*" >&2; FAILED=1; }
 
 # Missing: ours.
@@ -28,7 +28,7 @@ printf 'shop.example.com {\n\treverse_proxy 127.0.0.1:8080\n}\n' >"$WORK/theirs"
 cp "$WORK/theirs" "$WORK/run1"
 main "$WORK/run1" >"$WORK/run2"
 grep -q 'shop.example.com' "$WORK/run2" || fail "the operator's site is kept"
-[ "$(grep -c 'import figcraft-server.caddy' "$WORK/run2")" = 1 ] || fail "one import line is added"
+[[ "$(grep -c 'import figcraft-server.caddy' "$WORK/run2")" = 1 ]] || fail "one import line is added"
 main "$WORK/run2" >"$WORK/run3"
 cmp -s "$WORK/run2" "$WORK/run3" || fail "running again leaves a Caddyfile with other sites as it is"
 main "$WORK/run3" >"$WORK/run4"
@@ -39,5 +39,5 @@ main "$WORK/none" >"$WORK/ours1"
 main "$WORK/ours1" >"$WORK/ours2"
 cmp -s "$WORK/ours1" "$WORK/ours2" || fail "our own Caddyfile stays the same"
 
-if [ "$FAILED" = 0 ]; then echo "install.sh Caddyfile handling: ok"; fi
+if [[ "$FAILED" = 0 ]]; then echo "install.sh Caddyfile handling: ok"; fi
 exit "$FAILED"
diff --git a/packaging/server/install.sh b/packaging/server/install.sh
index 11c489a32..94acd5786 100755
--- a/packaging/server/install.sh
+++ b/packaging/server/install.sh
@@ -41,7 +41,7 @@ SERVICE=figcraft-server
 HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 # The source tree this script sits in (packaging/server/ of a copy or checkout), if any.
 LOCAL_SRC=""
-if [ -f "$HERE/../../Cargo.toml" ] && [ -d "$HERE/../../apps/figcraft-server" ]; then
+if [[ -f "$HERE/../../Cargo.toml" ]] && [[ -d "$HERE/../../apps/figcraft-server" ]]; then
   LOCAL_SRC="$(cd "$HERE/../.." && pwd)"
 fi
 
@@ -64,9 +64,9 @@ MARK="# figcraft-server (install.sh)"
 
 caddy_main() { # caddy_main FILE EMAIL: the main Caddyfile to install, on stdout
   local file="$1" email="$2"
-  if [ -f "$file" ] && grep -qE '^[[:space:]]*import[[:space:]]+figcraft-server\.caddy[[:space:]]*$' "$file"; then
+  if [[ -f "$file" ]] && grep -qE '^[[:space:]]*import[[:space:]]+figcraft-server\.caddy[[:space:]]*$' "$file"; then
     cat "$file" # it imports our site already: kept exactly as it is
-  elif [ ! -f "$file" ] || ! grep -qvE '^[[:space:]]*(#|$|:80|\{|\}|root|file_server)' "$file"; then
+  elif [[ ! -f "$file" ]] || ! grep -qvE '^[[:space:]]*(#|$|:80|\{|\}|root|file_server)' "$file"; then
     # Missing, or only the example site the package ships: ours, with the certificate email.
     printf '%s\n{\n\temail %s\n}\n\nimport figcraft-server.caddy\n' "$MARK" "$email"
   else
@@ -76,7 +76,7 @@ caddy_main() { # caddy_main FILE EMAIL: the main Caddyfile to install, on stdout
   fi
 }
 
-while [ $# -gt 0 ]; do
+while [[ $# -gt 0 ]]; do
   case "$1" in
     # For tests (packaging/server/install-test.sh): print the Caddyfile this script would write.
     --caddy-main) caddy_main "${2:-}" "${3:-}"; exit 0 ;;
@@ -95,7 +95,7 @@ while [ $# -gt 0 ]; do
   esac
 done
 
-[ "$(id -u)" -eq 0 ] || die "run it as root (sudo ./install.sh ...)"
+[[ "$(id -u)" -eq 0 ]] || die "run it as root (sudo ./install.sh ...)"
 # shellcheck source=/dev/null
 . /etc/os-release
 case " ${ID:-} ${ID_LIKE:-} " in
@@ -104,9 +104,9 @@ case " ${ID:-} ${ID_LIKE:-} " in
 esac
 
 ask() { # ask VAR "question" FLAG: read an answer from the terminal when the value wasn't given
-  local var="$1" question="$2" answer
-  if [ -z "${!var}" ]; then
-    [ -t 0 ] || die "give $3 (no terminal to ask on)"
+  local var="$1" question="$2" flag="$3" answer
+  if [[ -z "${!var}" ]]; then
+    [[ -t 0 ]] || die "give $flag (no terminal to ask on)"
     read -r -p "$question " answer
     printf -v "$var" '%s' "$answer"
   fi
@@ -115,6 +115,7 @@ ask HOST "DNS name people will use (e.g. figcraft.example.com):" "--host"
 ask EMAIL "Email for Let's Encrypt and the abuse contact shown to users:" "--email"
 case "$HOST" in
   "" | *[!A-Za-z0-9.-]* | .* | *. ) die "--host must be a DNS name like figcraft.example.com" ;;
+  *) ;;
 esac
 case "$EMAIL" in
   *@*.*) ;;
@@ -126,6 +127,7 @@ case "$TERMS" in
 esac
 case "$EMAIL$TERMS" in
   *[[:space:]\"\\]*) die "--email and --terms can't contain spaces, quotes or backslashes" ;;
+  *) ;;
 esac
 
 export DEBIAN_FRONTEND=noninteractive
@@ -138,6 +140,7 @@ ARCH="$(uname -m)"
 case "$ARCH" in
   amd64) ARCH=x86_64 ;;
   arm64) ARCH=aarch64 ;;
+  *) ;; # already a release name (x86_64, aarch64)
 esac
 
 # --- The binary -----------------------------------------------------------------------------
@@ -146,17 +149,17 @@ FILES="$HERE" # where the units and the Caddyfile come from
 
 from_release() { # download and check the release archive; sets NEW_BIN and FILES
   local version="$VERSION" name dir
-  if [ -z "$version" ]; then
-    version="$(curl -fsSL "https://api.github.com/repos/$REPO/releases/latest" | sed -n 's/.*"tag_name": *"v\([^"]*\)".*/\1/p' | head -n 1)" || return 1
-    [ -n "$version" ] || return 1
+  if [[ -z "$version" ]]; then
+    version="$(curl --proto '=https' -fsSL "https://api.github.com/repos/$REPO/releases/latest" | sed -n 's/.*"tag_name": *"v\([^"]*\)".*/\1/p' | head -n 1)" || return 1
+    [[ -n "$version" ]] || return 1
   fi
   name="figcraft-server-$version-linux-$ARCH"
   dir="$WORK/release"
   rm -rf "$dir"
   mkdir -p "$dir"
   say "Downloading $name"
-  curl -fsSL -o "$dir/$name.tar.gz" "https://github.com/$REPO/releases/download/v$version/$name.tar.gz" || return 1
-  curl -fsSL -o "$dir/SHA256SUMS.txt" "https://github.com/$REPO/releases/download/v$version/SHA256SUMS.txt" || return 1
+  curl --proto '=https' -fsSL -o "$dir/$name.tar.gz" "https://github.com/$REPO/releases/download/v$version/$name.tar.gz" || return 1
+  curl --proto '=https' -fsSL -o "$dir/SHA256SUMS.txt" "https://github.com/$REPO/releases/download/v$version/SHA256SUMS.txt" || return 1
   (cd "$dir" && grep " $name.tar.gz\$" SHA256SUMS.txt | sha256sum -c --quiet -) || die "the download doesn't match SHA256SUMS.txt"
   tar -C "$dir" -xzf "$dir/$name.tar.gz"
   NEW_BIN="$dir/$name/figcraft-server"
@@ -165,7 +168,7 @@ from_release() { # download and check the release archive; sets NEW_BIN and FILE
 
 SWAP=""
 cleanup() {
-  if [ -n "$SWAP" ]; then
+  if [[ -n "$SWAP" ]]; then
     swapoff "$SWAP" 2>/dev/null || true
     rm -f "$SWAP"
   fi
@@ -174,7 +177,7 @@ trap cleanup EXIT
 
 as_builder() { # run a command as the unprivileged build user, with its own toolchain
   local jobs=()
-  if [ -n "${CARGO_BUILD_JOBS:-}" ]; then jobs=("CARGO_BUILD_JOBS=$CARGO_BUILD_JOBS"); fi
+  if [[ -n "${CARGO_BUILD_JOBS:-}" ]]; then jobs=("CARGO_BUILD_JOBS=$CARGO_BUILD_JOBS"); fi
   runuser -u "$BUILDER" -- env HOME="$BUILD" RUSTUP_HOME="$BUILD/rustup" CARGO_HOME="$BUILD/cargo" \
     CARGO_TARGET_DIR="$BUILD/target" "${jobs[@]}" "$@"
 }
@@ -184,27 +187,27 @@ from_source() { # build the source tree around this script, else a fresh clone;
   apt-get install -y -qq build-essential git pkg-config >/dev/null
   id -u "$BUILDER" >/dev/null 2>&1 || useradd --system --home-dir "$BUILD" --shell /usr/sbin/nologin "$BUILDER"
   install -d -o "$BUILDER" -g "$BUILDER" -m 755 "$BUILD"
-  if [ ! -x "$BUILD/cargo/bin/cargo" ]; then
+  if [[ ! -x "$BUILD/cargo/bin/cargo" ]]; then
     as_builder sh -c "curl --proto '=https' --tlsv1.2 -fsSL https://sh.rustup.rs | sh -s -- -y --profile minimal --default-toolchain stable --no-modify-path" >/dev/null
   else
     as_builder "$BUILD/cargo/bin/rustup" update stable >/dev/null
   fi
   # The source root installs files from is root's own (the copy beside this script, or root's
   # clone); the build user only ever builds a copy of it.
-  if [ -n "$LOCAL_SRC" ]; then
+  if [[ -n "$LOCAL_SRC" ]]; then
     src="$LOCAL_SRC"
     say "Building the source in $LOCAL_SRC: this takes a while"
   else
     src="$WORK/src"
-    if [ -d "$src/.git" ]; then
+    if [[ -d "$src/.git" ]]; then
       git -C "$src" fetch --quiet --tags origin
     else
       git clone --quiet "https://github.com/$REPO" "$src" ||
         die "can't clone $REPO (a private repository: copy the source to this machine and run its packaging/server/install.sh)"
     fi
-    if [ -z "$ref" ]; then
-      if [ -n "$VERSION" ]; then ref="v$VERSION"; else ref="$(git -C "$src" tag --list 'v*' --sort=-v:refname | head -n 1)"; fi
-      [ -n "$ref" ] || ref=main
+    if [[ -z "$ref" ]]; then
+      if [[ -n "$VERSION" ]]; then ref="v$VERSION"; else ref="$(git -C "$src" tag --list 'v*' --sort=-v:refname | head -n 1)"; fi
+      [[ -n "$ref" ]] || ref=main
     fi
     say "Building $ref from a clone: this takes a while"
     # A branch as it is upstream now, or a tag.
@@ -216,7 +219,7 @@ from_source() { # build the source tree around this script, else a fresh clone;
   tar -C "$src" --exclude=./target --exclude=./plugins/target --exclude=./.git -cf - . | as_builder tar -C "$copy" -xf -
   # The compiler needs about 2 GB: add a temporary swap file on smaller machines.
   mem_kb="$(awk '/^MemTotal:/ {print $2}' /proc/meminfo)"
-  if [ "$mem_kb" -lt 2000000 ] && [ -z "$(swapon --show --noheadings)" ]; then
+  if [[ "$mem_kb" -lt 2000000 ]] && [[ -z "$(swapon --show --noheadings)" ]]; then
     SWAP="$WORK/swapfile"
     say "Adding a temporary 2 GB swap file for the build"
     fallocate -l 2G "$SWAP" 2>/dev/null || dd if=/dev/zero of="$SWAP" bs=1M count=2048 status=none
@@ -237,19 +240,19 @@ from_source() { # build the source tree around this script, else a fresh clone;
   FILES="$src/packaging/server"
 }
 
-if [ -x "$HERE/figcraft-server" ] && [ "$FROM_SOURCE" = false ]; then
+if [[ -x "$HERE/figcraft-server" ]] && [[ "$FROM_SOURCE" = false ]]; then
   NEW_BIN="$HERE/figcraft-server" # run from an unpacked release archive
-elif [ -n "$LOCAL_SRC" ] && [ -z "$VERSION" ]; then
+elif [[ -n "$LOCAL_SRC" ]] && [[ -z "$VERSION" ]]; then
   from_source # the source copied to (or checked out on) this machine, as it is
-elif [ "$FROM_SOURCE" = true ] || ! from_release; then
-  [ "$FROM_SOURCE" = true ] || say "No release archive for linux-$ARCH: building from source instead"
+elif [[ "$FROM_SOURCE" = true ]] || ! from_release; then
+  [[ "$FROM_SOURCE" = true ]] || say "No release archive for linux-$ARCH: building from source instead"
   from_source
 fi
-[ -x "$NEW_BIN" ] || die "no figcraft-server binary to install"
+[[ -x "$NEW_BIN" ]] || die "no figcraft-server binary to install"
 # The units and the Caddyfile beside this script when it has them (a checkout or an archive).
-[ -f "$HERE/figcraft-backup.timer" ] && FILES="$HERE"
+[[ -f "$HERE/figcraft-backup.timer" ]] && FILES="$HERE"
 for f in figcraft-server.service Caddyfile figcraft-backup.service figcraft-backup.timer; do
-  [ -f "$FILES/$f" ] || die "$FILES/$f is missing"
+  [[ -f "$FILES/$f" ]] || die "$FILES/$f is missing"
 done
 
 # The server's own account runs the binary, from here on too (root never runs what was built).
@@ -267,7 +270,7 @@ fi
 # --- Data and settings ----------------------------------------------------------------------
 install -d -o figcraft -g figcraft -m 700 "$DATA"
 install -d -m 755 "$CONFIG_DIR"
-if [ ! -f "$CONFIG" ]; then
+if [[ ! -f "$CONFIG" ]]; then
   say "Writing $CONFIG"
   {
     printf '# figcraft-server settings (docs/server.md, "Configuration"). install.sh never overwrites this file.\n'
@@ -303,8 +306,9 @@ as_server "$BIN" --config "$CONFIG" check >/dev/null ||
   die "$CONFIG isn't right for this figcraft-server (see above; a release older than open hosting needs --from-source)"
 
 install_file() { # install_file SOURCE TARGET MODE: true when it changed
-  if cmp -s "$1" "$2"; then return 1; fi
-  install -m "$3" "$1" "$2"
+  local source="$1" target="$2" mode="$3"
+  if cmp -s "$source" "$target"; then return 1; fi
+  install -m "$mode" "$source" "$target"
 }
 
 # --- systemd --------------------------------------------------------------------------------
@@ -312,16 +316,16 @@ UNITS=false
 install_file "$FILES/figcraft-server.service" /etc/systemd/system/figcraft-server.service 644 && UNITS=true
 install_file "$FILES/figcraft-backup.service" /etc/systemd/system/figcraft-backup.service 644 && UNITS=true
 install_file "$FILES/figcraft-backup.timer" /etc/systemd/system/figcraft-backup.timer 644 && UNITS=true
-if [ "$UNITS" = true ]; then
+if [[ "$UNITS" = true ]]; then
   systemctl daemon-reload
   CHANGED=true
 fi
 systemctl enable --quiet "$SERVICE"
-if [ "$CHANGED" = true ] || ! systemctl is-active --quiet "$SERVICE"; then
+if [[ "$CHANGED" = true ]] || ! systemctl is-active --quiet "$SERVICE"; then
   say "Starting figcraft-server"
   systemctl restart "$SERVICE"
 fi
-if [ "$BACKUPS" = true ]; then
+if [[ "$BACKUPS" = true ]]; then
   systemctl enable --now --quiet figcraft-backup.timer
 fi
 
@@ -339,15 +343,15 @@ MAIN="$(mktemp)"
 caddy_main "$CADDYFILE" "$EMAIL" >"$MAIN"
 CADDY_CHANGED=false
 for f in "$CADDYFILE" "$SITE_FILE"; do
-  if [ -f "$f" ]; then cp -p "$f" "$f.before-figcraft"; else rm -f "$f.before-figcraft"; fi
+  if [[ -f "$f" ]]; then cp -p "$f" "$f.before-figcraft"; else rm -f "$f.before-figcraft"; fi
 done
 install_file "$SITE" "$SITE_FILE" 644 && CADDY_CHANGED=true
 install_file "$MAIN" "$CADDYFILE" 644 && CADDY_CHANGED=true
 rm -f "$SITE" "$MAIN"
-if [ "$CADDY_CHANGED" = true ]; then
+if [[ "$CADDY_CHANGED" = true ]]; then
   if ! caddy validate --config "$CADDYFILE" --adapter caddyfile >/dev/null 2>&1; then
     for f in "$CADDYFILE" "$SITE_FILE"; do
-      if [ -f "$f.before-figcraft" ]; then cp -p "$f.before-figcraft" "$f"; else rm -f "$f"; fi
+      if [[ -f "$f.before-figcraft" ]]; then cp -p "$f.before-figcraft" "$f"; else rm -f "$f"; fi
     done
     die "Caddy doesn't accept the new configuration (the old one is back; see: caddy validate --config $CADDYFILE)"
   fi
@@ -356,10 +360,10 @@ fi
 systemctl enable --now --quiet caddy
 
 # --- Firewall -------------------------------------------------------------------------------
-if [ "$FIREWALL" = true ]; then
+if [[ "$FIREWALL" = true ]]; then
   # The ports sshd really listens on (sudo doesn't pass SSH_CONNECTION on).
   SSH_PORTS="$(sshd -T 2>/dev/null | awk '/^port / {print $2}' | sort -u)"
-  [ -n "$SSH_PORTS" ] || SSH_PORTS=22
+  [[ -n "$SSH_PORTS" ]] || SSH_PORTS=22
   say "Firewall: SSH ($(echo "$SSH_PORTS" | tr '\n' ' ' | sed 's/ $//')), 80 and 443"
   for p in $SSH_PORTS; do ufw allow "$p/tcp" >/dev/null; done
   ufw allow 80/tcp >/dev/null
@@ -370,12 +374,12 @@ if [ "$FIREWALL" = true ]; then
     # Other services reachable from outside would be cut off by enabling ufw.
     OTHERS=""
     for a in $(ss -Hltn | awk '{print $4}'); do
-      case "$a" in 127.* | "[::1]:"* | ::1:*) continue ;; esac
+      case "$a" in 127.* | "[::1]:"* | ::1:*) continue ;; *) ;; esac
       port="${a##*:}"
       case " $(echo "$SSH_PORTS" | tr '\n' ' ') 80 443 " in *" $port "*) continue ;; esac
       OTHERS="$OTHERS $port"
     done
-    if [ -n "$OTHERS" ] && [ "$FIREWALL_ANYWAY" = false ]; then
+    if [[ -n "$OTHERS" ]] && [[ "$FIREWALL_ANYWAY" = false ]]; then
       warn "other services listen on port(s)$OTHERS: ufw was not enabled (rules added; allow those ports, then 'ufw enable', or run again with --firewall-anyway)"
     else
       ufw --force enable >/dev/null
@@ -395,7 +399,7 @@ cat <<EOF
 figcraft-server is running behind Caddy.
 
   Publish:   in FigCraft, Share > Publish to server..., address wss://$HOST/
-             $(if [ "$OPEN" = true ]; then echo "(open to the public: no key needed; each file gets an owner token)"; else echo "(with the key: $ADMIN key)"; fi)
+             $(if [[ "$OPEN" = true ]]; then echo "(open to the public: no key needed; each file gets an owner token)"; else echo "(with the key: $ADMIN key)"; fi)
   Check:     curl https://$HOST/healthz      (once DNS points here and Caddy has its certificate)
   Logs:      journalctl -u $SERVICE -f
 
diff --git a/packaging/server/package.sh b/packaging/server/package.sh
index 7d2f9c545..5f3063273 100755
--- a/packaging/server/package.sh
+++ b/packaging/server/package.sh
@@ -25,11 +25,12 @@ ARCH="$(uname -m)"
 case "$ARCH" in
   arm64) ARCH=aarch64 ;;
   amd64) ARCH=x86_64 ;;
+  *) ;; # already a release name (x86_64, aarch64)
 esac
 NAME="figcraft-server-$VERSION-$OS-$ARCH"
 echo "==> figcraft-server $VERSION for $OS $ARCH"
 
-if [ "$SKIP_BUILD" = 0 ]; then
+if [[ "$SKIP_BUILD" = 0 ]]; then
   (cd "$ROOT" && cargo build --release --locked -p figcraft-server)
 fi
 WORK="$CARGO_TARGET_DIR/server-package"
diff --git a/packaging/web/package.sh b/packaging/web/package.sh
index 0e45c5156..f9ee34a78 100755
--- a/packaging/web/package.sh
+++ b/packaging/web/package.sh
@@ -11,13 +11,13 @@ set -euo pipefail
 . "$(dirname "${BASH_SOURCE[0]}")/../env.sh"
 HERE="$ROOT/packaging/web"
 
-if [ "${1:-}" != "--skip-build" ]; then
+if [[ "${1:-}" != "--skip-build" ]]; then
   command -v trunk >/dev/null || { echo "error: trunk not found (cargo install trunk --locked)" >&2; exit 1; }
   (cd "$ROOT/apps/figcraft-web" && trunk build --release)
 fi
 
 SITE="$ROOT/dist/web"
-[ -f "$SITE/index.html" ] || { echo "error: $SITE/index.html missing; run without --skip-build" >&2; exit 1; }
+[[ -f "$SITE/index.html" ]] || { echo "error: $SITE/index.html missing; run without --skip-build" >&2; exit 1; }
 # Paths must be relative so the site works under any prefix (public_url = "./" in Trunk.toml).
 if grep -Eq '(src|href)="/[^/]' "$SITE/index.html"; then
   echo "error: $SITE/index.html has root-absolute URLs; it would break when served from a sub-path" >&2
@@ -30,16 +30,16 @@ fi
 MAX_WASM_BYTES="${FIGCRAFT_WASM_MAX_BYTES:-25165824}" # 24 MiB
 WASM_COUNT=0
 for wasm in "$SITE"/*.wasm; do
-  [ -f "$wasm" ] || continue
+  [[ -f "$wasm" ]] || continue
   WASM_COUNT=$((WASM_COUNT + 1))
   size=$(wc -c <"$wasm" | tr -d ' ')
   echo "$(basename "$wasm"): $size bytes ($((size / 1048576)) MiB; limit $MAX_WASM_BYTES)"
-  if [ "$size" -gt "$MAX_WASM_BYTES" ]; then
+  if [[ "$size" -gt "$MAX_WASM_BYTES" ]]; then
     echo "error: $(basename "$wasm") is $size bytes, over the $MAX_WASM_BYTES-byte limit (Cloudflare's per-file cap is 25 MiB)" >&2
     exit 1
   fi
 done
-[ "$WASM_COUNT" -gt 0 ] || { echo "error: no .wasm in $SITE" >&2; exit 1; }
+[[ "$WASM_COUNT" -gt 0 ]] || { echo "error: no .wasm in $SITE" >&2; exit 1; }
 
 NAME="figcraft-web-$VERSION"
 WORK="$CARGO_TARGET_DIR/web-package"
diff --git a/packaging/windows/sign.ps1 b/packaging/windows/sign.ps1
index 3d94747a5..795ef067b 100644
--- a/packaging/windows/sign.ps1
+++ b/packaging/windows/sign.ps1
@@ -56,8 +56,8 @@ if (-not $haveCert -and -not $haveAzure) {
 
 $script:SignTool = Find-SignTool
 $common = @('sign', '/v', '/fd', 'SHA256', '/td', 'SHA256', '/d', 'FigCraft', '/du', 'https://github.com/storytold/figcraft')
-$tmp = Join-Path ([IO.Path]::GetTempPath()) "figcraft-sign-$PID"
-New-Item -ItemType Directory -Force -Path $tmp | Out-Null
+$tmp = Join-Path ([IO.Path]::GetTempPath()) "figcraft-sign-$([IO.Path]::GetRandomFileName())"
+New-Item -ItemType Directory -Path $tmp | Out-Null
 
 try {
   if ($haveCert) {
@@ -73,8 +73,15 @@ try {
     Write-Output "Signing with Azure Trusted Signing ($env:AZURE_SIGNING_ACCOUNT / $env:AZURE_CERT_PROFILE): $($Files -join ', ')"
     # The dlib authenticates with DefaultAzureCredential, which reads AZURE_TENANT_ID,
     # AZURE_CLIENT_ID and AZURE_CLIENT_SECRET from the environment.
+    $trustedSigningVersion = '1.0.95'
+    $trustedSigningSha256 = '3bfcf1e0a3cb42af1692f0a8ed45c15de070c2de86f28a59b2795d904d8a920f'
     $pkg = Join-Path $tmp 'trusted-signing.zip'
-    Invoke-WebRequest -Uri 'https://www.nuget.org/api/v2/package/Microsoft.Trusted.Signing.Client' -OutFile $pkg
+    $uri = "https://api.nuget.org/v3-flatcontainer/microsoft.trusted.signing.client/$trustedSigningVersion/microsoft.trusted.signing.client.$trustedSigningVersion.nupkg"
+    Invoke-WebRequest -Uri $uri -OutFile $pkg
+    $actualHash = (Get-FileHash -Path $pkg -Algorithm SHA256).Hash.ToLowerInvariant()
+    if ($actualHash -ne $trustedSigningSha256) {
+      throw "Microsoft.Trusted.Signing.Client $trustedSigningVersion checksum mismatch"
+    }
     Expand-Archive -Path $pkg -DestinationPath (Join-Path $tmp 'client') -Force
     $dlib = Get-ChildItem -Path (Join-Path $tmp 'client') -Recurse -Filter Azure.CodeSigning.Dlib.dll |
       Where-Object { $_.FullName -match '\\x64\\' } | Select-Object -First 1
diff --git a/sonar-project.properties b/sonar-project.properties
new file mode 100644
index 000000000..92562d54c
--- /dev/null
+++ b/sonar-project.properties
@@ -0,0 +1,2 @@
+sonar.projectKey=storytold_figcraft
+sonar.organization=storytold
diff --git a/xtask/src/main.rs b/xtask/src/main.rs
index e3f00e8bc..6c09c9210 100644
--- a/xtask/src/main.rs
+++ b/xtask/src/main.rs
@@ -1,6 +1,9 @@
 //! Project tasks: `cargo xtask <task>`.
 //!
-//! - `ci`      fmt check, clippy -D warnings, tests, layers, assets, wasm check
+//! - `ci`      fmt check, clippy -D warnings, tests, the translation report, layers, assets, wasm check
+//! - `test`    the workspace tests (nextest when installed) and doctests
+//! - `i18n-report` the UI strings, command labels and menu wordings each language lacks (never fails
+//!   on them: a missing translation reads English)
 //! - `layers`  crate dependency layering check
 //! - `assets`  every file under assets/ and docs/ has a row in ATTRIBUTION.md
 //! - `parity`  menu-catalog coverage → docs/parity-checklist.md
@@ -16,7 +19,7 @@
 mod icon;
 mod layers;
 
-use std::process::{Command, ExitCode};
+use std::process::{Command, ExitCode, Stdio};
 
 fn run(cmd: &mut Command) -> bool {
     eprintln!("$ {cmd:?}");
@@ -36,6 +39,8 @@ fn main() -> ExitCode {
     let task = args.first().map(String::as_str).unwrap_or("help");
     let ok = match task {
         "ci" => ci(),
+        "test" => test(),
+        "i18n-report" => i18n_report(),
         "layers" => layers::check(&root()),
         "assets" => assets(),
         "parity" => parity(),
@@ -45,7 +50,7 @@ fn main() -> ExitCode {
         "plugins" => plugins(),
         "bench" => bench(args.get(1).map_or("1000,10000,50000", String::as_str)),
         _ => {
-            eprintln!("tasks: ci, layers, assets, parity, version [set X.Y.Z], icon, wasm, plugins, bench [SIZES]");
+            eprintln!("tasks: ci, test, i18n-report, layers, assets, parity, version [set X.Y.Z], icon, wasm, plugins, bench [SIZES]");
             task == "help"
         }
     };
@@ -54,16 +59,38 @@ fn main() -> ExitCode {
 
 fn ci() -> bool {
     run(cargo().args(["fmt", "--all", "--check"]))
-        && run(cargo().args(["clippy", "--workspace", "--all-targets", "--", "-D", "warnings"]))
-        && run(cargo().args(["test", "--workspace"]))
+        && run(cargo().args(["clippy", "--workspace", "--all-targets", "--keep-going", "--", "-D", "warnings"]))
+        && test()
+        && i18n_report()
         && layers::check(&root())
         && assets()
         && wasm()
 }
 
+/// Unit and integration tests with nextest when it is installed (`cargo install cargo-nextest`),
+/// else with `cargo test`; then the doctests, which nextest does not run. Examples are not built:
+/// clippy's `--all-targets` already checks them.
+fn test() -> bool {
+    let nextest = cargo().args(["nextest", "--version"]).stdout(Stdio::null()).stderr(Stdio::null()).status().is_ok_and(|s| s.success());
+    let units = if nextest {
+        run(cargo().args(["nextest", "run", "--workspace", "--lib", "--bins", "--tests"]))
+    } else {
+        eprintln!("xtask: cargo-nextest not installed; running unit and integration tests with `cargo test`");
+        run(cargo().args(["test", "--workspace", "--lib", "--bins", "--tests"]))
+    };
+    units && run(cargo().args(["test", "--workspace", "--doc"]))
+}
+
+/// Prints what each language's catalog lacks, from the test that lists it. `--workspace --lib`
+/// reuses the binaries `test` built.
+fn i18n_report() -> bool {
+    run(cargo().args(["test", "-q", "--workspace", "--lib", "--", "--exact", "i18n::tests::missing_translations_report", "--nocapture"]))
+}
+
 fn wasm() -> bool {
     run(cargo().args([
         "check",
+        "--keep-going",
         "--target",
         "wasm32-unknown-unknown",
         "-p",