diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 83c92b7..22e01b7 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -81,6 +81,47 @@ jobs:
       - name: Test
         run: vendor/bin/pest
 
+  # The decks the library writes, checked against the schema Microsoft's own validator
+  # reads.
+  #
+  # Its own job rather than a step in the test matrix, because the validator is a .NET
+  # program: the SDK it is built and run with is a second toolchain, and the job that
+  # installs it is the job that runs the gate.
+  #
+  # The rasteriser is installed because the deck that carries a vector needs one to be
+  # written at all — the library refuses a picture it cannot draw rather than writing a
+  # diagram that has lost its words. Whether the runner's Imagick can draw one is the
+  # runner's business: where it cannot, that deck's test says so and skips itself, and
+  # the rest of the gallery is checked all the same.
+  conformance:
+    name: valid OOXML
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
+
+      - uses: shivammathur/setup-php@f3e473d116dcccaddc5834248c87452386958240 # v2
+        with:
+          php-version: '8.5'
+          coverage: none
+          tools: composer:v2
+          extensions: imagick
+
+      - uses: actions/setup-dotnet@67a3573c9a986a3f9c594539f4ab511d57bb3ce9 # v4
+        with:
+          dotnet-version: '8.0.x'
+
+      # The validator is a .NET program, so the SDK is what runs it. The step says so
+      # where it is missing rather than leaving the gate to skip itself: a skipped test
+      # is a green tick for a check that never ran.
+      - name: The .NET SDK is there
+        run: dotnet --version
+
+      - name: Install
+        run: composer install --prefer-dist --no-interaction --no-progress
+
+      - name: The decks are valid OOXML
+        run: vendor/bin/pest --testsuite=conformance
+
   coverage:
     name: coverage
     runs-on: ubuntu-latest
diff --git a/.gitignore b/.gitignore
index 646b245..48b1714 100644
--- a/.gitignore
+++ b/.gitignore
@@ -30,6 +30,10 @@
 # The OOXML schemas `tools/install-ooxml-schemas.php` fetches and checksums.
 /tools/ooxml-schemas/
 
+# The validator's own build output, which the .NET SDK writes beside the project.
+/tools/ooxml-validator/bin/
+/tools/ooxml-validator/obj/
+
 # The fonts `tools/generate-font-metrics.php` fetches and checksums.
 /tools/fonts/
 
