CI: run FreeBSD and Windows ARM64 checks nightly and on release, not per PR

They ran on every push to main and on any PR touching Cargo.toml/Cargo.lock, which is nearly every PR. See craftrules release/playbook.md §2. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-24 10:37:03 -06:00 · 2026-10-11 02:02:58 -04:00
24 changed files with 621 additions and 792 deletions
@@ -2,16 +2,19 @@
 # (GitHub has no FreeBSD runners). GPU tests skip themselves when the VM has no adapter.
 name: FreeBSD

+# The VM build is slow, so it runs nightly on main and on pushes to `release`, not on every push
+# or dependency change: a drifted dependency still shows up within a day, and always before a
+# release ships. PRs that change the FreeBSD packaging itself still run it.
 on:
+  schedule:
+    - cron: "7 2 * * *"
  push:
-    branches: [main]
+    branches: [release]
  pull_request:
    paths:
-      - Cargo.toml
-      - Cargo.lock
-      - "**/Cargo.toml"
      - "crates/fonts/**"
      - .github/workflows/freebsd.yml
+      - packaging/freebsd/**
  workflow_dispatch:

 concurrency:
@@ -23,7 +26,33 @@ permissions:

 jobs:
  freebsd:
-    # 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:
-      craft-fonts-ref: 43913056ce82a3fdad0ef69f6b88d1dc922a8104
+    name: FreeBSD 14 (build + test)
+    runs-on: ubuntu-latest
+    timeout-minutes: 300
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - name: Check out craft-fonts
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          repository: storytold/craft-fonts
+          ref: 43913056ce82a3fdad0ef69f6b88d1dc922a8104
+          path: craft-fonts
+      - name: Build and test in a FreeBSD VM
+        uses: vmactions/freebsd-vm@c46abacb49f09938ca4e1702d15d836285d694cc # v1.5.9
+        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
+          prepare: |
+            pkg install -y git curl pkgconf cmake python3 libxkbcommon wayland libX11 libXcursor libXrandr libXi libxcb mesa-libs vulkan-loader gtk3 fontconfig freetype2 alsa-lib
+            curl -fsSL https://sh.rustup.rs | sh -s -- -y --profile minimal
+          run: |
+            . "$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
+            CRAFT_FONTS_DIR="$PWD/craft-fonts" CARGO_PROFILE_DEV_DEBUG=0 cargo test --workspace --locked
@@ -19,5 +19,48 @@ concurrency:

 jobs:
  lint:
-    # 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
+    runs-on: ubuntu-latest
+    env:
+      ACTIONLINT_VERSION: 1.7.12
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - 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
+      - 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)"
+          }
+      - name: XML, desktop entry, AppStream, Flatpak manifest
+        run: |
+          xmllint --noout packaging/windows/deckcraft.wxs packaging/macos/*.plist* packaging/linux/*.xml*
+          # Windows Installer needs Icon ids ending in .ico or .exe, or shortcuts show a blank icon.
+          if grep -oE '<Icon Id="[^"]*"' packaging/windows/deckcraft.wxs | grep -vE '\.(ico|exe)"$'; then
+            echo "::error::Icon Id must end in .ico or .exe"; exit 1
+          fi
+          desktop-file-validate packaging/linux/ai.storyteller.deckcraft.desktop
+          sed -e 's/@VERSION@/0.0.0/' -e 's/@DATE@/2026-01-01/' packaging/linux/ai.storyteller.deckcraft.metainfo.xml.in >"$RUNNER_TEMP/ai.storyteller.deckcraft.metainfo.xml"
+          appstreamcli validate --no-net --explain "$RUNNER_TEMP/ai.storyteller.deckcraft.metainfo.xml"
+          python3 - <<'EOF'
+          import yaml
+          src = yaml.safe_load(open("packaging/linux/flatpak/ai.storyteller.deckcraft.yml"))
+          bundle = yaml.safe_load(open("packaging/linux/flatpak/ai.storyteller.deckcraft.bundle.yml"))
+          for m in (src, bundle):
+              assert m["id"] == "ai.storyteller.deckcraft" and m["command"] == "deckcraft", 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
@@ -1,3 +1,16 @@
+# Release pipeline: every push to `release` builds installers for every platform and creates or
+# updates the draft GitHub Release "DeckCraft v<version>" (tag v<version>). Recipe:
+# craftrules release/playbook.md.
+#
+# The version has one source: `[workspace.package] version` in Cargo.toml (`cargo xtask version`,
+# `cargo xtask version set X.Y.Z`). The app shows it in About and `--version`; the release name
+# and tag use it too. workflow_dispatch can override it for a test build (applied to the build).
+#
+# The jobs that sign (macOS, Windows) and the one that drafts the release run in the `release`
+# environment (restricted to the `release` branch), which holds the signing secrets. Every secret
+# is optional: missing ones produce unsigned artifacts and a warning, never a failed build. The
+# other jobs sign nothing and get no secrets, so a workflow_dispatch from another branch is a dry
+# run: they build, the signed jobs are refused by the environment, and no release is drafted.
 name: Release

 on:
@@ -11,33 +24,469 @@ on:
        default: ""

 permissions:
-  contents: write
+  contents: read

 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
+  DECKCRAFT_BUILD_SHA: ${{ github.sha }}
+  INPUT_VERSION: ${{ inputs.version }}
+  # Optional font input (storytold/craft-fonts docs/integration.md); releases always embed it.
+  # This commit adds fonts/latin-manifest.txt (the Latin presentation fonts).
+  CRAFT_FONTS_REF: 43913056ce82a3fdad0ef69f6b88d1dc922a8104
+
 jobs:
+  version:
+    name: version
+    runs-on: ubuntu-latest
+    # No `environment: release`: no secrets needed, so branch dry runs get past it.
+    outputs:
+      version: ${{ steps.v.outputs.version }}
+      date: ${{ steps.v.outputs.date }}
+      prerelease: ${{ steps.v.outputs.prerelease }}
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - id: v
+        name: Resolve version
+        run: |
+          . packaging/common.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 "### DeckCraft v$v (\`${GITHUB_SHA::9}\`)" >>"$GITHUB_STEP_SUMMARY"
+
+  macos:
+    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:
+      DECKCRAFT_VERSION: ${{ needs.version.outputs.version }}
+      DECKCRAFT_BUILD_DATE: ${{ needs.version.outputs.date }}
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - name: Check out craft-fonts
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          repository: storytold/craft-fonts
+          ref: ${{ env.CRAFT_FONTS_REF }}
+          path: craft-fonts
+      - uses: dtolnay/rust-toolchain@686976e191b89faba57d3206551f0f330d8cb249 # stable
+        with:
+          targets: aarch64-apple-darwin, x86_64-apple-darwin
+      - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
+        with:
+          key: release-macos-universal
+      - name: Apply version override
+        if: inputs.version != ''
+        run: cargo xtask version set "$DECKCRAFT_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:
+          CRAFT_FONTS_DIR: ${{ github.workspace }}/craft-fonts
+          CRAFT_FONTS_REQUIRED: "1"
+          APPLE_ID: ${{ secrets.APPLE_ID }}
+          APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
+          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
+        run: packaging/macos/package.sh --arch universal
+      - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        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:
+    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 (x64 signtool / Azure
+          # Trusted Signing) and WiX (-arch arm64) run as above. package.ps1 checks the PE machine
+          # type and skips the CLI smoke test, since an ARM64 exe can't run on the x64 runner.
+          - { arch: arm64, target: aarch64-pc-windows-msvc }
+    env:
+      DECKCRAFT_VERSION: ${{ needs.version.outputs.version }}
+      DECKCRAFT_BUILD_DATE: ${{ needs.version.outputs.date }}
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - name: Check out craft-fonts
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          repository: storytold/craft-fonts
+          ref: ${{ env.CRAFT_FONTS_REF }}
+          path: craft-fonts
+      - uses: dtolnay/rust-toolchain@686976e191b89faba57d3206551f0f330d8cb249 # stable
+        with:
+          targets: ${{ matrix.target }}
+      - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
+        with:
+          key: release-windows-${{ matrix.arch }}
+      - name: Apply version override
+        if: inputs.version != ''
+        shell: bash
+        run: cargo xtask version set "$DECKCRAFT_VERSION"
+      - name: Install WiX
+        shell: pwsh
+        run: dotnet tool install --global wix --version 5.0.2
+      - name: Build, sign, package
+        shell: pwsh
+        env:
+          CRAFT_FONTS_DIR: ${{ github.workspace }}/craft-fonts
+          CRAFT_FONTS_REQUIRED: "1"
+          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 }}
+        run: ./packaging/windows/package.ps1 -Arch ${{ matrix.arch }}
+      - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        with:
+          name: release-windows-${{ matrix.arch }}
+          path: dist/release/*
+          if-no-files-found: error
+
+  linux:
+    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).
+    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-22.04, deb: amd64 }
+          - { arch: aarch64, runner: ubuntu-22.04-arm, deb: arm64 }
+    env:
+      DECKCRAFT_VERSION: ${{ needs.version.outputs.version }}
+      DECKCRAFT_BUILD_DATE: ${{ needs.version.outputs.date }}
+      NFPM_VERSION: 2.47.0
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - name: Check out craft-fonts
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        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 \
+            libasound2-dev 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@686976e191b89faba57d3206551f0f330d8cb249 # stable
+      - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
+        with:
+          key: release-linux-${{ matrix.arch }}
+      - name: Apply version override
+        if: inputs.version != ''
+        run: cargo xtask version set "$DECKCRAFT_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/deckcraft$|metainfo|applications'
+          ldd target/release/deckcraft
+          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@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        with:
+          name: release-linux-${{ matrix.arch }}
+          path: dist/release/*
+          if-no-files-found: error
+
+  flatpak:
+    name: Flatpak ${{ matrix.arch }}
+    needs: [version, linux]
+    # Repackages the Linux job's tarball (the same binaries as the AppImage/deb/rpm, with the
+    # craft-fonts embedded); no Rust build here. packaging/linux/flatpak/ai.storyteller.deckcraft.yml
+    # stays the from-source manifest for Flathub. 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:
+      DECKCRAFT_VERSION: ${{ needs.version.outputs.version }}
+      DECKCRAFT_BUILD_DATE: ${{ needs.version.outputs.date }}
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
+        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 can fail 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/deckcraft-$DECKCRAFT_VERSION-linux-${{ matrix.arch }}.tar.gz"
+      - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        with:
+          name: release-flatpak-${{ matrix.arch }}
+          path: dist/release/*.flatpak
+          if-no-files-found: error
+
+  freebsd:
+    name: FreeBSD x86_64
+    needs: version
+    runs-on: ubuntu-latest
+    # No `environment: release`: this job signs nothing, so it gets no release secrets.
+    timeout-minutes: 240
+    env:
+      DECKCRAFT_VERSION: ${{ needs.version.outputs.version }}
+      DECKCRAFT_BUILD_DATE: ${{ needs.version.outputs.date }}
+      VERSION_OVERRIDE: ${{ inputs.version }}
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - name: Check out craft-fonts
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          repository: storytold/craft-fonts
+          ref: ${{ env.CRAFT_FONTS_REF }}
+          path: craft-fonts
+      - name: Build and package in a FreeBSD VM
+        uses: vmactions/freebsd-vm@c46abacb49f09938ca4e1702d15d836285d694cc # v1.5.9
+        with:
+          release: "14.3"
+          usesh: true
+          cpu: 4
+          mem: 12288
+          envs: DECKCRAFT_VERSION DECKCRAFT_BUILD_DATE DECKCRAFT_BUILD_SHA VERSION_OVERRIDE
+          # Copies the workspace (with dist/release) back; the target dir lives outside it so the
+          # copy stays small.
+          copyback: true
+          prepare: |
+            pkg install -y bash git curl pkgconf cmake python3 libxkbcommon wayland libX11 libXcursor libXrandr libXi libxcb mesa-libs vulkan-loader fontconfig freetype2 alsa-lib
+            curl -fsSL https://sh.rustup.rs | sh -s -- -y --profile minimal
+          run: |
+            . "$HOME/.cargo/env"
+            git config --global --add safe.directory "*"
+            export CARGO_TARGET_DIR="$HOME/target" CRAFT_FONTS_DIR="$PWD/craft-fonts" CRAFT_FONTS_REQUIRED=1
+            if [ -n "$VERSION_OVERRIDE" ]; then cargo xtask version set "$DECKCRAFT_VERSION"; fi
+            bash packaging/freebsd/package.sh
+            tar -tzf dist/release/deckcraft-*-freebsd-x86_64.tar.gz \
+              | grep -E '/bin/deckcraft$|/bin/deckcraft-cli$|/share/applications/ai\.storyteller\.deckcraft\.desktop$'
+      - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        with:
+          name: release-freebsd
+          path: dist/release/*
+          if-no-files-found: error
+
+  web:
+    name: Web (wasm)
+    needs: version
+    runs-on: ubuntu-latest
+    # No `environment: release`: this job signs nothing, so it gets no release secrets.
+    env:
+      DECKCRAFT_VERSION: ${{ needs.version.outputs.version }}
+      DECKCRAFT_BUILD_DATE: ${{ needs.version.outputs.date }}
+      TRUNK_VERSION: 0.21.14
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - name: Check out craft-fonts
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          repository: storytold/craft-fonts
+          ref: ${{ env.CRAFT_FONTS_REF }}
+          path: craft-fonts
+      - uses: dtolnay/rust-toolchain@686976e191b89faba57d3206551f0f330d8cb249 # stable
+        with:
+          targets: wasm32-unknown-unknown
+      - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
+        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 xtask version set "$DECKCRAFT_VERSION"
+      - name: Build and zip
+        env:
+          CRAFT_FONTS_DIR: ${{ github.workspace }}/craft-fonts
+          CRAFT_FONTS_REQUIRED: "1"
+        run: packaging/web/package.sh
+      - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        with:
+          name: release-web
+          path: dist/release/*
+          if-no-files-found: error
+
+  linux-riscv64:
+    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 signs nothing, so it gets no release secrets.
+    env:
+      DECKCRAFT_VERSION: ${{ needs.version.outputs.version }}
+      DECKCRAFT_BUILD_DATE: ${{ needs.version.outputs.date }}
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - name: Check out craft-fonts
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          repository: storytold/craft-fonts
+          ref: ${{ env.CRAFT_FONTS_REF }}
+          path: craft-fonts
+      - uses: dtolnay/rust-toolchain@686976e191b89faba57d3206551f0f330d8cb249 # stable
+        with:
+          targets: riscv64gc-unknown-linux-gnu
+      - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
+        with:
+          key: release-linux-riscv64
+      - name: Apply version override
+        if: inputs.version != ''
+        run: cargo xtask version set "$DECKCRAFT_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 \
+            libasound2-dev:riscv64 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@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        with:
+          name: release-linux-riscv64
+          path: dist/release/*.tar.gz
+          if-no-files-found: error
+
  release:
-    # 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: deckcraft
-      app-title: DeckCraft
-      craft-fonts-ref: 43913056ce82a3fdad0ef69f6b88d1dc922a8104
-      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 }}
+    name: Draft GitHub Release
+    # Every build is required, so the draft always has the full set the README lists. Needing the
+    # signed jobs also keeps branch dry runs from drafting a release.
+    needs: [version, macos, windows, linux, linux-riscv64, flatpak, freebsd, web]
+    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@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
+        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="DeckCraft 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 xtask version set) 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"
@@ -877,7 +877,7 @@ checksum = "0c87e182de0887fd5361989c677c4e8f5000cd9491d6d563161a8f3a5519fc7f"

 [[package]]
 name = "deckcraft"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
 "arboard",
 "cpal",
@@ -896,7 +896,7 @@ dependencies = [

 [[package]]
 name = "deckcraft-anim"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
 "deckcraft-geom",
 "deckcraft-model",
@@ -905,7 +905,7 @@ dependencies = [

 [[package]]
 name = "deckcraft-av1"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
 "deckcraft-bitstream",
 "rayon",
@@ -914,14 +914,14 @@ dependencies = [

 [[package]]
 name = "deckcraft-bitstream"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
 "proptest",
 ]

 [[package]]
 name = "deckcraft-cli"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
 "deckcraft-engine",
 "deckcraft-mcp",
@@ -930,14 +930,14 @@ dependencies = [

 [[package]]
 name = "deckcraft-color"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
 "serde",
 ]

 [[package]]
 name = "deckcraft-engine"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
 "deckcraft-color",
 "deckcraft-fonts",
@@ -959,7 +959,7 @@ dependencies = [

 [[package]]
 name = "deckcraft-fonts"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
 "epaint_default_fonts",
 "harfrust 0.13.3",
@@ -971,7 +971,7 @@ dependencies = [

 [[package]]
 name = "deckcraft-format"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
 "deckcraft-model",
 "serde",
@@ -982,7 +982,7 @@ dependencies = [

 [[package]]
 name = "deckcraft-geom"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
 "kurbo",
 "serde",
@@ -990,7 +990,7 @@ dependencies = [

 [[package]]
 name = "deckcraft-h264"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
 "deckcraft-bitstream",
 "rayon",
@@ -999,7 +999,7 @@ dependencies = [

 [[package]]
 name = "deckcraft-hevc"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
 "deckcraft-bitstream",
 "rayon",
@@ -1008,7 +1008,7 @@ dependencies = [

 [[package]]
 name = "deckcraft-isobmff"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
 "deckcraft-bitstream",
 "thiserror 2.0.21",
@@ -1016,11 +1016,11 @@ dependencies = [

 [[package]]
 name = "deckcraft-matroska"
-version = "0.6.1"
+version = "0.5.0"

 [[package]]
 name = "deckcraft-mcp"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
 "deckcraft-engine",
 "deckcraft-render",
@@ -1030,7 +1030,7 @@ dependencies = [

 [[package]]
 name = "deckcraft-media"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
 "deckcraft-av1",
 "deckcraft-h264",
@@ -1048,7 +1048,7 @@ dependencies = [

 [[package]]
 name = "deckcraft-model"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
 "deckcraft-color",
 "deckcraft-geom",
@@ -1059,15 +1059,15 @@ dependencies = [

 [[package]]
 name = "deckcraft-ogg"
-version = "0.6.1"
+version = "0.5.0"

 [[package]]
 name = "deckcraft-opus"
-version = "0.6.1"
+version = "0.5.0"

 [[package]]
 name = "deckcraft-pdf"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
 "deckcraft-fonts",
 "deckcraft-model",
@@ -1082,7 +1082,7 @@ dependencies = [

 [[package]]
 name = "deckcraft-pptx"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
 "deckcraft-color",
 "deckcraft-engine",
@@ -1098,7 +1098,7 @@ dependencies = [

 [[package]]
 name = "deckcraft-render"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
 "deckcraft-color",
 "deckcraft-fonts",
@@ -1114,7 +1114,7 @@ dependencies = [

 [[package]]
 name = "deckcraft-text"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
 "chrono",
 "deckcraft-color",
@@ -1128,7 +1128,7 @@ dependencies = [

 [[package]]
 name = "deckcraft-ui-egui"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
 "deckcraft-anim",
 "deckcraft-color",
@@ -1150,7 +1150,7 @@ dependencies = [

 [[package]]
 name = "deckcraft-vp9"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
 "deckcraft-bitstream",
 "rayon",
@@ -1159,7 +1159,7 @@ dependencies = [

 [[package]]
 name = "deckcraft-web"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
 "deckcraft-engine",
 "deckcraft-ui-egui",
@@ -5655,7 +5655,7 @@ checksum = "9440ea3e5aeabb0ac63af70daf835274065238cdd0cec83418f417eae38bacee"

 [[package]]
 name = "xtask"
-version = "0.6.1"
+version = "0.5.0"
 dependencies = [
 "serde_json",
 ]
@@ -4,7 +4,7 @@ members = ["crates/*", "apps/*", "xtask"]
 default-members = ["crates/*", "apps/deckcraft", "apps/deckcraft-cli"]

 [workspace.package]
-version = "0.6.1"
+version = "0.5.0"
 edition = "2024"
 license = "MIT OR Apache-2.0"
 rust-version = "1.90"
@@ -483,7 +483,6 @@ fn insert_layout(s: &mut Session, p: &Value) -> Result<Value> {
                background: None,
                show_master_shapes: true,
                preserve: true,
-                color_map: None,
                raw_ext: None,
            },
        );
@@ -243,7 +243,6 @@ pub fn build_master(size: Size, theme: Theme, first_id: u32) -> (Master, u32) {
            background: None,
            show_master_shapes: true,
            preserve: true,
-            color_map: None,
            raw_ext: None,
        });
    };
@@ -488,10 +488,6 @@ pub struct Slide {
    /// Speaker notes.
    pub notes: TextBody,
    pub comments: Vec<Comment>,
-    /// `clrMapOvr`: a colour map replacing the layout's or master's (`bg1`→`dk1`…); None follows
-    /// the layout.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub color_map: Option<Vec<(String, String)>>,
    /// Unmodelled XML kept for round-trip (custom data, tags).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub raw_ext: Option<String>,
@@ -511,7 +507,6 @@ impl Default for Slide {
            animations: vec![],
            notes: TextBody::default(),
            comments: vec![],
-            color_map: None,
            raw_ext: None,
        }
    }
@@ -601,10 +596,6 @@ pub struct Layout {
    pub background: Option<Background>,
    pub show_master_shapes: bool,
    pub preserve: bool,
-    /// `clrMapOvr`: a colour map replacing the master's for this layout and the slides using it
-    /// (dark "section" layouts map `bg1` to `dk1`); None follows the master.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub color_map: Option<Vec<(String, String)>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub raw_ext: Option<String>,
 }
@@ -650,17 +641,24 @@ impl Master {
    }
    /// Resolve `bg1`/`tx1`/`bg2`/`tx2` through the colour map.
    pub fn map_slot(&self, slot: SchemeSlot) -> SchemeSlot {
-        map_slot(&self.color_map, slot)
+        let key = match slot {
+            SchemeSlot::Bg1 => "bg1",
+            SchemeSlot::Tx1 => "tx1",
+            SchemeSlot::Bg2 => "bg2",
+            SchemeSlot::Tx2 => "tx2",
+            other => return other,
+        };
+        self.color_map.iter().find(|(k, _)| k == key).and_then(|(_, v)| SchemeSlot::from_xml(v)).unwrap_or(match slot {
+            SchemeSlot::Bg1 => SchemeSlot::Lt1,
+            SchemeSlot::Tx1 => SchemeSlot::Dk1,
+            SchemeSlot::Bg2 => SchemeSlot::Lt2,
+            _ => SchemeSlot::Dk2,
+        })
    }
    /// The theme's colour scheme with the colour map applied (`bg1`… resolve to mapped colours).
    pub fn scheme(&self) -> ColorScheme {
-        self.scheme_with(&self.color_map)
-    }
-    /// The theme's colour scheme with `map` (a layout's or slide's override, or the master's own)
-    /// applied.
-    pub fn scheme_with(&self, map: &[(String, String)]) -> ColorScheme {
        let mut s = self.theme.colors.clone();
-        if map.is_empty() {
+        if self.color_map.is_empty() {
            return s;
        }
        let base = self.theme.colors.clone();
@@ -670,30 +668,12 @@ impl Master {
            (SchemeSlot::Bg2, SchemeSlot::Lt2),
            (SchemeSlot::Tx2, SchemeSlot::Dk2),
        ] {
-            s.set(slot, base.get(map_slot(map, alias)));
+            s.set(slot, base.get(self.map_slot(alias)));
        }
        s
    }
 }

-/// Resolve `bg1`/`tx1`/`bg2`/`tx2` through the colour map `map` (the default mapping when it has
-/// no entry).
-pub fn map_slot(map: &[(String, String)], slot: SchemeSlot) -> SchemeSlot {
-    let key = match slot {
-        SchemeSlot::Bg1 => "bg1",
-        SchemeSlot::Tx1 => "tx1",
-        SchemeSlot::Bg2 => "bg2",
-        SchemeSlot::Tx2 => "tx2",
-        other => return other,
-    };
-    map.iter().find(|(k, _)| k == key).and_then(|(_, v)| SchemeSlot::from_xml(v)).unwrap_or(match slot {
-        SchemeSlot::Bg1 => SchemeSlot::Lt1,
-        SchemeSlot::Tx1 => SchemeSlot::Dk1,
-        SchemeSlot::Bg2 => SchemeSlot::Lt2,
-        _ => SchemeSlot::Dk2,
-    })
-}
-
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
 #[serde(default, rename_all = "camelCase")]
 pub struct Section {
@@ -22,27 +22,23 @@ pub struct Ctx<'a> {
    pub layout: Option<&'a Layout>,
    pub owner: Owner,
    pub scheme: ColorScheme,
-    /// The colour map in force: the slide's override, else its layout's, else the master's.
-    pub color_map: Vec<(String, String)>,
 }

 impl<'a> Ctx<'a> {
    pub fn for_slide(pres: &'a Presentation, slide: &Slide) -> Option<Ctx<'a>> {
        let (master, layout) = pres.master_for(slide)?;
-        let map = slide.color_map.as_ref().or(layout.and_then(|l| l.color_map.as_ref())).unwrap_or(&master.color_map).clone();
-        Some(Ctx { pres, master, layout, owner: Owner::Slide, scheme: master.scheme_with(&map), color_map: map })
+        Some(Ctx { pres, master, layout, owner: Owner::Slide, scheme: master.scheme() })
    }
    pub fn for_layout(pres: &'a Presentation, master: &'a Master, layout: &'a Layout) -> Ctx<'a> {
-        let map = layout.color_map.as_ref().unwrap_or(&master.color_map).clone();
-        Ctx { pres, master, layout: Some(layout), owner: Owner::Layout, scheme: master.scheme_with(&map), color_map: map }
+        Ctx { pres, master, layout: Some(layout), owner: Owner::Layout, scheme: master.scheme() }
    }
    pub fn for_master(pres: &'a Presentation, master: &'a Master) -> Ctx<'a> {
-        Ctx { pres, master, layout: None, owner: Owner::Master, scheme: master.scheme(), color_map: master.color_map.clone() }
+        Ctx { pres, master, layout: None, owner: Owner::Master, scheme: master.scheme() }
    }
    pub fn color(&self, c: &ColorRef, ph: Option<Rgba>) -> Rgba {
        let c = match &c.base {
            crate::ColorBase::Scheme { slot } if matches!(slot, SchemeSlot::Bg1 | SchemeSlot::Tx1 | SchemeSlot::Bg2 | SchemeSlot::Tx2) => {
-                ColorRef { base: crate::ColorBase::Scheme { slot: crate::map_slot(&self.color_map, *slot) }, mods: c.mods.clone() }
+                ColorRef { base: crate::ColorBase::Scheme { slot: self.master.map_slot(*slot) }, mods: c.mods.clone() }
            }
            _ => c.clone(),
        };
@@ -159,31 +159,3 @@ fn hyperlinked_runs_take_the_theme_hyperlink_look() {
    let dbl = resolve::run(&ctx, title, &para, &RunProps { link, underline: Some("dbl".into()), ..Default::default() });
    assert_eq!((dbl.fill, dbl.underline.as_deref()), (hlink, Some("dbl")));
 }
-
-#[test]
-fn a_layout_colour_map_override_applies_to_its_slides() {
-    // A dark "section" layout maps bg1→dk1 and tx1→lt1; a slide on it that keeps the master
-    // mapping (`masterClrMapping`) follows the layout, as PowerPoint draws it.
-    let mut p = Presentation::default();
-    let dark: Vec<(String, String)> =
-        [("bg1", "dk1"), ("tx1", "lt1"), ("bg2", "dk2"), ("tx2", "lt2")].iter().map(|(a, b)| (a.to_string(), b.to_string())).collect();
-    let layout = p.slides[0].layout;
-    let m = std::sync::Arc::make_mut(&mut p.masters[0]);
-    let colors = m.theme.colors.clone();
-    m.layouts.iter_mut().find(|l| l.id == layout).unwrap().color_map = Some(dark.clone());
-    let s: Slide = (*p.slides[0]).clone();
-    let ctx = Ctx::for_slide(&p, &s).unwrap();
-    assert_eq!(ctx.color(&ColorRef::scheme(SchemeSlot::Bg1), None), colors.get(SchemeSlot::Dk1));
-    assert_eq!(ctx.color(&ColorRef::scheme(SchemeSlot::Tx2), None), colors.get(SchemeSlot::Lt2));
-    assert_eq!(ctx.scheme.get(SchemeSlot::Lt1), colors.get(SchemeSlot::Dk1));
-    // The slide's own override wins over the layout's.
-    let mut own = s.clone();
-    own.color_map = Some([("bg1", "lt1"), ("tx1", "dk1")].iter().map(|(a, b)| (a.to_string(), b.to_string())).collect());
-    let ctx = Ctx::for_slide(&p, &own).unwrap();
-    assert_eq!(ctx.color(&ColorRef::scheme(SchemeSlot::Bg1), None), colors.get(SchemeSlot::Lt1));
-    // The layout itself draws with its override; the master keeps its own map.
-    let m = &p.masters[0];
-    let l = m.layout(layout).unwrap();
-    assert_eq!(Ctx::for_layout(&p, m, l).color(&ColorRef::scheme(SchemeSlot::Bg1), None), colors.get(SchemeSlot::Dk1));
-    assert_eq!(Ctx::for_master(&p, m).color(&ColorRef::scheme(SchemeSlot::Bg1), None), colors.get(SchemeSlot::Lt1));
-}
@@ -77,12 +77,6 @@ pub fn fill_el(imp: &mut Imp, part: &Part, f: &El) -> Option<Fill> {
        "solidFill" => Fill::Solid { color: color(f).unwrap_or(ColorRef::rgb(Rgba::BLACK)) },
        "gradFill" => Fill::Gradient(gradient(f)),
        "blipFill" => match blip_fill(imp, part, f) {
-            // A picture filling a shape or background with neither `a:stretch` nor `a:tile` is
-            // tiled at its own size, as PowerPoint draws it.
-            Some(mut p) if f.child("stretch").is_none() && f.child("tile").is_none() => {
-                p.mode = PictureMode::Tile { tx: 0.0, ty: 0.0, sx: 1.0, sy: 1.0, flip: "none".into(), align: "tl".into() };
-                Fill::Picture(p)
-            }
            Some(p) => Fill::Picture(p),
            None => Fill::None,
        },
@@ -14,7 +14,7 @@ use std::sync::Arc;
 use deckcraft_geom::{Size, emu_to_pt};
 use deckcraft_model::text::TextBody;
 use deckcraft_model::{
-    Background, Comment, CustomShow, Geom, HeaderFooter, Layout, LayoutId, LayoutType, Master, MasterId, MediaId, MediaItem, PhType, Presentation,
+    Background, Comment, CustomShow, HeaderFooter, Layout, LayoutId, LayoutType, Master, MasterId, MediaId, MediaItem, PhType, Presentation,
    Properties, Section, ShowSettings, Slide, SlideId, defaults,
 };

@@ -387,7 +387,6 @@ pub fn import(bytes: &[u8]) -> Result<Presentation, PptxError> {
        p.props.company = d.root.child("Company").map(|c| c.text()).unwrap_or_default();
    }

-    inherit_placeholder_geometry(&mut p);
    p.header_footer = header_footer(&p);
    p.media = std::mem::take(&mut imp.media);
    p.next_id = imp.next;
@@ -420,91 +419,6 @@ pub fn color_map(cm: &El) -> Vec<(String, String)> {
    cm.attrs.iter().filter(|(k, _)| !k.starts_with("xmlns")).map(|(k, v)| (k.clone(), v.clone())).collect()
 }

-/// Placeholders read without a geometry (an empty custom geometry, see `shapes::sp`) take the
-/// geometry of the layout or master placeholder they inherit from, as PowerPoint draws them: a
-/// layout's picture placeholder cut into a shape keeps that shape on the slide. Anything left
-/// is a rectangle.
-fn inherit_placeholder_geometry(p: &mut Presentation) {
-    let unset = |g: &Geom| matches!(g, Geom::Custom { paths } if paths.is_empty());
-    // Masters first, then layouts (from their masters), then slides (from layouts and masters).
-    for m in &mut p.masters {
-        let m = Arc::make_mut(m);
-        walk_shapes_mut(&mut m.shapes, &mut |s| {
-            if unset(&s.geom) {
-                s.geom = Geom::default();
-            }
-        });
-    }
-    let mut layout_geoms: Vec<(LayoutId, usize, Geom)> = vec![];
-    for m in &p.masters {
-        for l in &m.layouts {
-            let ctx = deckcraft_model::resolve::Ctx::for_layout(p, m, l);
-            for (i, s) in l.shapes.iter().enumerate() {
-                if unset(&s.geom) {
-                    let (_, mp) = deckcraft_model::resolve::parents(&ctx, s);
-                    layout_geoms.push((l.id, i, mp.map(|m| m.geom.clone()).filter(|g| !unset(g)).unwrap_or_default()));
-                }
-            }
-        }
-    }
-    for m in &mut p.masters {
-        let m = Arc::make_mut(m);
-        for l in &mut m.layouts {
-            for (id, i, g) in layout_geoms.iter().filter(|(id, _, _)| *id == l.id) {
-                let _ = id;
-                if let Some(s) = l.shapes.get_mut(*i) {
-                    s.geom = g.clone();
-                }
-            }
-        }
-    }
-    let mut slide_geoms: Vec<(usize, usize, Geom)> = vec![];
-    for (si, sl) in p.slides.iter().enumerate() {
-        let Some(ctx) = deckcraft_model::resolve::Ctx::for_slide(p, sl) else { continue };
-        for (i, s) in sl.shapes.iter().enumerate() {
-            if unset(&s.geom) {
-                let (lp, mp) = deckcraft_model::resolve::parents(&ctx, s);
-                let g = lp.map(|l| l.geom.clone()).filter(|g| !unset(g)).or_else(|| mp.map(|m| m.geom.clone()).filter(|g| !unset(g)));
-                slide_geoms.push((si, i, g.unwrap_or_default()));
-            }
-        }
-    }
-    for (si, i, g) in slide_geoms {
-        if let Some(sl) = p.slides.get_mut(si)
-            && let Some(s) = Arc::make_mut(sl).shapes.get_mut(i)
-        {
-            s.geom = g;
-        }
-    }
-    // Placeholders inside groups (rare) and anything still unset: rectangles.
-    for sl in &mut p.slides {
-        walk_shapes_mut(&mut Arc::make_mut(sl).shapes, &mut |s| {
-            if unset(&s.geom) {
-                s.geom = Geom::default();
-            }
-        });
-    }
-    for m in &mut p.masters {
-        for l in &mut Arc::make_mut(m).layouts {
-            walk_shapes_mut(&mut l.shapes, &mut |s| {
-                if unset(&s.geom) {
-                    s.geom = Geom::default();
-                }
-            });
-        }
-    }
-}
-
-/// Every shape, groups included.
-fn walk_shapes_mut(shapes: &mut [deckcraft_model::Shape], f: &mut dyn FnMut(&mut deckcraft_model::Shape)) {
-    for s in shapes {
-        f(s);
-        if let deckcraft_model::ShapeKind::Group { children, .. } = &mut s.kind {
-            walk_shapes_mut(children, f);
-        }
-    }
-}
-
 fn background(imp: &mut Imp, part: &Part, csld: &El) -> Option<Background> {
    let bg = csld.child("bg")?;
    if let Some(pr) = bg.child("bgPr") {
@@ -609,18 +523,12 @@ fn read_layout(imp: &mut Imp, part: &Part, doc: &Doc) -> Layout {
            l.shapes = shapes::sp_tree(imp, part, &mut ctx, tree, 0);
        }
    }
-    l.color_map = color_map_override(root);
    if let Some(ext) = root.child("extLst").filter(|e| !has_rel_refs(e)) {
        l.raw_ext = Some(ext.elements().map(|e| part.keep(e)).collect());
    }
    l
 }

-/// A layout's or slide's `clrMapOvr/overrideClrMapping` (None for `masterClrMapping` or none).
-fn color_map_override(root: &El) -> Option<Vec<(String, String)>> {
-    root.child("clrMapOvr")?.child("overrideClrMapping").map(color_map)
-}
-
 fn read_slide(imp: &mut Imp, part: &Part, doc: &Doc, id: SlideId, layout: LayoutId) -> Slide {
    let root = &doc.root;
    let mut s = Slide {
@@ -628,7 +536,6 @@ fn read_slide(imp: &mut Imp, part: &Part, doc: &Doc, id: SlideId, layout: Layout
        layout,
        hidden: root.bool("show") == Some(false),
        show_master_shapes: root.bool("showMasterSp").unwrap_or(true),
-        color_map: color_map_override(root),
        ..Default::default()
    };
    let mut ctx = shapes::IdCtx::default();
@@ -180,15 +180,6 @@ fn preset_geom(pg: &El) -> Geom {
    Geom::Preset { name, adj }
 }

-/// A placeholder whose `spPr` names no geometry takes its layout's (or master's) placeholder's:
-/// marked here with an empty custom geometry, filled in once the layouts are read
-/// (`inherit_placeholder_geometry`).
-fn mark_inherited_geometry(s: &mut Shape, pr: Option<&El>) {
-    if s.ph.is_some() && pr.is_none_or(|pr| pr.child("prstGeom").is_none() && pr.child("custGeom").is_none()) {
-        s.geom = Geom::Custom { paths: vec![] };
-    }
-}
-
 /// `spPr` → transform, geometry, fill, line, effects.
 fn sp_pr(imp: &mut Imp, part: &Part, s: &mut Shape, pr: &El) {
    if let Some(x) = pr.child("xfrm") {
@@ -238,7 +229,6 @@ fn sp(imp: &mut Imp, part: &Part, ctx: &mut IdCtx, e: &El) -> Shape {
    if let Some(pr) = e.child("spPr") {
        sp_pr(imp, part, &mut s, pr);
    }
-    mark_inherited_geometry(&mut s, e.child("spPr"));
    if e.bool("useBgFill") == Some(true) {
        s.fill = Some(Fill::Background);
    }
@@ -227,21 +227,6 @@ const CLR_KEYS: [(&str, &str); 12] = [
 ];

 fn clr_map(w: &mut W, map: &[(String, String)]) {
-    w.empty("p:clrMap", clr_map_attrs(map));
-}
-
-/// `p:clrMapOvr`: the layout's or slide's own colour map, else `a:masterClrMapping`.
-fn clr_map_ovr(w: &mut W, map: Option<&[(String, String)]>) {
-    w.open0("p:clrMapOvr");
-    match map {
-        Some(m) => w.empty("a:overrideClrMapping", clr_map_attrs(m)),
-        None => w.empty0("a:masterClrMapping"),
-    }
-    w.close("p:clrMapOvr");
-}
-
-/// The twelve colour map attributes, each a theme slot (the default for anything else).
-fn clr_map_attrs(map: &[(String, String)]) -> A {
    let mut a = A::new();
    for (k, d) in CLR_KEYS {
        let v = map
@@ -252,7 +237,7 @@ fn clr_map_attrs(map: &[(String, String)]) -> A {
            .unwrap_or(d);
        a = a.a(k, v);
    }
-    a
+    w.empty("p:clrMap", a);
 }

 fn ext_list(w: &mut W, raw: Option<&str>) {
@@ -537,7 +522,9 @@ fn layout_xml(x: &mut Exp, o: &mut Out, l: &Layout) -> Vec<u8> {
        A::new().o("showMasterSp", (!l.show_master_shapes).then_some("0")).a("type", l.kind.xml()).t("preserve", l.preserve),
    );
    csld(&mut w, x, o, &l.name, l.background.as_ref(), &l.shapes);
-    clr_map_ovr(&mut w, l.color_map.as_deref());
+    w.open0("p:clrMapOvr");
+    w.empty0("a:masterClrMapping");
+    w.close("p:clrMapOvr");
    ext_list(&mut w, ext_children(l.raw_ext.as_deref()).as_deref());
    w.close("p:sldLayout");
    w.finish()
@@ -569,7 +556,9 @@ fn slide_xml(x: &mut Exp, o: &mut Out, s: &Slide) -> Vec<u8> {
    let mut w = W::new();
    root_open(&mut w, "p:sld", A::new().o("showMasterSp", (!s.show_master_shapes).then_some("0")).o("show", s.hidden.then_some("0")));
    let ids = csld(&mut w, x, o, &s.name, s.background.as_ref(), &s.shapes);
-    clr_map_ovr(&mut w, s.color_map.as_deref());
+    w.open0("p:clrMapOvr");
+    w.empty0("a:masterClrMapping");
+    w.close("p:clrMapOvr");
    if let Some(t) = &s.transition {
        timing::transition(&mut w, x, o, t);
    }
@@ -1,81 +0,0 @@
-//! Fills read from decks written by other tools.
-
-use std::io::{Cursor, Read, Write};
-
-use deckcraft_geom::Xfrm;
-use deckcraft_model::style::{Fill, PictureFill, PictureMode};
-use deckcraft_model::{Shape, ShapeId, defaults};
-
-/// `bytes` with `edit` applied to every slide part.
-fn edit_slides(bytes: &[u8], edit: impl Fn(String) -> String) -> Vec<u8> {
-    let mut z = zip::ZipArchive::new(Cursor::new(bytes)).expect("zip");
-    let mut out = zip::ZipWriter::new(Cursor::new(Vec::new()));
-    let o = zip::write::SimpleFileOptions::default();
-    for i in 0..z.len() {
-        let mut f = z.by_index(i).expect("entry");
-        let mut d = vec![];
-        f.read_to_end(&mut d).expect("read");
-        let name = f.name().to_string();
-        if name.starts_with("ppt/slides/slide") && name.ends_with(".xml") {
-            d = edit(String::from_utf8(d).expect("utf8")).into_bytes();
-        }
-        out.start_file(name, o).expect("start");
-        out.write_all(&d).expect("write");
-    }
-    out.finish().expect("finish").into_inner()
-}
-
-fn png() -> Vec<u8> {
-    let mut out = Cursor::new(vec![]);
-    image::DynamicImage::ImageRgb8(image::RgbImage::from_pixel(4, 4, image::Rgb([10, 200, 30])))
-        .write_to(&mut out, image::ImageFormat::Png)
-        .expect("png");
-    out.into_inner()
-}
-
-/// A deck with one shape filled with a stretched picture, exported.
-fn deck() -> Vec<u8> {
-    let mut p = defaults::new_presentation(None);
-    let media = p.add_media("tile.png", "image/png", png());
-    let id = ShapeId(p.alloc_id());
-    let first = p.slides[0].id;
-    p.slide_mut(first).expect("slide").shapes.push(Shape {
-        id,
-        name: "Textured".into(),
-        xfrm: Some(Xfrm::new(10.0, 10.0, 200.0, 100.0)),
-        fill: Some(Fill::Picture(PictureFill { media, ..Default::default() })),
-        ..Default::default()
-    });
-    deckcraft_pptx::export(&p).expect("export")
-}
-
-fn textured_mode(bytes: &[u8]) -> PictureMode {
-    let q = deckcraft_pptx::import(bytes).expect("import");
-    let s = q.slides[0].shapes.iter().find(|s| s.name == "Textured").expect("shape");
-    match &s.fill {
-        Some(Fill::Picture(pf)) => pf.mode.clone(),
-        other => panic!("{other:?}"),
-    }
-}
-
-#[test]
-fn a_shape_picture_fill_without_stretch_or_tile_tiles() {
-    // tdf#128596: `<a:blipFill><a:blip/></a:blipFill>` on a shape, as some tools write it;
-    // PowerPoint tiles the picture at its own size.
-    let bare = edit_slides(&deck(), |s| {
-        let s = regex_free_strip(&s, "<a:stretch>", "</a:stretch>");
-        assert!(!s.contains("<a:stretch"), "the test deck lost its stretch");
-        s
-    });
-    assert!(matches!(textured_mode(&bare), PictureMode::Tile { sx, sy, .. } if sx == 1.0 && sy == 1.0));
-    // An explicit stretch is still a stretch.
-    assert!(matches!(textured_mode(&deck()), PictureMode::Stretch { .. }));
-}
-
-/// `s` without the first `open`…`close` span inside a `blipFill`.
-fn regex_free_strip(s: &str, open: &str, close: &str) -> String {
-    let Some(b) = s.find("<a:blipFill") else { return s.to_string() };
-    let Some(i) = s[b..].find(open).map(|i| i + b) else { return s.to_string() };
-    let Some(j) = s[i..].find(close).map(|j| j + i + close.len()) else { return s.to_string() };
-    format!("{}{}", &s[..i], &s[j..])
-}
@@ -1,64 +0,0 @@
-//! Placeholder inheritance in decks written by PowerPoint.
-
-use std::io::{Cursor, Read, Write};
-
-use deckcraft_model::{Geom, defaults};
-
-/// `bytes` with `edit` applied to every slide part.
-fn edit_slides(bytes: &[u8], edit: impl Fn(String) -> String) -> Vec<u8> {
-    let mut z = zip::ZipArchive::new(Cursor::new(bytes)).expect("zip");
-    let mut out = zip::ZipWriter::new(Cursor::new(Vec::new()));
-    let o = zip::write::SimpleFileOptions::default();
-    for i in 0..z.len() {
-        let mut f = z.by_index(i).expect("entry");
-        let mut d = vec![];
-        f.read_to_end(&mut d).expect("read");
-        let name = f.name().to_string();
-        if name.starts_with("ppt/slides/slide") && name.ends_with(".xml") {
-            d = edit(String::from_utf8(d).expect("utf8")).into_bytes();
-        }
-        out.start_file(name, o).expect("start");
-        out.write_all(&d).expect("write");
-    }
-    out.finish().expect("finish").into_inner()
-}
-
-#[test]
-fn a_placeholder_without_geometry_takes_its_layouts() {
-    // PowerPoint leaves a slide placeholder's spPr empty and draws it with the layout
-    // placeholder's geometry (a picture placeholder cut into a shape keeps the shape).
-    let mut p = defaults::new_presentation(None);
-    let layout = p.slides[0].layout;
-    let m = std::sync::Arc::make_mut(&mut p.masters[0]);
-    let l = m.layouts.iter_mut().find(|l| l.id == layout).expect("layout");
-    for s in &mut l.shapes {
-        if s.ph.is_some() {
-            s.geom = Geom::Preset { name: "ellipse".into(), adj: vec![] };
-        }
-    }
-    let bytes = deckcraft_pptx::export(&p).expect("export");
-    // Strip the slide's own geometry, as PowerPoint writes inheriting placeholders.
-    let bare = edit_slides(&bytes, |s| {
-        let mut s = s;
-        while let Some(i) = s.find("<a:prstGeom") {
-            let Some(j) = s[i..].find("</a:prstGeom>").map(|j| j + i + "</a:prstGeom>".len()) else { break };
-            s.replace_range(i..j, "");
-        }
-        s
-    });
-    let q = deckcraft_pptx::import(&bare).expect("import");
-    let phs: Vec<_> = q.slides[0].shapes.iter().filter(|s| s.ph.is_some()).collect();
-    assert!(!phs.is_empty());
-    for s in phs {
-        assert!(matches!(&s.geom, Geom::Preset { name, .. } if name == "ellipse"), "{:?}", s.geom);
-    }
-    // A placeholder with its own geometry keeps it.
-    let first = p.slides[0].id;
-    for s in &mut p.slide_mut(first).expect("slide").shapes {
-        if s.ph.is_some() {
-            s.geom = Geom::Preset { name: "triangle".into(), adj: vec![] };
-        }
-    }
-    let q = deckcraft_pptx::import(&deckcraft_pptx::export(&p).expect("export")).expect("import");
-    assert!(q.slides[0].shapes.iter().filter(|s| s.ph.is_some()).all(|s| matches!(&s.geom, Geom::Preset { name, .. } if name == "triangle")));
-}
@@ -730,39 +730,3 @@ fn date_fields_keep_their_type_and_saved_text() {
        assert_eq!(by_name(&q.slides[0], name).text, by_name(&p.slides[0], name).text, "{name}");
    }
 }
-
-#[test]
-fn colour_map_overrides_round_trip() {
-    let mut p = defaults::new_presentation(None);
-    let dark: Vec<(String, String)> =
-        [("bg1", "dk1"), ("tx1", "lt1"), ("bg2", "dk2"), ("tx2", "lt2")].iter().map(|(a, b)| (a.to_string(), b.to_string())).collect();
-    let layout = p.slides[0].layout;
-    std::sync::Arc::make_mut(&mut p.masters[0]).layouts.iter_mut().find(|l| l.id == layout).expect("layout").color_map = Some(dark.clone());
-    let first = p.slides[0].id;
-    p.slide_mut(first).expect("slide").color_map = Some(dark.clone());
-    let q = round(&p);
-    let get = |m: &Option<Vec<(String, String)>>, k: &str| m.as_ref().and_then(|m| m.iter().find(|(a, _)| a == k).map(|(_, v)| v.clone()));
-    let ql = q.masters[0].layouts.iter().find(|l| l.color_map.is_some()).expect("the layout keeps its override");
-    assert_eq!(get(&ql.color_map, "bg1").as_deref(), Some("dk1"));
-    assert_eq!(get(&q.slides[0].color_map, "tx1").as_deref(), Some("lt1"));
-    // Layouts and slides without one keep following the master.
-    assert!(q.masters[0].layouts.iter().filter(|l| l.color_map.is_none()).count() >= 1);
-}
-
-#[test]
-fn a_picture_duotone_round_trips() {
-    let mut p = defaults::new_presentation(None);
-    let img = p.add_media("image1.png", "image/png", png(4, 4, [128, 128, 128]));
-    let mut pic = shape(&mut p, "Duotone", 10.0, 10.0, 100.0, 100.0);
-    let mut pf = PictureFill { media: img, ..Default::default() };
-    pf.adjust.duotone = Some((ColorRef::scheme(SchemeSlot::Accent1).with(ColorTransform::Shade(30000)), ColorRef::rgb(Rgba::rgb(250, 240, 200))));
-    pic.kind = deckcraft_model::ShapeKind::Picture { fill: pf };
-    let first = p.slides[0].id;
-    p.slide_mut(first).expect("slide").shapes.push(pic);
-    let q = round(&p);
-    let sh = by_name(&q.slides[0], "Duotone");
-    let deckcraft_model::ShapeKind::Picture { fill } = &sh.kind else { panic!("picture") };
-    let (d, l) = fill.adjust.duotone.as_ref().expect("duotone kept");
-    assert!(matches!(d.base, deckcraft_model::ColorBase::Scheme { slot: SchemeSlot::Accent1 }));
-    assert!(matches!(l.base, deckcraft_model::ColorBase::Rgb { rgb } if rgb == Rgba::rgb(250, 240, 200)));
-}
@@ -79,26 +79,9 @@ fn adjust_key(a: &PictureAdjust) -> u64 {
    if let Some(c) = a.clear_color {
        mix(((c.r as u64) << 16) | ((c.g as u64) << 8) | c.b as u64 | 1 << 40);
    }
-    if let Some((d, l)) = duotone_rgb(a) {
-        for c in [d, l] {
-            mix(((c.r as u64) << 24) | ((c.g as u64) << 16) | ((c.b as u64) << 8) | c.a as u64 | 1 << 41);
-        }
-    }
    h
 }

-/// The duotone's dark and light colours. The painter resolves them to plain RGB first (see
-/// `paint::resolved`); a colour that is still a scheme reference falls back to black and white.
-fn duotone_rgb(a: &PictureAdjust) -> Option<(deckcraft_color::Rgba, deckcraft_color::Rgba)> {
-    use deckcraft_model::style::ColorBase;
-    let (d, l) = a.duotone.as_ref()?;
-    let rgb = |c: &deckcraft_model::style::ColorRef, or: deckcraft_color::Rgba| match &c.base {
-        ColorBase::Rgb { rgb } if c.mods.is_empty() => *rgb,
-        _ => or,
-    };
-    Some((rgb(d, deckcraft_color::Rgba::BLACK), rgb(l, deckcraft_color::Rgba::WHITE)))
-}
-
 /// Decode encoded bytes (PNG, JPEG, GIF, WebP, BMP, TIFF) to straight RGBA.
 pub fn decode(bytes: &[u8]) -> Option<image::RgbaImage> {
    if bytes.len() > 512 << 20 {
@@ -250,7 +233,6 @@ fn apply_adjust(img: &mut image::RgbaImage, a: &PictureAdjust) {
    if a.brightness == 0.0 && a.contrast == 0.0 && sat == 1.0 && !a.grayscale && a.clear_color.is_none() && a.duotone.is_none() {
        return;
    }
-    let duo = duotone_rgb(a);
    let b = a.brightness.clamp(-1.0, 1.0) * 255.0;
    let c = a.contrast.clamp(-1.0, 1.0);
    let cf = if c >= 0.0 { 1.0 / (1.0 - c * 0.99) } else { 1.0 + c };
@@ -270,12 +252,6 @@ fn apply_adjust(img: &mut image::RgbaImage, a: &PictureAdjust) {
            *v = y + (*v - y) * s;
            *v = (*v - 128.0) * cf + 128.0 + b;
        }
-        // Duotone: the pixel's luminance picks a colour between the dark and the light one.
-        if let Some((d, l)) = duo {
-            let t = ((0.299 * rgb[0] + 0.587 * rgb[1] + 0.114 * rgb[2]) / 255.0).clamp(0.0, 1.0);
-            rgb =
-                [d.r as f64 + (l.r as f64 - d.r as f64) * t, d.g as f64 + (l.g as f64 - d.g as f64) * t, d.b as f64 + (l.b as f64 - d.b as f64) * t];
-        }
        for (i, v) in rgb.iter().enumerate() {
            if let Some(ch) = p.0.get_mut(i) {
                *ch = v.round().clamp(0.0, 255.0) as u8;
@@ -290,25 +266,6 @@ mod tests {

    use super::*;

-    #[test]
-    fn duotone_maps_luminance_between_its_two_colours() {
-        use deckcraft_color::Rgba;
-        use deckcraft_model::style::ColorRef;
-        let mut img = image::RgbaImage::from_fn(3, 1, |x, _| image::Rgba([[0, 0, 0, 255], [128, 128, 128, 200], [255, 255, 255, 255]][x as usize]));
-        let adj =
-            PictureAdjust { duotone: Some((ColorRef::rgb(Rgba::rgb(100, 40, 0)), ColorRef::rgb(Rgba::rgb(250, 240, 200)))), ..Default::default() };
-        apply_adjust(&mut img, &adj);
-        assert_eq!(img.get_pixel(0, 0).0, [100, 40, 0, 255], "black takes the dark colour");
-        assert_eq!(img.get_pixel(2, 0).0, [250, 240, 200, 255], "white takes the light colour");
-        let mid = img.get_pixel(1, 0).0;
-        assert!((mid[0] as i32 - 175).abs() <= 1 && (mid[1] as i32 - 140).abs() <= 1 && (mid[2] as i32 - 100).abs() <= 1, "{mid:?}");
-        assert_eq!(mid[3], 200, "alpha is kept");
-        // Different duotones are cached separately.
-        let other = PictureAdjust { duotone: Some((ColorRef::rgb(Rgba::rgb(0, 0, 0)), ColorRef::rgb(Rgba::rgb(255, 0, 0)))), ..Default::default() };
-        assert_ne!(adjust_key(&adj), adjust_key(&other));
-        assert_ne!(adjust_key(&adj), adjust_key(&PictureAdjust::default()));
-    }
-
    #[test]
    fn a_gif_of_many_tiny_frames_keeps_only_the_frame_cap() {
        use image::{Delay, Frame, Rgba, RgbaImage};
@@ -13,7 +13,6 @@ mod morph_path;
 mod morph_text;
 mod paint;
 mod placed;
-mod ramp;
 mod table;

 use std::collections::HashMap;
@@ -684,7 +683,7 @@ impl Renderer {
                let bounds = Rect::new(0.0, 0.0, w, h);
                ctx.push_clip_layer(&outline);
                let t = f.opts.gif_times.iter().find(|g| g.0 == s.id).map(|g| g.1);
-                paint::picture(ctx, f.pres, &paint::resolved(rctx, pf, None), bounds, m, t);
+                paint::picture(ctx, f.pres, pf, bounds, m, t);
                ctx.pop_layer();
            }
            ShapeKind::Media(mc) => {
@@ -3,7 +3,7 @@
 use deckcraft_color::Rgba;
 use deckcraft_geom::preset::FillMode;
 use deckcraft_model::resolve::Ctx;
-use deckcraft_model::style::{ColorRef, Fill, GradientShape, PictureFill, PictureMode};
+use deckcraft_model::style::{Fill, GradientShape, PictureFill, PictureMode};
 use deckcraft_model::{PhType, Presentation};
 use kurbo::{Affine, BezPath, Point, Rect, Shape as _};
 use vello_cpu::{RenderContext, peniko};
@@ -35,11 +35,10 @@ pub fn fill_path(
            if g.stops.is_empty() {
                return;
            }
-            let mut stops: Vec<(f64, Rgba)> = g.stops.iter().map(|s| (s.pos.clamp(0.0, 1.0), shade(rctx.color(&s.color, ph), mode))).collect();
+            let mut stops: Vec<(f32, peniko::Color)> =
+                g.stops.iter().map(|s| (s.pos.clamp(0.0, 1.0) as f32, color(shade(rctx.color(&s.color, ph), mode), alpha))).collect();
            stops.sort_by(|a, b| a.0.total_cmp(&b.0));
-            // PowerPoint's ramp between stops (linear light, S-shaped), see `ramp`.
-            let stops: Vec<peniko::ColorStop> =
-                crate::ramp::expand(&stops).into_iter().map(|(o, c)| peniko::ColorStop { offset: o as f32, color: color(c, alpha).into() }).collect();
+            let stops: Vec<peniko::ColorStop> = stops.into_iter().map(|(o, c)| peniko::ColorStop { offset: o, color: c.into() }).collect();
            let grad = match &g.shape {
                GradientShape::Linear { angle, .. } => {
                    // Angle measured clockwise from left→right; span the bounds along that direction.
@@ -66,7 +65,7 @@ pub fn fill_path(
        }
        Fill::Picture(pf) => {
            ctx.push_clip_layer(path);
-            picture(ctx, pres, &resolved(rctx, pf, ph), bounds, m, None);
+            picture(ctx, pres, pf, bounds, m, None);
            ctx.pop_layer();
        }
        Fill::Pattern(p) => {
@@ -121,16 +120,6 @@ fn p_rect(x: f64, y: f64, w: f64, h: f64) -> BezPath {
 }
 fn p_add(_a: &mut BezPath, _b: &mut BezPath) {}

-/// `pf` with its duotone colours resolved to plain RGB against the slide's colours and the
-/// placeholder colour `ph` (theme background pictures recolour with `phClr`), so the decoded-image
-/// cache can apply and key them without a colour scheme.
-pub fn resolved<'a>(rctx: &Ctx, pf: &'a PictureFill, ph: Option<Rgba>) -> std::borrow::Cow<'a, PictureFill> {
-    let Some((d, l)) = &pf.adjust.duotone else { return std::borrow::Cow::Borrowed(pf) };
-    let mut out = pf.clone();
-    out.adjust.duotone = Some((ColorRef::rgb(rctx.color(d, ph)), ColorRef::rgb(rctx.color(l, ph))));
-    std::borrow::Cow::Owned(out)
-}
-
 /// Draw a picture fill into `bounds` (shape-local) honouring crop and stretch/tile modes; an animated
 /// GIF shows its frame at `gif_time` seconds.
 pub fn picture(ctx: &mut RenderContext, pres: &Presentation, pf: &PictureFill, bounds: Rect, m: Affine, gif_time: Option<f64>) {
@@ -1,128 +0,0 @@
-//! Gradient colour ramps as PowerPoint draws them.
-//!
-//! A gradient of exactly two stops, at 0 % and 100 % (what a two-colour gradient is), is not
-//! blended linearly in sRGB by PowerPoint: it mixes the colours in linear light, and the second
-//! colour's share follows an S-shaped curve of the position. Black to white is 105 (not 64) a
-//! quarter of the way, 186 (not 128) half way and 238 (not 191) three quarters of the way, in any
-//! direction, on shapes and on slide backgrounds. Gradients with three or more stops, or with a
-//! stop moved off an end, blend linearly in sRGB (measured from PowerPoint's own slide export).
-//! The renderer interpolates linearly in sRGB, so a two-colour gradient is expanded into short
-//! pieces whose colours follow PowerPoint's ramp.
-
-use deckcraft_color::Rgba;
-
-/// The next stop's share of the linear-light mix at sixteenths of a segment (0 at the first stop,
-/// 1 at the second). Measured, then made symmetric: `w(1 - t) = 1 - w(t)`.
-const WEIGHT: [f64; 17] =
-    [0.0, 0.0205, 0.0469, 0.0878, 0.1431, 0.2143, 0.2989, 0.3972, 0.5, 0.6028, 0.7011, 0.7857, 0.8569, 0.9122, 0.9531, 0.9795, 1.0];
-
-/// Pieces each segment between two stops is cut into.
-const PIECES: usize = 16;
-
-/// The next stop's share at `t` (0..1) between two stops.
-pub fn weight(t: f64) -> f64 {
-    if !t.is_finite() {
-        return 0.0;
-    }
-    let x = t.clamp(0.0, 1.0) * (WEIGHT.len() - 1) as f64;
-    let i = (x.floor() as usize).min(WEIGHT.len() - 2);
-    let f = x - i as f64;
-    let (a, b) = (WEIGHT.get(i).copied().unwrap_or(0.0), WEIGHT.get(i + 1).copied().unwrap_or(1.0));
-    a + (b - a) * f
-}
-
-fn to_linear(v: u8) -> f64 {
-    let v = v as f64 / 255.0;
-    if v <= 0.04045 { v / 12.92 } else { ((v + 0.055) / 1.055).powf(2.4) }
-}
-
-fn to_srgb(v: f64) -> u8 {
-    let v = v.clamp(0.0, 1.0);
-    let s = if v <= 0.0031308 { v * 12.92 } else { 1.055 * v.powf(1.0 / 2.4) - 0.055 };
-    (s * 255.0).round().clamp(0.0, 255.0) as u8
-}
-
-/// The colour at `t` between stops `a` and `b`. Alpha mixes by the same share.
-pub fn mix(a: Rgba, b: Rgba, t: f64) -> Rgba {
-    let w = weight(t);
-    let ch = |x: u8, y: u8| to_srgb(to_linear(x) + (to_linear(y) - to_linear(x)) * w);
-    Rgba { r: ch(a.r, b.r), g: ch(a.g, b.g), b: ch(a.b, b.b), a: (a.a as f64 + (b.a as f64 - a.a as f64) * w).round().clamp(0.0, 255.0) as u8 }
-}
-
-/// Sorted stops (position 0..1, colour) as a renderer interpolating linearly in sRGB should get
-/// them: a two-colour gradient (two stops, at 0 and 1) expanded to follow PowerPoint's ramp,
-/// anything else unchanged.
-pub fn expand(stops: &[(f64, Rgba)]) -> Vec<(f64, Rgba)> {
-    let two_colour = matches!(stops, [(p, _), (q, _)] if *p <= 1e-6 && *q >= 1.0 - 1e-6);
-    if !two_colour {
-        return stops.to_vec();
-    }
-    let mut out = Vec::with_capacity(stops.len() * PIECES + 1);
-    for (i, &(p, c)) in stops.iter().enumerate() {
-        out.push((p, c));
-        let Some(&(q, d)) = stops.get(i + 1) else { continue };
-        if q - p <= 1e-6 || c == d {
-            continue;
-        }
-        for k in 1..PIECES {
-            let t = k as f64 / PIECES as f64;
-            out.push((p + (q - p) * t, mix(c, d, t)));
-        }
-    }
-    out
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn black_to_white_follows_powerpoint() {
-        // PowerPoint's export: 105 at a quarter, 186 half way, 238 at three quarters.
-        let (k, w) = (Rgba::rgb(0, 0, 0), Rgba::rgb(255, 255, 255));
-        for (t, want) in [(0.25, 105), (0.5, 186), (0.75, 238)] {
-            let got = mix(k, w, t).r as i32;
-            assert!((got - want).abs() <= 3, "{t}: {got} vs {want}");
-        }
-    }
-
-    #[test]
-    fn colour_pairs_follow_powerpoint() {
-        // Blue (4472C4) to orange (ED7D31) half way: PowerPoint draws (178, 120, 146).
-        let m = mix(Rgba::rgb(68, 114, 196), Rgba::rgb(237, 125, 49), 0.5);
-        assert!((m.r as i32 - 178).abs() <= 3 && (m.g as i32 - 120).abs() <= 3 && (m.b as i32 - 146).abs() <= 3, "{m:?}");
-        // Red to blue a quarter of the way: (238, 0, 105).
-        let m = mix(Rgba::rgb(255, 0, 0), Rgba::rgb(0, 0, 255), 0.25);
-        assert!((m.r as i32 - 238).abs() <= 3 && (m.b as i32 - 105).abs() <= 3, "{m:?}");
-    }
-
-    #[test]
-    fn the_ends_are_the_stops_and_the_weight_is_symmetric() {
-        let (a, b) = (Rgba::rgb(10, 200, 30), Rgba::rgb(240, 20, 90));
-        assert_eq!(mix(a, b, 0.0), a);
-        assert_eq!(mix(a, b, 1.0), b);
-        for k in 0..=32 {
-            let t = k as f64 / 32.0;
-            assert!((weight(t) + weight(1.0 - t) - 1.0).abs() < 1e-9);
-            assert!(weight(t) <= weight((t + 0.01).min(1.0)), "monotonic");
-        }
-        assert_eq!(weight(f64::NAN), 0.0);
-    }
-
-    #[test]
-    fn expand_keeps_stops_and_hard_edges() {
-        let (r, g) = (Rgba::rgb(255, 0, 0), Rgba::rgb(0, 255, 0));
-        // Three or more stops, or a stop off an end, blend linearly in sRGB: unchanged.
-        let e = expand(&[(0.0, r), (0.5, r), (0.5, g), (1.0, g)]);
-        assert_eq!(e, vec![(0.0, r), (0.5, r), (0.5, g), (1.0, g)]);
-        assert_eq!(expand(&[(0.2, r), (1.0, g)]), vec![(0.2, r), (1.0, g)]);
-        assert_eq!(expand(&[(0.0, r), (0.5, g), (1.0, r)]).len(), 3);
-        // Two equal colours add nothing.
-        assert_eq!(expand(&[(0.0, r), (1.0, r)]), vec![(0.0, r), (1.0, r)]);
-        let e = expand(&[(0.0, r), (1.0, g)]);
-        assert_eq!(e.len(), PIECES + 1);
-        assert_eq!(e.first(), Some(&(0.0, r)));
-        assert_eq!(e.last(), Some(&(1.0, g)));
-        assert!(e.windows(2).all(|w| w[0].0 <= w[1].0));
-    }
-}
@@ -523,52 +523,3 @@ fn hyperlinks_draw_in_the_hyperlink_colour_underlined() {
    let own = px(&run_deck(RunProps { link, fill: red.clone(), ..Default::default() }));
    assert_eq!(diff(&own, &px(&run_deck(RunProps { fill: red, underline: Some("sng".into()), ..Default::default() }))), 0);
 }
-
-#[test]
-fn a_linear_gradient_ramps_like_powerpoint() {
-    // Black to white, left to right: PowerPoint draws 105 a quarter of the way and 186 half way
-    // (linear-light mix, S-shaped), not 64 and 128.
-    use deckcraft_model::style::{Fill, Gradient, GradientShape, GradientStop};
-    let stop = |pos, c| GradientStop { pos, color: ColorRef::rgb(c) };
-    let sh = Shape {
-        id: ShapeId(700),
-        xfrm: Some(Xfrm::new(0.0, 0.0, 800.0, 100.0)),
-        fill: Some(Fill::Gradient(Gradient {
-            stops: vec![stop(0.0, deckcraft_color::Rgba::rgb(0, 0, 0)), stop(1.0, deckcraft_color::Rgba::rgb(255, 255, 255))],
-            shape: GradientShape::Linear { angle: 0.0, scaled: false },
-            rotate_with_shape: true,
-        })),
-        line: Some(deckcraft_model::style::Line { fill: Some(Fill::None), ..Default::default() }),
-        ..Default::default()
-    };
-    let p = deck_with(vec![sh]);
-    let img = render_slide(&p, 0, &RenderOpts { scale: 1.0, ..Default::default() });
-    for (x, want) in [(200, 105), (400, 186), (600, 238)] {
-        let got = img.pixel(x, 50)[0] as i32;
-        assert!((got - want).abs() <= 4, "x {x}: {got} vs {want}");
-    }
-}
-
-#[test]
-fn a_gradient_with_a_stop_off_the_end_stays_linear() {
-    // Stops at 20 % and 100 %: PowerPoint blends linearly in sRGB (96 at 50 %, 175 at 75 %).
-    use deckcraft_model::style::{Fill, Gradient, GradientShape, GradientStop};
-    let stop = |pos, c| GradientStop { pos, color: ColorRef::rgb(c) };
-    let sh = Shape {
-        id: ShapeId(701),
-        xfrm: Some(Xfrm::new(0.0, 0.0, 800.0, 100.0)),
-        fill: Some(Fill::Gradient(Gradient {
-            stops: vec![stop(0.2, deckcraft_color::Rgba::rgb(0, 0, 0)), stop(1.0, deckcraft_color::Rgba::rgb(255, 255, 255))],
-            shape: GradientShape::Linear { angle: 0.0, scaled: false },
-            rotate_with_shape: true,
-        })),
-        line: Some(deckcraft_model::style::Line { fill: Some(Fill::None), ..Default::default() }),
-        ..Default::default()
-    };
-    let p = deck_with(vec![sh]);
-    let img = render_slide(&p, 0, &RenderOpts { scale: 1.0, ..Default::default() });
-    for (x, want) in [(400, 96), (600, 175)] {
-        let got = img.pixel(x, 50)[0] as i32;
-        assert!((got - want).abs() <= 4, "x {x}: {got} vs {want}");
-    }
-}
@@ -566,9 +566,6 @@ fn shape_cells(ctx: &Ctx, text: &str, char_style: &[usize], styles: &[Style], fa
    cells
 }

-/// Size of superscript and subscript text relative to the run's size.
-const SUB_SUPER: f64 = 0.66;
-
 /// Shape cells `range` (one item) and hang each cluster's glyphs on its first cell, sharing the
 /// cluster's advance among its graphemes (by the ligature's GDEF carets when it has them).
 #[allow(clippy::too_many_arguments)]
@@ -596,11 +593,7 @@ fn shape_item(
        let st = styles.get(cell.style);
        let size = st.map(|s| s.size).unwrap_or(18.0);
        let small = st.is_some_and(|s| s.caps == Caps::Small) && cell.ch.is_lowercase();
-        let size = if small { size * 0.8 } else { size };
-        // Superscript and subscript glyphs are drawn at two thirds of the size, so they advance by
-        // two thirds too.
-        let size = if st.is_some_and(|s| s.baseline != 0.0) { size * SUB_SUPER } else { size };
-        size / upem
+        (if small { size * 0.8 } else { size }) / upem
    };
    // Cluster heads in this item, ascending; each cluster spans to the next head.
    let mut heads: Vec<usize> = glyphs.iter().filter_map(|g| char_at_byte.get(&g.cluster).copied()).filter(|h| range.contains(h)).collect();
@@ -686,8 +679,7 @@ fn map_symbol_bullet(c: &str, font: Option<&str>) -> String {
        };
        return m.to_string();
    }
-    // PowerPoint draws only the first character of a longer `buChar` ("••" draws one dot).
-    c.graphemes(true).next().unwrap_or("•").to_string()
+    c.to_string()
 }

 fn measure_str(face: &FontFace, size: f64, s: &str) -> (f64, Vec<(u32, f64)>) {
@@ -917,11 +909,7 @@ fn layout_scaled(ctx: &Ctx, shape: &Shape, body: &TextBody, bp: &BodyProps, opts
        let bullet_w = p.bullet.as_ref().map(|(s, st)| measure_str(&st.face, st.size, s).0).unwrap_or(0.0);
        let first_x = if p.bullet.is_some() {
            let bx = (margin + indent).max(0.0);
-            // A hanging bullet's text starts at the margin. When the hang reaches left of the box
-            // (marL + indent < 0), PowerPoint pins the bullet to the box's edge and keeps the
-            // hang: the first line's text starts at -indent (later lines stay at the margin).
-            let stop = margin.max(-indent);
-            if indent < 0.0 && bx + bullet_w <= stop { stop } else { bx + bullet_w + if indent >= 0.0 { 0.0 } else { 3.0 } }
+            if indent < 0.0 && bx + bullet_w <= margin { margin } else { bx + bullet_w + if indent >= 0.0 { 0.0 } else { 3.0 } }
        } else {
            (margin + indent).max(0.0)
        };
@@ -1167,7 +1155,7 @@ fn layout_scaled(ctx: &Ctx, shape: &Shape, body: &TextBody, bp: &BodyProps, opts
            let Some(st) = p.styles.get(cell.style) else { continue };
            let Some(&(cx, cx1)) = line.edges.get(k) else { continue };
            let base_y = line.baseline - st.baseline * st.size;
-            let size = if st.baseline != 0.0 { st.size * SUB_SUPER } else { st.size };
+            let size = if st.baseline != 0.0 { st.size * 0.66 } else { st.size };
            let size = if st.caps == Caps::Small && cell.ch.is_lowercase() { size * 0.8 } else { size };
            let key = (cell.style, cell.face);
            if key != cur_key {
@@ -1216,8 +1204,9 @@ fn layout_scaled(ctx: &Ctx, shape: &Shape, body: &TextBody, bp: &BodyProps, opts
                            }
                        }
                    }
+                    let k66 = if st.baseline != 0.0 { 0.66 } else { 1.0 };
                    for (gid, gx, gy) in &cell.glyphs {
-                        r.glyphs.push((*gid, cl + kash + gx, base_y + gy));
+                        r.glyphs.push((*gid, cl + kash + gx * k66, base_y + gy));
                        r.cells.push((ci, cell.ch));
                    }
                }
@@ -45,20 +45,6 @@ fn bullets_are_drawn_for_body_text() {
    assert_eq!(l.para_lines.len(), 2);
 }

-#[test]
-fn only_the_first_character_of_a_bullet_is_drawn() {
-    // "••" (seen in the wild) draws one dot in PowerPoint.
-    for (char, glyphs) in [("\u{2022}\u{2022}", 1), ("\u{2022}", 1), ("-->", 1)] {
-        let (p, mut sh) = setup("One", 600.0, 300.0);
-        sh.text.as_mut().unwrap().paragraphs[0].props.bullet = Some(Bullet::Char { char: char.into() });
-        let l = lay(&p, &sh, 600.0, 300.0);
-        let bullet = l.runs.iter().find(|r| r.chars == (0, 0)).expect("bullet run");
-        assert_eq!(bullet.glyphs.len(), glyphs, "{char:?}");
-    }
-    // The first grapheme cluster is kept whole.
-    assert_eq!(map_symbol_bullet("e\u{301}x", None), "e\u{301}");
-}
-
 #[test]
 fn shrink_on_overflow() {
    let text = (0..30).map(|i| format!("Line number {i}")).collect::<Vec<_>>().join("\n");
@@ -409,83 +395,3 @@ fn hostile_bidi_input_never_panics() {
        }
    }
 }
-
-/// Width of `word` laid out in a run with `baseline` (0 = normal, 0.3 = superscript …).
-fn run_width(word: &str, baseline: Option<f64>) -> f64 {
-    let mut run = Run::new(word);
-    run.props.size = Some(24.0);
-    run.props.baseline = baseline;
-    let (p, sh) = bidi_setup(vec![run], 2000.0, false, Align::Left);
-    let l = lay(&p, &sh, 2000.0, 300.0);
-    let line = &l.lines[0];
-    line.caret_x.last().unwrap() - line.caret_x.first().unwrap()
-}
-
-#[test]
-fn superscript_and_subscript_advance_at_their_drawn_size() {
-    // The glyphs are drawn at two thirds of the size; advancing by the full size spread the
-    // letters apart ("s u p e r").
-    let normal = run_width("superscript", None);
-    for b in [Some(0.3), Some(-0.25)] {
-        let w = run_width("superscript", b);
-        assert!((w / normal - SUB_SUPER).abs() < 0.02, "{b:?}: {w} vs {normal}");
-    }
-}
-
-#[test]
-fn superscript_glyphs_sit_inside_their_cells() {
-    let mut run = Run::new("super");
-    run.props.size = Some(24.0);
-    run.props.baseline = Some(0.3);
-    let (p, sh) = bidi_setup(vec![run], 2000.0, false, Align::Left);
-    let l = lay(&p, &sh, 2000.0, 300.0);
-    let line = &l.lines[0];
-    let r = l.runs.iter().find(|r| !r.cells.is_empty()).unwrap();
-    assert!((r.size - 24.0 * SUB_SUPER).abs() < 1e-6);
-    for (g, (ci, _)) in r.glyphs.iter().zip(&r.cells) {
-        let (x0, x1) = line.edges[*ci - line.start];
-        assert!(g.1 >= x0 - 0.01 && g.1 < x1, "glyph at {} outside its cell {x0}..{x1}", g.1);
-    }
-}
-
-/// A wrapping numbered paragraph with `marL` and `indent`; returns (bullet x, first line's text
-/// x, second line's text x).
-fn hanging(margin: f64, indent: f64, bullet: Bullet) -> (Option<f64>, f64, f64) {
-    let text = "Wrapping words go on and on so the paragraph needs at least two or three lines here";
-    let (p, mut sh) = setup(text, 300.0, 300.0);
-    let para = &mut sh.text.as_mut().unwrap().paragraphs[0];
-    para.props.bullet = Some(bullet);
-    para.props.margin_left = Some(margin);
-    para.props.indent = Some(indent);
-    let l = lay(&p, &sh, 300.0, 300.0);
-    assert!(l.lines.len() >= 2, "{} lines", l.lines.len());
-    let bx = l.runs.iter().find(|r| r.cells.is_empty() && !r.glyphs.is_empty()).map(|r| r.glyphs[0].1);
-    (bx, l.lines[0].caret_x[0], l.lines[1].caret_x[0])
-}
-
-#[test]
-fn a_hang_past_the_box_edge_keeps_its_width_on_the_first_line() {
-    // PowerPoint, marL 0 / indent -36pt: the number sits at the box's edge, the first line's text
-    // 36pt in, and the wrapped lines at the margin (observed with PowerPoint's slide export).
-    let num = || Bullet::AutoNum { scheme: "arabicPeriod".into(), start_at: 1 };
-    let (bx, first, rest) = hanging(0.0, -36.0, num());
-    assert!((first - rest - 36.0).abs() < 0.5, "first {first} rest {rest}");
-    assert!((bx.unwrap() - rest).abs() < 0.5, "bullet {bx:?} rest {rest}");
-    // marL 18 / indent -54: number at the edge, first line at 54, the rest at 18.
-    let (bx, first, rest) = hanging(18.0, -54.0, num());
-    assert!((first - rest - 36.0).abs() < 0.5, "first {first} rest {rest}");
-    assert!((rest - bx.unwrap() - 18.0).abs() < 0.5, "bullet {bx:?} rest {rest}");
-    // A character bullet behaves the same.
-    let (_, first, rest) = hanging(0.0, -36.0, Bullet::Char { char: "•".into() });
-    assert!((first - rest - 36.0).abs() < 0.5, "first {first} rest {rest}");
-    // Without a bullet the first line just starts at the edge.
-    let (_, first, rest) = hanging(0.0, -36.0, Bullet::None);
-    assert!((first - rest).abs() < 0.5, "first {first} rest {rest}");
-}
-
-#[test]
-fn an_ordinary_hang_still_puts_the_text_at_the_margin() {
-    let (bx, first, rest) = hanging(36.0, -36.0, Bullet::AutoNum { scheme: "arabicPeriod".into(), start_at: 1 });
-    assert!((first - rest).abs() < 0.5, "first {first} rest {rest}");
-    assert!((rest - bx.unwrap() - 36.0).abs() < 0.5);
-}