diff --git a/src/Integrations/Divi/Design/DiviFontsUploadAbility.php b/src/Integrations/Divi/Design/DiviFontsUploadAbility.php
new file mode 100644
index 0000000..15fbdb4
--- /dev/null
+++ b/src/Integrations/Divi/Design/DiviFontsUploadAbility.php
@@ -0,0 +1,449 @@
+<?php
+
+declare(strict_types=1);
+
+namespace LIT\MCP\Integrations\Divi\Design;
+
+use LIT\MCP\Abilities\Ability;
+use LIT\MCP\Abilities\Annotations;
+use LIT\MCP\Abilities\Errors;
+use LIT\MCP\Abilities\Rollback;
+use LIT\MCP\Abilities\ToolResult;
+use LIT\MCP\Abilities\WriteFailed;
+use LIT\MCP\ChangeLog\ChangeLog;
+use LIT\MCP\Integrations\Divi\Release\DiviFeature;
+use LIT\MCP\Integrations\Divi\Release\RequiresDiviFeatures;
+use LIT\MCP\Integrations\Media\AdminIncludes;
+use LIT\MCP\Integrations\Media\RemoteFileFetcher;
+use LIT\MCP\Limits;
+use RuntimeException;
+use WP_Error;
+
+defined('ABSPATH') || exit;
+
+/**
+ * lit/divi-fonts-upload (spec §8.2, rulings W8–W10): adds a custom font to Divi's uploaded fonts from public URLs,
+ * one file per format. No pipeline and no snapshot (A2), but its own dry run: without confirm the files are really
+ * downloaded (RemoteFileFetcher, at most 5 MB and the upload limit each), checked by magic bytes against their
+ * format key (FontSignature) and by Divi's content check, the temp files deleted again, and the answer is
+ * confirm_required with format, size and SHA-256 of every file. confirm: true downloads and checks again and
+ * installs (FontInstaller); Divi's partial success is undone with font_remove. Every path deletes the temp files.
+ */
+final class DiviFontsUploadAbility implements Ability, RequiresDiviFeatures
+{
+    /** Ruling A9: at most 5 MB per font file, whatever the upload limit allows. */
+    public const MAX_FILE_BYTES = 5 * 1024 * 1024;
+
+    public const OBJECT_TYPE = 'divi_font';
+
+    public const FAMILIES = ['serif', 'sans-serif', 'monospace', 'cursive', 'fantasy'];
+
+    public const WEIGHTS = [100, 200, 300, 400, 500, 600, 700, 800, 900];
+
+    private const KEYS = ['name', 'files', 'weights', 'generic_family', 'confirm'];
+
+    private const DEFAULT_FAMILY = 'sans-serif';
+
+    private const REASON = 'Divi hat die Schrift nicht vollständig übernommen.';
+
+    private const FILE_RULE = '1 bis 4 Formate als Objekt {Format: URL}';
+
+    public function __construct(
+        private FontCatalog $catalog,
+        private FontInstaller $installer,
+        private RemoteFileFetcher $fetcher,
+        private ChangeLog $log,
+        private Limits $limits
+    ) {
+    }
+
+    public function name(): string
+    {
+        return 'lit/divi-fonts-upload';
+    }
+
+    public function label(): string
+    {
+        return 'Eigene Schrift in Divi hochladen';
+    }
+
+    public function description(): string
+    {
+        return 'Lädt eine eigene Schrift von öffentlichen URLs in Divis hochgeladene Schriften: files mit je einer '
+            . 'Datei pro Format (woff2, woff, ttf, otf; höchstens 5 MB je Datei). name: 1–100 Zeichen aus Buchstaben, '
+            . 'Ziffern, Leerzeichen, _ und -, kein Name einer Google-, Web-Safe- oder schon hochgeladenen Schrift. '
+            . 'weights: "all" oder Liste aus 100 … 900; generic_family: serif, sans-serif (Standard), monospace, '
+            . 'cursive oder fantasy. Wirkt auf die ganze Website: zuerst Probelauf (lädt und prüft die Dateien, nennt '
+            . 'Format, Größe und SHA-256), nach Rückfrage beim Nutzer confirm: true. Kein Snapshot; entfernen lässt '
+            . 'sich die Schrift im Divi-Builder.';
+    }
+
+    public function inputSchema(): array
+    {
+        $url = ['type' => 'string', 'description' => 'Öffentliche http(s)-URL der Datei.'];
+
+        return [
+            'type' => 'object',
+            'properties' => [
+                'name' => ['type' => 'string', 'description' => 'Name der Schrift (Familienname in Divi).'],
+                'files' => [
+                    'type' => 'object',
+                    'properties' => array_fill_keys(FontInstaller::FORMATS, $url),
+                    'additionalProperties' => false,
+                ],
+                'weights' => [
+                    'type' => ['string', 'array'],
+                    'items' => ['type' => 'integer'],
+                    'description' => '"all" oder Liste der Schriftstärken aus 100, 200, … 900.',
+                ],
+                'generic_family' => ['type' => 'string', 'enum' => self::FAMILIES],
+                'confirm' => ['type' => 'boolean'],
+            ],
+            'required' => ['name', 'files', 'weights'],
+            'additionalProperties' => false,
+        ];
+    }
+
+    public function outputSchema(): ?array
+    {
+        return ToolResult::schema([
+            'font' => ['type' => 'string'],
+            'files' => [
+                'type' => 'array',
+                'items' => [
+                    'type' => 'object',
+                    'properties' => [
+                        'format' => ['type' => 'string'],
+                        'bytes' => ['type' => 'integer'],
+                        'sha256' => ['type' => 'string'],
+                    ],
+                ],
+            ],
+            'weights' => ['type' => 'string'],
+            'generic_family' => ['type' => 'string'],
+        ], ['font', 'files', 'weights', 'generic_family']);
+    }
+
+    public function annotations(): array
+    {
+        return Annotations::write(false);
+    }
+
+    public function isDirect(): bool
+    {
+        return false;
+    }
+
+    /** FontInstaller and the font lists of FontCatalog (name collision) both serve font-upload (ruling W1). */
+    public function diviFeatures(array $input): array
+    {
+        return [DiviFeature::FontUpload];
+    }
+
+    public function permission(array $input): bool|WP_Error
+    {
+        return DesignRights::fonts($this->catalog) ?? true;
+    }
+
+    /** @throws WriteFailed */
+    public function execute(array $input): mixed
+    {
+        $refusal = DesignRights::fonts($this->catalog);
+        if ($refusal !== null) {
+            return $refusal;
+        }
+
+        $errors = [];
+        foreach (array_diff(array_map('strval', array_keys($input)), self::KEYS) as $key) {
+            $errors[$key] = 'unbekanntes Feld';
+        }
+        $name = is_string($input['name'] ?? null) ? $input['name'] : '';
+        $taken = FontNameRules::taken($name, $this->catalog->reserved());
+        $nameProblem = $taken === null
+            ? FontNameRules::check($name, [], $this->installer->nameMaxLength())
+            : null;
+        if ($nameProblem !== null) {
+            $errors['name'] = $nameProblem;
+        }
+        $urls = $this->urls($input['files'] ?? null, $errors);
+        $weights = self::weights($input['weights'] ?? null, $errors);
+        $family = $input['generic_family'] ?? self::DEFAULT_FAMILY;
+        if (! in_array($family, self::FAMILIES, true)) {
+            $errors['generic_family'] = 'eine von: ' . implode(', ', self::FAMILIES);
+        }
+        $confirm = $input['confirm'] ?? false;
+        if (! is_bool($confirm)) {
+            $errors['confirm'] = 'true oder false';
+        }
+        if ($errors !== []) {
+            return Errors::invalidInput('Ungültige Angaben zur Schrift; nichts wurde gespeichert.', $errors);
+        }
+
+        if ($taken !== null) {
+            return Errors::make(
+                'conflict',
+                sprintf('Eine Schrift „%s“ gibt es schon; nichts wurde gespeichert.', $taken),
+                'Einen anderen Namen wählen (Groß-/Kleinschreibung zählt nicht) oder die vorhandene Schrift verwenden.',
+                409
+            );
+        }
+
+        return $this->upload($name, $urls, $weights, (string) $family, $confirm === true);
+    }
+
+    /**
+     * @param array<string, mixed> $errors
+     * @return array<string, string> Format => URL, in the order of the input.
+     */
+    private function urls(mixed $files, array &$errors): array
+    {
+        if (! is_array($files) || $files === [] || array_is_list($files) || count($files) > 4) {
+            $errors['files'] = self::FILE_RULE;
+
+            return [];
+        }
+
+        $known = $this->installer->formats();
+        $urls = [];
+        foreach ($files as $format => $url) {
+            $field = 'files.' . $format;
+            if (! in_array($format, FontInstaller::FORMATS, true)) {
+                $errors[$field] = 'unbekanntes Format; erlaubt: ' . implode(', ', FontInstaller::FORMATS);
+            } elseif (! in_array($format, $known, true)) {
+                $errors[$field] = 'dieses Format unterstützt Divi auf dieser Website nicht';
+            } elseif (! is_string($url) || $url === '') {
+                $errors[$field] = 'URL als Text erwartet';
+            } elseif (! $this->fetcher->allows($url)) {
+                $errors[$field] = 'nur öffentlich erreichbare http(s)-Adressen';
+            } else {
+                $urls[$format] = $url;
+            }
+        }
+
+        return $urls;
+    }
+
+    /**
+     * @param array<string, mixed> $errors
+     * @return string "all" or the sorted list as Divi stores it ("400,700").
+     */
+    private static function weights(mixed $weights, array &$errors): string
+    {
+        if ($weights === 'all') {
+            return 'all';
+        }
+
+        if (
+            ! is_array($weights) || $weights === [] || ! array_is_list($weights)
+            || array_filter($weights, 'is_int') !== $weights
+            || array_diff($weights, self::WEIGHTS) !== [] || count(array_unique($weights)) !== count($weights)
+        ) {
+            $errors['weights'] = '"all" oder Liste verschiedener Schriftstärken aus '
+                . implode(', ', self::WEIGHTS);
+
+            return '';
+        }
+
+        sort($weights);
+
+        return implode(',', $weights);
+    }
+
+    /**
+     * Downloads and checks every file into temp files – for the dry run and again for the install – and deletes
+     * them on every path.
+     *
+     * @param array<string, string> $urls
+     * @return array<string, mixed>|WP_Error
+     * @throws WriteFailed
+     */
+    private function upload(string $name, array $urls, string $weights, string $family, bool $confirm): array|WP_Error
+    {
+        AdminIncludes::load();
+        $temps = [];
+        try {
+            $files = $this->download($name, $urls, $temps);
+            if ($files instanceof WP_Error) {
+                return $files;
+            }
+
+            $report = array_values(array_map(
+                static fn (array $file): array => array_diff_key($file, ['path' => true]),
+                $files
+            ));
+            if (! $confirm) {
+                return Errors::confirmRequired(
+                    sprintf(
+                        'Schrift „%s“ hochladen (%s): Sie steht danach auf der ganzen Website in Divi zur Auswahl '
+                            . '(Builder, Theme-Optionen, Schrift-Variablen). Nichts wurde gespeichert (Probelauf).',
+                        $name,
+                        implode(', ', array_keys($files))
+                    ),
+                    ['font' => $name, 'files' => $report, 'weights' => $weights, 'generic_family' => $family]
+                );
+            }
+
+            $paths = array_map(static fn (array $file): string => $file['path'], $files);
+            $this->install($name, $paths, $weights, $family);
+        } finally {
+            foreach ($temps as $tmp) {
+                if (file_exists($tmp)) {
+                    wp_delete_file($tmp);
+                }
+            }
+        }
+
+        $summary = sprintf('Schrift „%s“ hochgeladen (%s).', $name, implode(', ', array_map(
+            static fn (array $file): string => $file['format'] . ' ' . $file['sha256'],
+            $report
+        )));
+        $logId = $this->log->record($this->name(), self::OBJECT_TYPE, $name, $summary);
+
+        return ToolResult::ok(sprintf(
+            'Schrift „%s“ hochgeladen; sie steht jetzt in Divi zur Auswahl (z. B. für lit/divi-theme-options-update).',
+            $name
+        ))
+            ->changed($name, self::OBJECT_TYPE, 'created', $name)
+            ->logId($logId)
+            ->with('font', $name)
+            ->with('files', $report)
+            ->with('weights', $weights)
+            ->with('generic_family', $family)
+            ->toArray();
+    }
+
+    /**
+     * @param array<string, string> $urls
+     * @param list<string>          $temps Gets every temp file created (the caller deletes them).
+     * @return array<string, array{format: string, bytes: int, sha256: string, path: string}>|WP_Error
+     */
+    private function download(string $name, array $urls, array &$temps): array|WP_Error
+    {
+        $max = min($this->limits->uploadBytes(), self::MAX_FILE_BYTES);
+        $files = [];
+        $problems = [];
+        $unreachable = false;
+        foreach ($urls as $format => $url) {
+            // fetch() does not check the URL itself: a refused URL is never requested (same answer as a failed one).
+            if (! $this->fetcher->allows($url)) {
+                $problems['files.' . $format] = 'nicht abrufbar';
+                $unreachable = true;
+                continue;
+            }
+            $tmp = (string) wp_tempnam('lit-mcp-font');
+            if ($tmp === '') {
+                return Errors::writeFailed('Die temporäre Datei konnte nicht angelegt werden.');
+            }
+            $temps[] = $tmp;
+            if ($this->fetcher->fetch($url, $tmp, $max, 'font upload') === null) {
+                $problems['files.' . $format] = 'nicht abrufbar';
+                $unreachable = true;
+                continue;
+            }
+
+            $problem = $this->problemOf($tmp, $format, $name . '.' . $format, $max);
+            if ($problem !== null) {
+                $problems['files.' . $format] = $problem;
+                continue;
+            }
+            $files[$format] = [
+                'format' => $format,
+                'bytes' => (int) filesize($tmp),
+                'sha256' => (string) hash_file('sha256', $tmp),
+                'path' => $tmp,
+            ];
+        }
+
+        if ($unreachable) {
+            return Errors::make(
+                'font_fetch_failed',
+                'Mindestens eine Schriftdatei konnte nicht geladen werden; nichts wurde gespeichert.',
+                'URLs prüfen; nur öffentlich erreichbare Dateien lassen sich laden.',
+                400,
+                ['fields' => $problems]
+            );
+        }
+
+        return $problems === [] ? $files : Errors::make(
+            'font_invalid',
+            'Mindestens eine Datei ist keine gültige Schriftdatei ihres Formats; nichts wurde gespeichert.',
+            sprintf(
+                'Je Format die passende Datei angeben (woff2, woff, ttf oder otf, höchstens %d MB je Datei).',
+                intdiv($max, 1024 * 1024)
+            ),
+            400,
+            ['fields' => $problems]
+        );
+    }
+
+    /** The problem of a downloaded file (size, magic bytes, Divi's content check), null when it is fine. */
+    private function problemOf(string $tmp, string $format, string $filename, int $max): ?string
+    {
+        clearstatcache(true, $tmp);
+        $bytes = (int) filesize($tmp);
+        if ($bytes === 0) {
+            return 'leere Datei';
+        }
+        if ($bytes > $max) {
+            return sprintf('größer als %d MB', intdiv($max, 1024 * 1024));
+        }
+
+        // phpcs:ignore WordPress.WP.AlternativeFunctions.file_get_contents_file_get_contents -- local temp file.
+        $header = (string) file_get_contents($tmp, false, null, 0, FontSignature::HEADER_BYTES);
+        $detected = FontSignature::detect($header);
+        if ($detected === null) {
+            return 'Inhalt ist keine Schriftdatei';
+        }
+        if ($detected !== $format) {
+            return sprintf('Inhalt ist eine %s-Datei, keine %s-Datei', $detected, $format);
+        }
+
+        return $this->installer->accepts($tmp, $filename) ? null : 'von Divi nicht als Schriftdatei erkannt';
+    }
+
+    /**
+     * @param array<string, string> $paths Format => checked temp file.
+     * @throws WriteFailed When Divi refuses the font or stores only some files (removed again if possible).
+     */
+    private function install(string $name, array $paths, string $weights, string $family): void
+    {
+        try {
+            $installed = $this->installer->install($name, $paths, $weights, $family);
+        } catch (RuntimeException $e) {
+            // FontInstaller stores nothing when it throws.
+            throw WriteFailed::rolledBack(self::REASON, $e, 'font upload: ' . $e->getMessage());
+        }
+
+        $missing = array_values(array_diff(array_keys($paths), $installed));
+        if ($missing === []) {
+            return;
+        }
+
+        $detail = sprintf(
+            'font upload: Divi stored %s of %s',
+            implode(',', $installed),
+            implode(',', array_keys($paths))
+        );
+        $failures = Rollback::attempt(fn () => $this->installer->remove($name));
+        if ($failures === []) {
+            throw WriteFailed::rolledBack(
+                self::REASON . sprintf(' Divi hat %s nicht gespeichert.', implode(', ', $missing)),
+                detail: $detail
+            );
+        }
+
+        $this->log->recordPartial(
+            $this->name(),
+            self::OBJECT_TYPE,
+            $name,
+            sprintf('Schrift „%s“ nur teilweise hochgeladen, nicht entfernt (%s)', $name, $failures[0])
+        );
+        throw WriteFailed::partial(
+            self::REASON,
+            detail: $detail . '; remove failed: ' . $failures[0],
+            state: sprintf('Die Schrift „%s“ ist ohne %s in Divi gespeichert.', $name, implode(', ', $missing)),
+            hint: 'Den Aufruf nicht wiederholen; die Schrift im Divi-Builder (Schriften verwalten) prüfen und ggf. '
+                . 'löschen und dem Nutzer Bescheid geben.'
+        );
+    }
+}
diff --git a/tests/Unit/Integrations/Divi/Design/DiviFontsUploadAbilityTest.php b/tests/Unit/Integrations/Divi/Design/DiviFontsUploadAbilityTest.php
new file mode 100644
index 0000000..ab3fc53
--- /dev/null
+++ b/tests/Unit/Integrations/Divi/Design/DiviFontsUploadAbilityTest.php
@@ -0,0 +1,495 @@
+<?php
+
+declare(strict_types=1);
+
+namespace LIT\MCP\Tests\Unit\Integrations\Divi\Design;
+
+use Brain\Monkey\Functions;
+use LIT\MCP\Abilities\Errors;
+use LIT\MCP\Abilities\WriteFailed;
+use LIT\MCP\Integrations\Divi\Design\DiviFontsUploadAbility;
+use LIT\MCP\Integrations\Divi\Design\FontCatalog;
+use LIT\MCP\Integrations\Divi\Design\FontInstaller;
+use LIT\MCP\Integrations\Divi\Release\DiviFeature;
+use LIT\MCP\Integrations\Media\RemoteFileFetcher;
+use LIT\MCP\Limits;
+use LIT\MCP\Tests\Support\FakeChangeLog;
+use LIT\MCP\Tests\Unit\TestCase;
+use Mockery;
+use Mockery\MockInterface;
+use RuntimeException;
+
+final class DiviFontsUploadAbilityTest extends TestCase
+{
+    private const WOFF2 = "wOF2\x00\x01\x00\x00woff2-body";
+    private const TTF = "\x00\x01\x00\x00\x00\x0cttf-body";
+    private const WOFF2_URL = 'https://fonts.example.com/inter.woff2';
+    private const TTF_URL = 'https://fonts.example.com/inter.ttf';
+
+    /** @var list<string> */
+    private array $tempFiles = [];
+
+    /** @var array<string, string|null> URL => body the fake fetcher writes (null = download fails). */
+    private array $bodies = [];
+
+    /** @var list<array{url: string, tmp: string, max: int, context: string}> */
+    private array $fetches = [];
+
+    /** @var array<string, string> Path => content of the temp files when install() ran. */
+    private array $installedFrom = [];
+
+    /** URL whose allows() turns false after the first call (it was valid on input, refused at download). */
+    private ?string $revokedUrl = null;
+
+    /** @var array<string, int> */
+    private array $allowCalls = [];
+
+    private string $errorLog = '';
+    private string|false $previousErrorLog = false;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+        $this->errorLog = (string) tempnam(sys_get_temp_dir(), 'lit-mcp-log');
+        $this->previousErrorLog = ini_set('error_log', $this->errorLog);
+        $this->bodies = [self::WOFF2_URL => self::WOFF2, self::TTF_URL => self::TTF];
+        Functions\when('current_user_can')->justReturn(true);
+        Functions\when('get_option')->justReturn(['upload_mb' => 1]);
+        Functions\when('wp_tempnam')->alias(function (): string {
+            $file = (string) tempnam(sys_get_temp_dir(), 'lit-font');
+            $this->tempFiles[] = $file;
+
+            return $file;
+        });
+        Functions\when('wp_delete_file')->alias(static function (string $file): void {
+            if (is_file($file)) {
+                unlink($file);
+            }
+        });
+    }
+
+    protected function tearDown(): void
+    {
+        ini_set('error_log', (string) $this->previousErrorLog);
+        foreach ([...$this->tempFiles, $this->errorLog] as $file) {
+            if (is_file($file)) {
+                unlink($file);
+            }
+        }
+        parent::tearDown();
+    }
+
+    private function fetcher(): RemoteFileFetcher
+    {
+        $test = $this;
+
+        return new class ($test) extends RemoteFileFetcher {
+            public function __construct(private DiviFontsUploadAbilityTest $test)
+            {
+                parent::__construct(static fn (string $host): array => ['93.184.216.34']);
+            }
+
+            public function allows(string $url): bool
+            {
+                return $this->test->allowed($url);
+            }
+
+            public function fetch(string $url, string $tmp, int $maxBytes, string $context): ?array
+            {
+                return $this->test->fakeFetch($url, $tmp, $maxBytes, $context);
+            }
+        };
+    }
+
+    /** The fake fetcher's allows(). */
+    public function allowed(string $url): bool
+    {
+        $this->allowCalls[$url] = ($this->allowCalls[$url] ?? 0) + 1;
+        if ($url === $this->revokedUrl && $this->allowCalls[$url] > 1) {
+            return false;
+        }
+
+        return str_starts_with($url, 'https://') && ! str_contains($url, 'intern');
+    }
+
+    /** The fake fetcher's download: writes the body of $url into $tmp. */
+    public function fakeFetch(string $url, string $tmp, int $maxBytes, string $context): ?array
+    {
+        $this->fetches[] = ['url' => $url, 'tmp' => $tmp, 'max' => $maxBytes, 'context' => $context];
+        $body = $this->bodies[$url] ?? null;
+        if ($body === null) {
+            return null;
+        }
+        file_put_contents($tmp, substr($body, 0, $maxBytes + 1));
+
+        return ['response' => ['code' => 200], 'headers' => []];
+    }
+
+    /** @param list<string> $reserved */
+    private static function catalog(array $reserved = ['Open Sans', 'Arial'], bool $canManage = true): FontCatalog
+    {
+        $catalog = Mockery::mock(FontCatalog::class);
+        $catalog->allows('reserved')->andReturn($reserved);
+        $catalog->allows('canManage')->andReturn($canManage);
+
+        return $catalog;
+    }
+
+    private static function installer(bool $accepts = true): FontInstaller&MockInterface
+    {
+        $installer = Mockery::mock(FontInstaller::class);
+        $installer->allows('formats')->andReturn(['woff2', 'woff', 'ttf', 'otf']);
+        $installer->allows('nameMaxLength')->andReturn(100);
+        $installer->allows('accepts')->andReturn($accepts);
+
+        return $installer;
+    }
+
+    private function ability(
+        ?FontInstaller $installer = null,
+        ?FakeChangeLog $log = null,
+        ?FontCatalog $catalog = null
+    ): DiviFontsUploadAbility {
+        return new DiviFontsUploadAbility(
+            $catalog ?? self::catalog(),
+            $installer ?? self::installer(),
+            $this->fetcher(),
+            $log ?? FakeChangeLog::forbidden(),
+            new Limits()
+        );
+    }
+
+    /** @return array<string, mixed> */
+    private static function input(array $overrides = []): array
+    {
+        return array_merge([
+            'name' => 'Inter Display',
+            'files' => ['woff2' => self::WOFF2_URL, 'ttf' => self::TTF_URL],
+            'weights' => [700, 400],
+        ], $overrides);
+    }
+
+    private function assertTempFilesRemoved(): void
+    {
+        self::assertNotSame([], $this->tempFiles, 'the files were downloaded');
+        foreach ($this->tempFiles as $file) {
+            self::assertFileDoesNotExist($file);
+        }
+    }
+
+    public function testIsAnIndirectAdditiveDiviToolForFontUpload(): void
+    {
+        $ability = $this->ability();
+
+        self::assertSame('lit/divi-fonts-upload', $ability->name());
+        self::assertFalse($ability->isDirect());
+        self::assertSame(['readonly' => false, 'destructive' => false, 'idempotent' => false], $ability->annotations());
+        self::assertSame([DiviFeature::FontUpload], $ability->diviFeatures([]));
+        self::assertSame(['name', 'files', 'weights'], $ability->inputSchema()['required']);
+        self::assertFalse($ability->inputSchema()['properties']['files']['additionalProperties']);
+    }
+
+    public function testPermissionAndExecuteAskTheFontRights(): void
+    {
+        $ability = $this->ability(catalog: self::catalog(canManage: false));
+
+        self::assertToolError($ability->permission(self::input()), 'forbidden');
+        self::assertToolError($ability->execute(self::input()), 'forbidden');
+
+        Functions\when('current_user_can')->alias(static fn (string $cap): bool => $cap !== 'upload_files');
+        self::assertToolError($this->ability()->permission(self::input()), 'forbidden');
+        self::assertToolError($this->ability()->execute(self::input()), 'forbidden');
+        self::assertSame([], $this->fetches, 'nothing is downloaded without the rights');
+    }
+
+    public function testEveryInputProblemIsReportedAtOnceWithItsPath(): void
+    {
+        $result = $this->ability()->execute([
+            'name' => 'Inter (Pro)',
+            'files' => ['woff2' => 'http://intern.example.com/a.woff2', 'eot' => self::TTF_URL, 'ttf' => 5],
+            'weights' => [400, 450, 400],
+            'generic_family' => 'serifs',
+            'confirm' => 'yes',
+            'style' => 'italic',
+        ]);
+
+        $fields = self::errorFields($result);
+        self::assertToolError($result, 'validation_failed');
+        self::assertStringContainsString('„Inter Pro“', $fields['name']);
+        self::assertStringContainsString('öffentlich', $fields['files.woff2']);
+        self::assertStringContainsString('erlaubt: woff2, woff, ttf, otf', $fields['files.eot']);
+        self::assertSame('URL als Text erwartet', $fields['files.ttf']);
+        self::assertStringContainsString('100, 200, 300, 400, 500, 600, 700, 800, 900', $fields['weights']);
+        self::assertStringContainsString('sans-serif', $fields['generic_family']);
+        self::assertSame('true oder false', $fields['confirm']);
+        self::assertSame('unbekanntes Feld', $fields['style']);
+        self::assertSame([], $this->fetches);
+    }
+
+    /** @return array<string, array{bool}> */
+    public static function confirmModes(): array
+    {
+        return ['dry run' => [false], 'confirm' => [true]];
+    }
+
+    /** @dataProvider confirmModes */
+    public function testNothingIsFetchedWhenOneUrlIsRefusedByAllows(bool $confirm): void
+    {
+        $result = $this->ability(self::installer(), null)->execute(self::input([
+            'files' => ['woff2' => self::WOFF2_URL, 'ttf' => 'https://intern.example.com/inter.ttf'],
+            'confirm' => $confirm,
+        ]));
+
+        self::assertToolError($result, 'validation_failed');
+        self::assertSame([], $this->fetches, 'the valid URL is not fetched either');
+    }
+
+    /** @dataProvider confirmModes */
+    public function testFetchIsNeverCalledForAUrlAllowsRefusesAtDownloadTime(bool $confirm): void
+    {
+        $this->revokedUrl = self::TTF_URL;
+        $installer = self::installer();
+        $installer->expects('install')->never();
+
+        $result = $this->ability($installer)->execute(self::input(['confirm' => $confirm]));
+
+        self::assertToolError($result, 'font_fetch_failed');
+        self::assertSame(['files.ttf' => 'nicht abrufbar'], self::errorFields($result));
+        self::assertSame([self::WOFF2_URL], array_column($this->fetches, 'url'), 'fetch() skipped the refused URL');
+        $this->assertTempFilesRemoved();
+    }
+
+    public function testFilesAndWeightsNeedTheirShape(): void
+    {
+        $fields = self::errorFields($this->ability()->execute(self::input(['files' => [], 'weights' => []])));
+        self::assertSame('1 bis 4 Formate als Objekt {Format: URL}', $fields['files']);
+        self::assertStringContainsString('"all" oder Liste', $fields['weights']);
+
+        $fields = self::errorFields($this->ability()->execute(self::input([
+            'files' => [self::WOFF2_URL],
+            'weights' => 'bold',
+        ])));
+        self::assertSame('1 bis 4 Formate als Objekt {Format: URL}', $fields['files']);
+        self::assertStringContainsString('"all" oder Liste', $fields['weights']);
+
+        $fields = self::errorFields($this->ability()->execute(['files' => ['woff2' => self::WOFF2_URL]]));
+        self::assertStringContainsString('Name fehlt', $fields['name']);
+        self::assertStringContainsString('"all" oder Liste', $fields['weights']);
+    }
+
+    public function testAFormatDiviDoesNotKnowIsRefused(): void
+    {
+        $installer = Mockery::mock(FontInstaller::class);
+        $installer->allows('formats')->andReturn(['ttf', 'otf']);
+        $installer->allows('nameMaxLength')->andReturn(100);
+
+        $fields = self::errorFields($this->ability($installer)->execute(self::input()));
+
+        self::assertStringContainsString('unterstützt Divi auf dieser Website nicht', $fields['files.woff2']);
+        self::assertArrayNotHasKey('files.ttf', $fields);
+    }
+
+    public function testANameThatIsTakenWhateverTheCaseIsAConflict(): void
+    {
+        $error = self::assertToolError(
+            $this->ability(catalog: self::catalog(['Open Sans', 'Inter Display']))->execute(
+                self::input(['name' => 'inter display'])
+            ),
+            'conflict'
+        );
+
+        self::assertStringContainsString('„Inter Display“', $error['message']);
+        self::assertSame([], $this->fetches);
+    }
+
+    public function testTheDryRunDownloadsAndChecksEveryFileAndAsksForConfirmation(): void
+    {
+        $installer = self::installer();
+        $installer->expects('install')->never();
+
+        $error = self::assertToolError($this->ability($installer)->execute(self::input()), 'confirm_required');
+
+        self::assertStringContainsString('„Inter Display“', $error['message']);
+        self::assertStringContainsString('ganzen Website', $error['message']);
+        self::assertStringContainsString('Nichts wurde gespeichert (Probelauf).', $error['message']);
+        self::assertSame('Inter Display', $error['font']);
+        self::assertSame([
+            ['format' => 'woff2', 'bytes' => strlen(self::WOFF2), 'sha256' => hash('sha256', self::WOFF2)],
+            ['format' => 'ttf', 'bytes' => strlen(self::TTF), 'sha256' => hash('sha256', self::TTF)],
+        ], $error['files']);
+        self::assertSame('400,700', $error['weights']);
+        self::assertSame('sans-serif', $error['generic_family']);
+        self::assertSame([self::WOFF2_URL, self::TTF_URL], array_column($this->fetches, 'url'));
+        self::assertSame(['font upload', 'font upload'], array_column($this->fetches, 'context'));
+        self::assertSame([1048576, 1048576], array_column($this->fetches, 'max'), 'upload limit 1 MB');
+        $this->assertTempFilesRemoved();
+    }
+
+    public function testTheSizeCapIsFiveMegabytesEvenWithAHigherUploadLimit(): void
+    {
+        Functions\when('get_option')->justReturn(['upload_mb' => 32]);
+
+        $this->ability()->execute(self::input());
+
+        self::assertSame([5242880, 5242880], array_column($this->fetches, 'max'));
+    }
+
+    public function testAFileAboveTheCapIsInvalid(): void
+    {
+        $this->bodies[self::TTF_URL] = self::TTF . str_repeat('x', 1048576);
+
+        $result = $this->ability()->execute(self::input());
+
+        self::assertToolError($result, 'font_invalid');
+        self::assertSame('größer als 1 MB', self::errorFields($result)['files.ttf']);
+        self::assertArrayNotHasKey('files.woff2', self::errorFields($result));
+        $this->assertTempFilesRemoved();
+    }
+
+    public function testTheContentMustBeTheFormatOfItsKey(): void
+    {
+        $this->bodies[self::WOFF2_URL] = self::TTF;
+        $this->bodies[self::TTF_URL] = '<?php evil();';
+
+        $result = $this->ability()->execute(self::input());
+
+        $fields = self::errorFields($result);
+        self::assertToolError($result, 'font_invalid');
+        self::assertSame('Inhalt ist eine ttf-Datei, keine woff2-Datei', $fields['files.woff2']);
+        self::assertSame('Inhalt ist keine Schriftdatei', $fields['files.ttf']);
+        $this->assertTempFilesRemoved();
+    }
+
+    public function testAnEmptyFileIsInvalid(): void
+    {
+        $this->bodies[self::TTF_URL] = '';
+
+        $result = $this->ability()->execute(self::input());
+
+        self::assertToolError($result, 'font_invalid');
+        self::assertSame('leere Datei', self::errorFields($result)['files.ttf']);
+    }
+
+    public function testAFileDivisContentCheckRefusesIsInvalid(): void
+    {
+        $result = $this->ability(self::installer(accepts: false))->execute(self::input());
+
+        self::assertToolError($result, 'font_invalid');
+        self::assertSame('von Divi nicht als Schriftdatei erkannt', self::errorFields($result)['files.woff2']);
+        $this->assertTempFilesRemoved();
+    }
+
+    public function testAFailedDownloadIsFontFetchFailedWithoutAnOracle(): void
+    {
+        $this->bodies[self::TTF_URL] = null;
+        $this->bodies[self::WOFF2_URL] = self::TTF;
+
+        $result = $this->ability()->execute(self::input());
+
+        $error = self::assertToolError($result, 'font_fetch_failed');
+        self::assertSame(
+            ['files.woff2' => 'Inhalt ist eine ttf-Datei, keine woff2-Datei', 'files.ttf' => 'nicht abrufbar'],
+            self::errorFields($result)
+        );
+        self::assertStringContainsString('nicht geladen', $error['message']);
+        $this->assertTempFilesRemoved();
+    }
+
+    public function testConfirmInstallsFromTheCheckedTempFilesAndLogsTheChecksums(): void
+    {
+        $installer = self::installer();
+        $installer->expects('install')->once()
+            ->with('Inter Display', Mockery::type('array'), '400,700', 'serif')
+            ->andReturnUsing(function (string $name, array $files): array {
+                $this->installedFrom = array_map('file_get_contents', $files);
+
+                return array_keys($files);
+            });
+        $log = new FakeChangeLog(7);
+
+        $result = $this->ability($installer, $log)->execute(
+            self::input(['generic_family' => 'serif', 'confirm' => true])
+        );
+
+        self::assertSame(['woff2' => self::WOFF2, 'ttf' => self::TTF], $this->installedFrom);
+        self::assertTrue($result['ok']);
+        self::assertSame('Inter Display', $result['font']);
+        self::assertSame(['woff2', 'ttf'], array_column($result['files'], 'format'));
+        self::assertSame(7, $result['log_id']);
+        self::assertSame([['id' => 'Inter Display', 'type' => 'divi_font', 'action' => 'created',
+            'label' => 'Inter Display']], $result['changed']);
+        self::assertCount(1, $log->records);
+        self::assertSame('lit/divi-fonts-upload', $log->records[0]['ability']);
+        self::assertSame('divi_font', $log->records[0]['object_type']);
+        self::assertSame('Inter Display', $log->records[0]['object_id']);
+        self::assertStringContainsString('woff2 ' . hash('sha256', self::WOFF2), $log->records[0]['summary']);
+        self::assertStringContainsString('ttf ' . hash('sha256', self::TTF), $log->records[0]['summary']);
+        self::assertSame(2, count($this->fetches), 'downloaded and checked again for the install');
+        $this->assertTempFilesRemoved();
+    }
+
+    public function testWeightsAllArePassedOn(): void
+    {
+        $installer = self::installer();
+        $installer->expects('install')->once()->with('Inter Display', Mockery::type('array'), 'all', 'sans-serif')
+            ->andReturn(['woff2', 'ttf']);
+
+        $result = $this->ability($installer, new FakeChangeLog())->execute(
+            self::input(['weights' => 'all', 'confirm' => true])
+        );
+
+        self::assertSame('all', $result['weights']);
+    }
+
+    public function testAPartialInstallIsRemovedAgain(): void
+    {
+        $installer = self::installer();
+        $installer->allows('install')->andReturn(['woff2']);
+        $installer->expects('remove')->once()->with('Inter Display');
+
+        try {
+            $this->ability($installer)->execute(self::input(['confirm' => true]));
+            self::fail('WriteFailed expected');
+        } catch (WriteFailed $e) {
+            self::assertTrue($e->rolledBack);
+            $error = self::assertToolError($e->toError(), 'write_failed');
+            self::assertStringContainsString('ttf', $error['message']);
+        }
+        $this->assertTempFilesRemoved();
+    }
+
+    public function testAPartialInstallThatCannotBeRemovedIsAPartialWrite(): void
+    {
+        $installer = self::installer();
+        $installer->allows('install')->andReturn(['woff2']);
+        $installer->allows('remove')->andThrow(new RuntimeException('font_remove refused: Font Does not Exist.'));
+        $log = FakeChangeLog::partialsOnly();
+
+        try {
+            $this->ability($installer, $log)->execute(self::input(['confirm' => true]));
+            self::fail('WriteFailed expected');
+        } catch (WriteFailed $e) {
+            self::assertFalse($e->rolledBack);
+            $error = self::assertToolError($e->toError(), 'partial_write');
+            self::assertStringContainsString('„Inter Display“', $error['message']);
+        }
+        self::assertCount(1, $log->partials);
+        self::assertSame('divi_font', $log->partials[0]['object_type']);
+    }
+
+    public function testARefusedInstallIsAWriteFailureThatLeavesNothing(): void
+    {
+        $installer = self::installer();
+        $installer->allows('install')->andThrow(new RuntimeException('font_add refused: kaputt'));
+        $installer->expects('remove')->never();
+
+        try {
+            $this->ability($installer)->execute(self::input(['confirm' => true]));
+            self::fail('WriteFailed expected');
+        } catch (WriteFailed $e) {
+            self::assertTrue($e->rolledBack);
+            self::assertStringNotContainsString('kaputt', Errors::clientMessage($e->toError()));
+        }
+        $this->assertTempFilesRemoved();
+    }
+}