diff --git a/CHANGELOG.md b/CHANGELOG.md
index a816266..827dbe9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,73 @@ All notable changes to this project are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the project follows
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.3.1] - 2026-10-31
+
+### Added
+
+- **The decks the library writes are checked against the schema Microsoft's own validator
+  reads.** Nothing in the suite could see that before: the decks were checked against the
+  parts they carry, and a deck whose XML is outside the schema passes every one of those
+  checks and opens in PowerPoint as `[Repaired]`.
+
+  The validator is Microsoft's own — the one the Open XML SDK Productivity Tool uses — and
+  it is a program in `tools/ooxml-validator/` rather than a dependency: nothing that ships
+  with the library needs it. A machine without the .NET SDK runs the rest of the suite and
+  says what is missing, and the job that runs the gate in continuous integration installs
+  it, so the gate cannot skip itself there.
+
+  The one deck that carries a vector needs a rasteriser to be written at all — the library
+  refuses a picture it cannot draw rather than writing a diagram that has lost its words
+  — so a machine without one says which deck it did not check and checks the rest.
+  **The continuous integration runner is such a machine**, so the gate checks eighteen of
+  the nineteen decks there, and the nineteenth is checked where a vector can be drawn.
+
+### Changed
+
+- **The patch carries four more fixes from upstream.** A chart's series is written in
+  the order the schema names it: the shape properties right after the title rather than
+  after the data points and the data labels, and the separator of the data labels of a
+  doughnut before the leader lines rather than after them. PowerPoint repairs a chart
+  written the other way round before it opens it
+  ([#695](https://github.com/PHPOffice/PHPPresentation/issues/695),
+  [#1044](https://github.com/PHPOffice/PHPPresentation/pull/1044)).
+
+  Three of them are charts that carried less than they were given: the area, the line,
+  the radar and the scatter dropped the fill of a single data point
+  ([#1048](https://github.com/PHPOffice/PHPPresentation/issues/1048),
+  [#1052](https://github.com/PHPOffice/PHPPresentation/pull/1052)), a doughnut, a pie
+  and a pie in three dimensions dropped the fill of the series itself
+  ([#1049](https://github.com/PHPOffice/PHPPresentation/issues/1049),
+  [#1051](https://github.com/PHPOffice/PHPPresentation/pull/1051)), and a category axis
+  wrote its major unit as the number of labels to skip — and as a fraction, where the
+  schema wants a count, so the file was outside the schema
+  ([#1047](https://github.com/PHPOffice/PHPPresentation/issues/1047),
+  [#1050](https://github.com/PHPOffice/PHPPresentation/pull/1050)).
+
+  This library writes no chart, so nothing it draws changes: the patch is upstream's
+  branch whole, and the fix belongs to that branch rather than to this one.
+
+- **The charts are checked too, and the gate knows what a chart has to carry.** The
+  patch is the library that writes the charts, and a patch that is re-rolled without a
+  fix is a patch that has lost it — nothing else in this suite would have noticed. So
+  the gate writes a chart of every kind through the patched library, and checks two
+  things about it: that the file is within the schema, which the validator reads, and
+  that it carries what it was given, which the validator cannot see.
+
+  A chart that is missing a data point is a valid chart. The validator reads what a
+  file holds and says nothing about what it does not, so the elements themselves are
+  asserted on: every kind of series carries the fill it was given, and every kind of
+  series carries the fill of the point it was given.
+
+  Three defects were found this way and are fixed upstream:
+  [#1047](https://github.com/PHPOffice/PHPPresentation/issues/1047) — a category axis
+  wrote its major unit as the number of labels to skip, and wrote it as a fraction
+  where the schema wants a count, so the file was outside the schema;
+  [#1048](https://github.com/PHPOffice/PHPPresentation/issues/1048) — the area, line,
+  radar and scatter charts dropped the fill of a single data point;
+  [#1049](https://github.com/PHPOffice/PHPPresentation/issues/1049) — a doughnut, a pie
+  and a pie in three dimensions dropped the fill of the series itself.
+
 ## [0.3.0] - 2026-10-30
 
 ### Added
@@ -2500,5 +2567,6 @@ slide begins and which theme a deck means, and renders the deck to a `.pptx`.
 [0.2.1]: https://github.com/markdown-office/markdown-presentation/releases/tag/v0.2.1
 [0.2.2]: https://github.com/markdown-office/markdown-presentation/releases/tag/v0.2.2
 [0.3.0]: https://github.com/markdown-office/markdown-presentation/releases/tag/v0.3.0
+[0.3.1]: https://github.com/markdown-office/markdown-presentation/releases/tag/v0.3.1
 [composer-patches]: https://github.com/cweagans/composer-patches
 [the-patch]: https://github.com/markdown-office/PHPPresentation/blob/patches/1.2.0-to-master/patches/phpoffice-phppresentation-1.2.0-to-master.patch
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index a1711a3..a31ff1c 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -146,6 +146,19 @@ it would import the file through a lossy converter and report nothing about whet
 is valid. PowerPoint is the only application on this machine that will tell the truth about
 whether these decks open.
 
+### The schema is checked by Microsoft's own validator
+
+A deck whose XML is outside the schema opens in PowerPoint as `[Repaired]`, and the
+checks written by hand here did not catch that. `tests/Conformance/ooxml.php` runs
+Microsoft's Open XML validator — the one the Open XML SDK Productivity Tool uses — over
+the decks the library writes, and the program that does it is in
+`tools/ooxml-validator/`.
+
+It is a .NET program, so a machine without the SDK skips those tests and says what is
+missing; the job that runs them in continuous integration installs it, so the gate cannot
+skip itself there. The one deck that carries a vector needs a rasteriser to be written at
+all, and a machine without one says which deck it did not check.
+
 ## What a change has to pass
 
 ```
diff --git a/composer.json b/composer.json
index 4064e28..d028a04 100644
--- a/composer.json
+++ b/composer.json
@@ -39,9 +39,9 @@
         "patches": {
             "phpoffice/phppresentation": [
                 {
-                    "description": "PHPPresentation 1.2.0 brought up to upstream's master, with the fixes that give a picture the path, the bytes and the name it was read from, and that find the folder of a part of a package with the slashes of the package",
-                    "url": "https://raw.githubusercontent.com/markdown-office/PHPPresentation/9aa3f4624f1cab54fc5d275397c2fc59cf6f276d/patches/phpoffice-phppresentation-1.2.0-to-master.patch",
-                    "sha256": "0b8f7c150f7ba5d12671fb9e211c9f1a4db549d7609239f49c0cea707a190551"
+                    "description": "PHPPresentation 1.2.0 brought up to upstream's master, with the fixes that give a picture the path, the bytes and the name it was read from, that find the folder of a part of a package with the slashes of the package, that write a chart series in the order the schema names it, that write the data points of a series and the fill of the series itself, and that give a category axis a tick label skip of its own",
+                    "url": "https://raw.githubusercontent.com/markdown-office/PHPPresentation/605bc7c9724ac4a0781cc1692ff7ae279a33bb8a/patches/phpoffice-phppresentation-1.2.0-to-master.patch",
+                    "sha256": "46862cef4470ae8e755a03f1f8afd94c7e772cc1ee4ab0a39441c2cb392d5146"
                 }
             ]
         }
@@ -69,6 +69,7 @@
     "scripts": {
         "test": "pest",
         "test:unit": "pest --testsuite=unit",
+        "test:conformance": "pest --testsuite=conformance",
         "test:readme": "pest --testsuite=readme",
         "test:coverage": "php -d memory_limit=-1 vendor/bin/pest --coverage --min=100",
         "analyse": "tools/phpstan.sh",
diff --git a/examples/build.php b/examples/build.php
index a2653f6..8b92085 100644
--- a/examples/build.php
+++ b/examples/build.php
@@ -12,22 +12,11 @@
  */
 
 require_once __DIR__ . '/../vendor/autoload.php';
+require_once __DIR__ . '/decks.php';
 
 use MarkdownPresentation\Document\DeckParser;
 use MarkdownPresentation\Render\PresentationRenderer;
 
-/**
- * The sources this script does not convert, and why.
- *
- * Keyed by the file's stem. A deck is here because converting it is the failure it
- * exists to demonstrate, which is the same reason `markdown-word` does not build its
- * `14-rejected.md`: the build would stop, or — worse — would not stop and the gallery
- * would contain a deck that quietly came out wrong.
- */
-const NOT_BUILT = [
-    '10-rejected' => 'converting it is the failure it exists to demonstrate; see examples/README.md',
-];
-
 /** Where the decks, their PDFs and their previews are written. */
 const OUT = __DIR__ . '/out';
 
@@ -37,19 +26,6 @@
 /** The directory a relative image path in a deck resolves against. */
 const SOURCES = __DIR__ . '/markdown';
 
-/**
- * The sources written more than once, and the one line each copy differs in.
- *
- * A theme is a frontmatter key, so the only way to see the three palettes side by side is
- * to write the same deck three times. Varying it here rather than in three files keeps
- * the three decks identical apart from the one line, which is the point of the
- * comparison.
- */
-const VARIANTS = [
-    '03-themes' => ['theme' => ['default', 'corporate-dark', 'minimal']],
-    '11-type-scale' => ['theme' => ['default', 'dense']],
-];
-
 /**
  * What each built deck is for, for the report at the end and for nothing else.
  */
diff --git a/examples/decks.php b/examples/decks.php
new file mode 100644
index 0000000..9181279
--- /dev/null
+++ b/examples/decks.php
@@ -0,0 +1,34 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * The decks the examples are written as.
+ *
+ * A file of its own because two things need it: the script that writes the decks, and
+ * the test that checks what it wrote. A list of its own in either of them would be a
+ * second answer to a question this file answers, and the two would drift.
+ *
+ * Required rather than included, so that a second caller in the same run does not
+ * declare the constants again.
+ */
+
+/**
+ * The sources this script does not convert, and why.
+ *
+ * A deck is here because converting it is the failure it exists to demonstrate.
+ */
+const NOT_BUILT = [
+    '10-rejected' => 'converting it is the failure it exists to demonstrate; see examples/README.md',
+];
+
+/**
+ * The sources written more than once, and the one line each copy differs in.
+ *
+ * A theme is a frontmatter key, so the only way to see the three palettes side by side
+ * is to write the same deck three times.
+ */
+const VARIANTS = [
+    '03-themes' => ['theme' => ['default', 'corporate-dark', 'minimal']],
+    '11-type-scale' => ['theme' => ['default', 'dense']],
+];
diff --git a/phpstan.neon.dist b/phpstan.neon.dist
index b4ac8f7..411e456 100644
--- a/phpstan.neon.dist
+++ b/phpstan.neon.dist
@@ -2,11 +2,11 @@
 # tools/phpstan.sh for the version and the hash.
 #
 # Level 9, with no `ignoreErrors`, no baseline and no suppression comment anywhere
-# in this repository. `tests/Unit` and `tests/Readme` are not analysed: every one of
-# their tests is a closure handed to `it()` and every assertion goes through
-# `expect()`, both of which resolve at run time, so an analyser given neither can
-# only report that the functions are unknown. The support code those tests lean on
-# *is* analysed, and it is where the array shapes live.
+# in this repository. `tests/Unit`, `tests/Conformance` and `tests/Readme` are not
+# analysed: every one of their tests is a closure handed to `it()` and every assertion
+# goes through `expect()`, both of which resolve at run time, so an analyser given
+# neither can only report that the functions are unknown. The support code those tests
+# lean on *is* analysed, and it is where the array shapes live.
 parameters:
     level: 9
 
diff --git a/phpunit.xml.dist b/phpunit.xml.dist
index 383a647..c3c920a 100644
--- a/phpunit.xml.dist
+++ b/phpunit.xml.dist
@@ -15,6 +15,14 @@
         <testsuite name="unit">
             <directory suffix=".php">tests/Unit</directory>
         </testsuite>
+        <!--
+            The decks the library writes, checked against the schema Microsoft's own
+            validator reads. It needs the .NET SDK, which a machine without it does not
+            have, so the test skips itself there.
+        -->
+        <testsuite name="conformance">
+            <directory suffix=".php">tests/Conformance</directory>
+        </testsuite>
         <!--
             Every fenced example in README.md, run. The mechanism is described where
             it is written down — in tests/Support/Doctest.php.
diff --git a/tests/Conformance/charts.php b/tests/Conformance/charts.php
new file mode 100644
index 0000000..14288e1
--- /dev/null
+++ b/tests/Conformance/charts.php
@@ -0,0 +1,279 @@
+<?php
+
+declare(strict_types=1);
+
+use PhpOffice\PhpPresentation\PhpPresentation;
+use PhpOffice\PhpPresentation\Shape\Chart\Series;
+use PhpOffice\PhpPresentation\Shape\Chart\Type\Area;
+use PhpOffice\PhpPresentation\Shape\Chart\Type\Bar;
+use PhpOffice\PhpPresentation\Shape\Chart\Type\Bar3D;
+use PhpOffice\PhpPresentation\Shape\Chart\Type\Doughnut;
+use PhpOffice\PhpPresentation\Shape\Chart\Type\Line;
+use PhpOffice\PhpPresentation\Shape\Chart\Type\Pie;
+use PhpOffice\PhpPresentation\Shape\Chart\Type\Pie3D;
+use PhpOffice\PhpPresentation\Shape\Chart\Type\Radar;
+use PhpOffice\PhpPresentation\Shape\Chart\Type\Scatter;
+use PhpOffice\PhpPresentation\Style\Color;
+use PhpOffice\PhpPresentation\Style\Fill;
+use PhpOffice\PhpPresentation\Writer\PowerPoint2007;
+use MarkdownPresentation\Tests\Support\Scratch;
+
+/*
+ * The charts, checked against the schema Microsoft's own validator reads.
+ *
+ * **This library writes no charts.** What it carries is a patch of the library that
+ * writes them, and the patch is what the charts here are for: a patch re-rolled
+ * without a fix is a patch that has lost it, and nothing else in this repository
+ * would notice.
+ *
+ * Two things can go wrong with a chart, and they are checked both ways: the file can
+ * be outside the schema, which the validator reads, and the file can be valid and
+ * carry nothing — a chart without a data point is a valid chart, and the validator
+ * says nothing about what is not there. So the elements themselves are asserted on.
+ */
+
+it('writes charts that are valid OOXML', function () {
+    skipWithoutDotnetSdk();
+
+    $decks = writeChartDecks();
+
+    expect($decks)->not->toBe([]);
+
+    [$status, $output] = validateWithOpenXml($decks);
+
+    foreach ($decks as $deck) {
+        expect($output)->toContain(basename($deck) . ': 0 error(s)');
+    }
+
+    expect($status)->toBe(0, $output);
+});
+
+it('writes into every kind of series what the series was given', function () {
+    $withoutFill = [];
+    $withoutPoint = [];
+
+    foreach (chartTypes() as $name => $type) {
+        $deck = writeChartDeck($name, $type);
+
+        $children = seriesChildrenOf($deck);
+
+        // The fill of the series itself, which the schema names right after the title.
+        if (!in_array('c:spPr', $children, true)) {
+            $withoutFill[] = $name;
+        }
+
+        // The fill of one point of the series, which the schema names before the labels.
+        if (!in_array('c:dPt', $children, true)) {
+            $withoutPoint[] = $name;
+        }
+    }
+
+    expect($withoutFill)->toBe([], 'these kinds of series carry no fill of their own: ' . implode(', ', $withoutFill));
+    expect($withoutPoint)->toBe([], 'these kinds of series carry no data point: ' . implode(', ', $withoutPoint));
+});
+
+it('writes the fill of a data point into the data point', function () {
+    foreach (chartTypes() as $name => $type) {
+        $deck = writeChartDeck($name, $type);
+
+        expect(pointFillsOf($deck))
+            ->not->toBe([], $name . ' writes a data point with no fill in it');
+    }
+});
+
+it('gives a category axis a tick label skip of its own, and not a major unit', function () {
+    // A major unit is the distance between the ticks of a value axis; a category axis
+    // has no scale for a unit to be a distance between. The writer used to write one as
+    // the number of labels to skip, and as a fraction where the schema wants a count.
+    $deck = writeChartDeck('axis', Bar::class, majorUnit: 2.5);
+
+    expect(chartPartOf($deck))
+        ->not->toContain('c:tickLblSkip');
+
+    expect(axisOf($deck))
+        ->not->toContain('c:majorUnit');
+});
+
+it('writes the tick label skip of a category axis as a count', function () {
+    $deck = writeChartDeck('axis', Bar::class, tickLabelSkip: 3);
+
+    expect(chartPartOf($deck))
+        ->toContain('<c:tickLblSkip val="3"/>');
+});
+
+/**
+ * Every kind of chart the library writes, and the class that writes it.
+ *
+ * @return array<string, class-string<\PhpOffice\PhpPresentation\Shape\Chart\Type\AbstractType>>
+ */
+function chartTypes(): array
+{
+    return [
+        'area' => Area::class,
+        'bar' => Bar::class,
+        'bar3d' => Bar3D::class,
+        'doughnut' => Doughnut::class,
+        'line' => Line::class,
+        'pie' => Pie::class,
+        'pie3d' => Pie3D::class,
+        'radar' => Radar::class,
+        'scatter' => Scatter::class,
+    ];
+}
+
+/**
+ * A deck for every kind of chart, and the axis that carries a major unit.
+ *
+ * @return list<string> The decks written, as paths.
+ */
+function writeChartDecks(): array
+{
+    $decks = [];
+
+    foreach (chartTypes() as $name => $type) {
+        $decks[] = writeChartDeck($name, $type);
+    }
+
+    // The axis of a category, with the major unit that is not its to carry.
+    $decks[] = writeChartDeck('axis', Bar::class, majorUnit: 2.5);
+
+    return $decks;
+}
+
+/**
+ * A deck with one chart of the given kind in it.
+ *
+ * The series carries a fill of its own and a point of it carries a fill of its own,
+ * because those are the two things a chart can be asked for and not be given.
+ *
+ * @param class-string<\PhpOffice\PhpPresentation\Shape\Chart\Type\AbstractType> $type
+ */
+function writeChartDeck(string $name, string $type, ?float $majorUnit = null, ?int $tickLabelSkip = null): string
+{
+    $presentation = new PhpPresentation();
+    $slide = $presentation->createSlide();
+    $shape = $slide->createChartShape();
+
+    $series = new Series('Downloads', ['A' => 7, 'B' => 5, 'C' => 3]);
+    $series->getFill()
+        ->setFillType(Fill::FILL_SOLID)
+        ->setStartColor(new Color('FF4F81BD'));
+    $series->getDataPointFill(0)->setFillType(Fill::FILL_SOLID);
+
+    $chart = new $type();
+    $chart->addSeries($series);
+    $shape->getPlotArea()->setType($chart);
+
+    if ($majorUnit !== null) {
+        $shape->getPlotArea()->getAxisX()->setMajorUnit($majorUnit);
+    }
+
+    if ($tickLabelSkip !== null) {
+        $shape->getPlotArea()->getAxisX()->setTickLabelSkip($tickLabelSkip);
+    }
+
+    $slide->addShape($shape);
+
+    $path = Scratch::directoryPath('chart') . '/' . $name . '.pptx';
+
+    $writer = new PowerPoint2007($presentation);
+    $writer->save($path);
+
+    return $path;
+}
+
+/**
+ * The chart part of a deck, as its XML.
+ */
+function chartPartOf(string $deck): string
+{
+    $archive = new ZipArchive();
+    $opened = $archive->open($deck);
+
+    if (true !== $opened) {
+        throw new RuntimeException(sprintf('The deck %s could not be opened.', $deck));
+    }
+
+    $part = null;
+
+    for ($index = 0; $index < $archive->numFiles; $index++) {
+        $name = (string) $archive->getNameIndex($index);
+
+        if (str_starts_with($name, 'ppt/charts/chart') && str_ends_with($name, '.xml')) {
+            $part = (string) $archive->getFromIndex($index);
+            break;
+        }
+    }
+
+    $archive->close();
+
+    if ($part === null) {
+        throw new RuntimeException(sprintf('The deck %s has no chart in it.', $deck));
+    }
+
+    return $part;
+}
+
+/**
+ * The children of the series of a chart, by name.
+ *
+ * @return list<string>
+ */
+function seriesChildrenOf(string $deck): array
+{
+    $xpath = new DOMXPath(chartDomOf($deck));
+    $xpath->registerNamespace('c', 'http://schemas.openxmlformats.org/drawingml/2006/chart');
+
+    $series = $xpath->query('//c:ser')->item(0);
+
+    if ($series === null) {
+        throw new RuntimeException(sprintf('The deck %s has no series in its chart.', $deck));
+    }
+
+    $children = [];
+
+    foreach ($series->childNodes as $child) {
+        if ($child instanceof DOMElement) {
+            $children[] = 'c:' . $child->localName;
+        }
+    }
+
+    return $children;
+}
+
+/**
+ * The chart part of a deck, parsed.
+ */
+function chartDomOf(string $deck): DOMDocument
+{
+    $dom = new DOMDocument();
+    $dom->loadXML(chartPartOf($deck));
+
+    return $dom;
+}
+
+/**
+ * The fills of the data points of a chart, as XML.
+ *
+ * @return list<string>
+ */
+function pointFillsOf(string $deck): array
+{
+    $xml = chartPartOf($deck);
+
+    preg_match_all('~<c:dPt>(.*?)</c:dPt>~s', $xml, $matches);
+
+    return $matches[1];
+}
+
+/**
+ * The axes of a chart, as XML.
+ */
+function axisOf(string $deck): string
+{
+    $xml = chartPartOf($deck);
+
+    preg_match_all('~<c:(catAx|valAx)>.*?</c:\1>~s', $xml, $matches);
+
+    return implode("\n", $matches[0]);
+}
diff --git a/tests/Conformance/ooxml.php b/tests/Conformance/ooxml.php
new file mode 100644
index 0000000..a36304d
--- /dev/null
+++ b/tests/Conformance/ooxml.php
@@ -0,0 +1,239 @@
+<?php
+
+declare(strict_types=1);
+
+use MarkdownPresentation\Document\DeckParser;
+use MarkdownPresentation\Render\PresentationRenderer;
+use MarkdownPresentation\Render\SvgRasteriser;
+use MarkdownPresentation\Tests\Support\Doctest;
+use MarkdownPresentation\Tests\Support\Scratch;
+
+require_once dirname(__DIR__, 2) . '/examples/decks.php';
+
+/*
+ * Every deck this library writes, checked against the schema Microsoft's own validator
+ * reads — the one the Open XML SDK Productivity Tool uses.
+ *
+ * Nothing in this suite could see that before: a deck whose XML is outside the schema
+ * passes every check the suite made and opens in PowerPoint as `[Repaired]`. The
+ * validator is a program in `tools/ooxml-validator/` rather than a dependency, and a
+ * machine without the .NET SDK says what is missing and skips the test — a green tick
+ * for a check that never ran is a check nobody made.
+ *
+ * The deck that carries a vector is a test of its own, because it is the one deck a
+ * machine without a rasteriser cannot write. It is a test of its own so that a run says
+ * which deck it did not check, rather than checking one deck fewer and saying nothing.
+ */
+
+it('writes decks that are valid OOXML', function () {
+    skipWithoutDotnetSdk();
+
+    $decks = writeExampleDecks(false);
+
+    [$status, $output] = validateWithOpenXml($decks);
+
+    // Every deck named: the validator prints one line per file, so a deck missing
+    // from the output is a deck that was not read.
+    expect($decks)->not->toBe([]);
+
+    foreach ($decks as $deck) {
+        expect($output)->toContain(basename($deck) . ': 0 error(s)');
+    }
+
+    // The tool's own answer: 0 when every deck is clean, 1 when one is not, and 2
+    // when the tool could not run at all.
+    expect($status)->toBe(0, $output);
+});
+
+it('writes the deck that carries a vector and it is valid OOXML', function () {
+    skipWithoutDotnetSdk();
+
+    // Named before they are written, because a machine whose Imagick cannot draw a
+    // letter cannot draw the diagram either, and the library refuses the picture rather
+    // than writing a deck with a drawing that has lost its words.
+    $carrying = array_keys(array_filter(
+        exampleDecks(),
+        static fn (array $deck): bool => $deck['vector'],
+    ));
+
+    if (!(new SvgRasteriser())->available()) {
+        test()->markTestSkipped(sprintf(
+            'This build cannot rasterise an SVG, and %s carries one to be drawn.',
+            implode(', ', $carrying),
+        ));
+    }
+
+    $decks = writeExampleDecks(true);
+
+    [$status, $output] = validateWithOpenXml($decks);
+
+    expect($decks)->not->toBe([]);
+
+    foreach ($decks as $deck) {
+        expect($output)->toContain(basename($deck) . ': 0 error(s)');
+    }
+
+    expect($status)->toBe(0, $output);
+});
+
+it('finds an error in a deck that has one', function () {
+    skipWithoutDotnetSdk();
+
+    // The gate is worth nothing if it cannot fail, so this one asks the validator
+    // about a deck with an error in it. The error is an element no schema names; the
+    // deck still opens, so what refuses it is the schema and not a broken archive.
+    $decks = writeExampleDecks(false);
+
+    expect($decks)->not->toBe([]);
+
+    $broken = deckWithAnUnknownElement($decks[0]);
+
+    [$status, $output] = validateWithOpenXml([$broken]);
+
+    expect($status)->toBe(1, 'The validator did not refuse the deck:' . PHP_EOL . $output)
+        ->and($output)->toContain('notAnElement');
+});
+
+/**
+ * A copy of a deck, with an element in it that no schema names.
+ *
+ * The element goes into the shape tree of the first slide, which is where the
+ * schema is strictest about what may sit there.
+ */
+function deckWithAnUnknownElement(string $deck): string
+{
+    $archive = new ZipArchive();
+    $opened = $archive->open($deck);
+
+    if (true !== $opened) {
+        throw new RuntimeException(sprintf('The deck %s could not be opened.', $deck));
+    }
+
+    $parts = [];
+    $slide = null;
+
+    for ($i = 0; $i < $archive->numFiles; $i++) {
+        $name = (string) $archive->getNameIndex($i);
+        $parts[$name] = (string) $archive->getFromIndex($i);
+
+        if ($slide === null
+            && str_starts_with($name, 'ppt/slides/slide')
+            && str_ends_with($name, '.xml')
+        ) {
+            $slide = $name;
+        }
+    }
+
+    $archive->close();
+
+    if ($slide === null) {
+        throw new RuntimeException(sprintf('The deck %s has no slide in it.', $deck));
+    }
+
+    $broken = str_replace('<p:spTree>', '<p:spTree><p:notAnElement/>', $parts[$slide]);
+
+    if ($broken === $parts[$slide]) {
+        throw new RuntimeException(sprintf('The slide %s has no shape tree in it.', $slide));
+    }
+
+    $parts[$slide] = $broken;
+
+    // The extension matters: the tool decides how to open a file from it.
+    $path = Scratch::directoryPath('deck') . '/broken.pptx';
+
+    file_put_contents($path, '');
+
+    $copy = new ZipArchive();
+    $copy->open($path, ZipArchive::OVERWRITE);
+    foreach ($parts as $name => $contents) {
+        $copy->addFromString($name, $contents);
+    }
+    $copy->close();
+
+    return $path;
+}
+
+/**
+ * The decks of the gallery that are written in this run, and where they are written to.
+ *
+ * The plan of the decks is the one `examples/decks.php` holds: a list of its own here
+ * would be a second answer to a question that already has one, and the two would
+ * drift.
+ *
+ * @param bool $withVector Whether the decks that carry a vector are among them.
+ *
+ * @return list<string> The decks written, as paths.
+ */
+function writeExampleDecks(bool $withVector): array
+{
+    $sources = Doctest::root() . '/examples/markdown';
+    $directory = Scratch::directoryPath('decks');
+    $parser = new DeckParser();
+    $written = [];
+
+    foreach (exampleDecks() as $name => $deck) {
+        if ($deck['vector'] !== $withVector) {
+            continue;
+        }
+
+        $renderer = new PresentationRenderer($sources);
+
+        // The theme is told to the renderer rather than to the source: the theme in
+        // the source's own frontmatter is the one the deck asked for.
+        if ($deck['theme'] !== null) {
+            $renderer->withTheme($deck['theme']);
+        }
+
+        $target = sprintf('%s/%s.pptx', $directory, $name);
+
+        $renderer->render($parser->parse((string) file_get_contents($sources . '/' . $deck['source'] . '.md')), $target);
+
+        $written[] = $target;
+    }
+
+    return $written;
+}
+
+/**
+ * Every deck the gallery is built from: its name, the source it is built from, the
+ * theme it is drawn in, and whether it carries a vector.
+ *
+ * @return array<string, array{source: string, theme: string|null, vector: bool}>
+ */
+function exampleDecks(): array
+{
+    $sources = Doctest::root() . '/examples/markdown';
+    $decks = [];
+
+    foreach (glob($sources . '/*.md') ?: [] as $path) {
+        $stem = basename($path, '.md');
+
+        if (isset(NOT_BUILT[$stem])) {
+            continue;
+        }
+
+        $source = (string) file_get_contents($path);
+        $vector = carriesVector($source);
+
+        foreach (VARIANTS[$stem]['theme'] ?? [null] as $theme) {
+            $name = $theme === null ? $stem : $stem . '-' . $theme;
+
+            $decks[$name] = ['source' => $stem, 'theme' => $theme, 'vector' => $vector];
+        }
+    }
+
+    ksort($decks);
+
+    return $decks;
+}
+
+/**
+ * Whether a deck's source carries a vector, and so needs a rasteriser to be written.
+ *
+ * A `.pptx` holds a vector only beside a raster of it.
+ */
+function carriesVector(string $source): bool
+{
+    return str_contains($source, '.svg)');
+}
+
diff --git a/tests/Pest.php b/tests/Pest.php
index bad4aa4..7890200 100644
--- a/tests/Pest.php
+++ b/tests/Pest.php
@@ -3,6 +3,7 @@
 declare(strict_types=1);
 
 use MarkdownPresentation\Filesystem\PathScope;
+use MarkdownPresentation\Tests\Support\Doctest;
 use MarkdownPresentation\Tests\Support\Scratch;
 
 pest()->afterEach(function (): void {
@@ -52,3 +53,53 @@ function deckScope(string $directory, array $roots = []): PathScope
 const TWO_SLIDES = "# One\n\n---\n\n# Two\n";
 
 const TITLE_AND_CONTENT = 'Title and Content';
+
+/**
+ * Skips the test where the machine cannot run the validator.
+ *
+ * The validator is a .NET program, so the SDK is what runs it.
+ */
+function skipWithoutDotnetSdk(): void
+{
+    if (dotnetSdkIsThere()) {
+        return;
+    }
+
+    test()->markTestSkipped(
+        'The .NET SDK is not installed, so the Open XML validator cannot be run. '
+        . 'The job that runs this test in continuous integration installs it.',
+    );
+}
+
+/**
+ * Whether this machine has the .NET SDK the validator is built with.
+ *
+ * The version rather than the path: a machine with the runtime and not the SDK can run
+ * a program but not build one.
+ */
+function dotnetSdkIsThere(): bool
+{
+    exec('dotnet --version 2>&1', $output, $status);
+
+    return $status === 0;
+}
+
+/**
+ * What Microsoft's validator makes of the given decks: the exit code and what it said.
+ *
+ * @param list<string> $decks
+ *
+ * @return array{0: int, 1: string}
+ */
+function validateWithOpenXml(array $decks): array
+{
+    $command = sprintf(
+        'dotnet run --project %s -- %s 2>&1',
+        escapeshellarg(Doctest::root() . '/tools/ooxml-validator'),
+        implode(' ', array_map('escapeshellarg', $decks)),
+    );
+
+    exec($command, $output, $status);
+
+    return [$status, implode("\n", $output)];
+}
diff --git a/tests/Readme/examples-decks.php b/tests/Readme/examples-decks.php
index 6aa9a7c..3c8eecc 100644
--- a/tests/Readme/examples-decks.php
+++ b/tests/Readme/examples-decks.php
@@ -155,16 +155,16 @@ function runsOfShape(Pptx $pptx, string $name, int $slide = 1, int $index = 0):
 });
 
 it('builds every deck the page says it builds', function () use ($readme, $root) {
-    $build = (string) file_get_contents($root . '/examples/build.php');
+    $decks = (string) file_get_contents($root . '/examples/decks.php');
     preg_match_all('/`(\d{2}-[a-z-]+)\.md`\s*\|\s*\*\*nothing\*\*/', $readme, $declined);
 
     // A page that says a deck is not built has to be right about it: the reason has to be
-    // in `build.php`, keyed by the stem, or the deck stops being built for a reason nobody
-    // wrote down.
+    // in the plan of the decks, keyed by the stem, or the deck stops being built for a
+    // reason nobody wrote down.
     expect($declined[1])->not->toBe([]);
 
     foreach ($declined[1] as $name) {
-        expect($build)->toContain("'" . $name . "' => '");
+        expect($decks)->toContain("'" . $name . "' => '");
     }
 });
 
diff --git a/tests/Unit/dead-code.php b/tests/Unit/dead-code.php
index bc93551..0396952 100644
--- a/tests/Unit/dead-code.php
+++ b/tests/Unit/dead-code.php
@@ -549,6 +549,18 @@ function pagesWithClaim(string $claim): array
     expect(constantDeclarations())->toBe([]);
 });
 
+it('keeps the install state out of the package', function () {
+    // `patches.lock.json` records the patch composer-patches applied on one
+    // machine, and it wins over the manifest: a file left in the repository
+    // installs that patch rather than the one the manifest names. Every
+    // `composer install` writes it, so it is ignored rather than committed.
+    $root = Doctest::root();
+    $tracked = [];
+    exec(sprintf('git -C %s ls-files -- patches.lock.json 2>&1', escapeshellarg($root)), $tracked);
+
+    expect($tracked)->toBe([]);
+});
+
 it('says in the code why ShapeWriter is not split', function () {
     // The one class where `php:S1448` is open on purpose, so the reason has to be somewhere
     // a person deciding whether to split it will actually read — which is the class itself,
diff --git a/tools/ooxml-validator/Program.cs b/tools/ooxml-validator/Program.cs
new file mode 100644
index 0000000..bbfdb15
--- /dev/null
+++ b/tools/ooxml-validator/Program.cs
@@ -0,0 +1,114 @@
+// Validates Office Open XML files against the schema, with Microsoft's own
+// validator — the one the Open XML SDK Productivity Tool uses.
+//
+// The exit code is the answer: 0 when every file is clean, 1 when one of them is
+// not, 2 when the tool was asked to do nothing it could do. A gate built on
+// anything else would be a gate on this suite's own opinion of the format rather
+// than on the format.
+
+using DocumentFormat.OpenXml;
+using DocumentFormat.OpenXml.Packaging;
+using DocumentFormat.OpenXml.Validation;
+
+if (args.Length == 0)
+{
+    Console.Error.WriteLine("usage: ooxml-validator [--version <FileFormatVersions>] <file>...");
+    return 2;
+}
+
+// Office2019 rather than the oldest version the SDK knows: the SDK validates
+// against the schema of the version it is given, and a document written for a
+// modern Word should be read as a modern Word would read it. Every file this
+// suite writes has been checked against every version the SDK knows, and the
+// errors are the same at all of them.
+var version = FileFormatVersions.Office2019;
+var files = new List<string>();
+
+// The files are gathered while the options are read, because the value of
+// `--version` is an option's value and not the name of a file.
+for (var i = 0; i < args.Length; i++)
+{
+    if (args[i] == "--version" && i + 1 < args.Length)
+    {
+        var value = args[++i];
+        if (!Enum.TryParse<FileFormatVersions>(value, ignoreCase: true, out version))
+        {
+            Console.Error.WriteLine($"not a version the SDK knows: {value}");
+            return 2;
+        }
+
+        continue;
+    }
+
+    if (args[i].StartsWith("--"))
+    {
+        Console.Error.WriteLine($"unknown option: {args[i]}");
+        return 2;
+    }
+
+    files.Add(args[i]);
+}
+
+if (files.Count == 0)
+{
+    Console.Error.WriteLine("no files to validate");
+    return 2;
+}
+
+var errors = 0;
+
+foreach (var file in files)
+{
+    if (!File.Exists(file))
+    {
+        Console.Error.WriteLine($"{file}: no such file");
+        errors++;
+        continue;
+    }
+
+    var extension = Path.GetExtension(file).ToLowerInvariant();
+
+    try
+    {
+        errors += extension switch
+        {
+            ".docx" or ".docm" or ".dotx" or ".dotm" => Validate(file, WordprocessingDocument.Open(file, false), version),
+            ".pptx" or ".pptm" or ".potx" or ".potm" => Validate(file, PresentationDocument.Open(file, false), version),
+            _ => Unknown(file),
+        };
+    }
+    catch (Exception exception)
+    {
+        // A file the SDK cannot open is a file the gate cannot pass, so it counts
+        // as an error rather than as a reason to give up.
+        Console.Error.WriteLine($"{file}: could not be opened: {exception.Message}");
+        errors++;
+    }
+}
+
+Console.WriteLine(errors == 0
+    ? $"{files.Count} file(s) checked against {version}: no errors"
+    : $"{files.Count} file(s) checked against {version}: {errors} error(s)");
+
+return errors == 0 ? 0 : 1;
+
+static int Validate(string file, OpenXmlPackage package, FileFormatVersions version)
+{
+    var found = new OpenXmlValidator(version).Validate(package).ToList();
+
+    Console.WriteLine($"{file}: {found.Count} error(s)");
+
+    foreach (var error in found)
+    {
+        Console.WriteLine($"  [{error.ErrorType}] {error.Description}");
+        Console.WriteLine($"    part={error.Part?.Uri} path={error.Path?.XPath}");
+    }
+
+    return found.Count;
+}
+
+static int Unknown(string file)
+{
+    Console.Error.WriteLine($"{file}: not a Word or PowerPoint file");
+    return 1;
+}
diff --git a/tools/ooxml-validator/README.md b/tools/ooxml-validator/README.md
new file mode 100644
index 0000000..e78c508
--- /dev/null
+++ b/tools/ooxml-validator/README.md
@@ -0,0 +1,38 @@
+# The OOXML validator
+
+A console program that opens a `.docx` or a `.pptx` and reports what Microsoft's
+Open XML SDK makes of it. It is the oracle the gate in this repository is measured
+against, so it is not a dependency of the library — nothing the library ships
+depends on it, and the library's own suite does not need it to run.
+
+## Running it
+
+```bash
+dotnet run --project tools/ooxml-validator -- path/to/document.docx
+dotnet run --project tools/ooxml-validator -- --version Office2007 path/to/document.docx
+```
+
+The exit code is the answer: `0` when every file is clean, `1` when one of them is
+not, `2` when there was nothing to check. The errors are printed one per line with
+the part they are in and the path to them, which is what a fix needs to be pointed
+at.
+
+## Why this and not the schema
+
+The schema in ECMA-376 is the definition of the format, and a document that breaks
+it is a document that is not what it claims to be. The SDK reads the same schema,
+and it is the reader the Open XML SDK Productivity Tool — the tool Microsoft's own
+documentation points at — uses. A gate built on it is a gate on the format rather
+than on this suite's opinion of it.
+
+The SDK is also stricter than the schema in a few places, and those places are
+named in the pull requests rather than papered over: `w:tblHeader` and
+`w:bidiVisual` carry an on/off value the SDK reads as `on` or `off` alone, where
+the schema's `ST_OnOff` also allows `1` and `0`.
+
+## Where it runs
+
+The gate that uses it is a job in `.github/workflows/tests.yml`, which installs the
+.NET SDK with `actions/setup-dotnet` before the suite runs. A machine without the
+.NET SDK can still run the rest of the suite; the test that uses this tool skips
+itself there and says why.
diff --git a/tools/ooxml-validator/ooxml-validator.csproj b/tools/ooxml-validator/ooxml-validator.csproj
new file mode 100644
index 0000000..963b2cb
--- /dev/null
+++ b/tools/ooxml-validator/ooxml-validator.csproj
@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <!-- The lowest runtime the tool asks for. A newer runtime runs it unchanged,
+         so the runner's SDK does not have to match the target framework. -->
+    <TargetFramework>net8.0</TargetFramework>
+    <!-- A machine with only a newer runtime can still run this. Without it the
+         runtime refuses the application, and the gate would be a gate on the
+         version of .NET the runner happens to have. -->
+    <RollForward>Major</RollForward>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <RootNamespace>OoxmlValidator</RootNamespace>
+    <AssemblyName>ooxml-validator</AssemblyName>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <!-- The version is pinned rather than ranged, because the validator is the
+         oracle the gate is measured against: a different version of it may find
+         different errors, and a gate whose oracle moves is not a gate. -->
+    <PackageReference Include="DocumentFormat.OpenXml" Version="[3.3.0]" />
+  </ItemGroup>
+
+</Project>