diff --git a/CHANGELOG.md b/CHANGELOG.md
index f375f28..9916bd8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,41 @@ file. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versioning
 follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+### Added
+- Word's multilevel numbering through HTML. The reader counts lists on the
+  way Word does — a list broken off by a paragraph continues (`<ol start>`),
+  a level below hangs under its parent's number through a label-less parent
+  item (`ListItem::$markerHidden`) — and keeps each level's label pattern
+  (`ListNode::$levelText`: `%1.%2.`, `4.%1.`). The serializer writes the
+  labels as `::marker` rules on per-level classes into
+  `ImportedDocument::$css`; the converter reads them back from `<style>`
+  (`Converter::markerStyleOf()` carries them past a CSS inliner), and the
+  writer emits such a list as one Word multilevel numbering. A job
+  description numbered `3.1 … 3.21` came out as `1 … 21` under every
+  heading.
+- `Footnote::$sizePt`: the size a note is set in (from its runs in
+  `footnotes.xml`), written as `font-size` on `span.footnote` — notes are
+  usually 7–10 pt, and at the body's size a note took lines the page does
+  not have.
+- Each level keeps where Word places it (`ListNode::$indentLeftTwips`, from
+  the numbering's `w:ind`): the serializer writes the list without the
+  browser's nesting indent and moves every item by what its level adds.
+
+### Fixed
+- Reading headers and footers took the references of every section, and a
+  later section's part won: a seven-page form came out with the footer of
+  its last section and the first-page footer of its first. The first
+  section's parts are read now — they govern the document's first pages —
+  and first-page parts only with `<w:titlePg/>`, even-page ones only with
+  `<w:evenAndOddHeaders/>`, as Word shows them.
+- `numbering.xml` interleaved custom `abstractNum` and `num` elements; the
+  schema wants every `abstractNum` first.
+- A table cell was read paragraph by paragraph, and its numbered and
+  bulleted items came out as plain paragraphs without markers. A cell is now
+  read like a body: lists, nested tables and all.
+
 ## [1.14.1] — 2026-08-17
 
 ### Changed
diff --git a/README.md b/README.md
index 7ae0836..00ce16f 100644
--- a/README.md
+++ b/README.md
@@ -247,7 +247,7 @@ CSS-inliner upstream if needed.
 | Links | `<a href>` external, `<a href="#anchor">` internal, `<a id>` bookmarks |
 | Images | `<img src="data:image/...;base64,...">` |
 | Tables | `<table>`, `<thead>/<tbody>`, `<tr>`, `<th>/<td>`, `<colgroup>/<col>`, `<caption>`, `colspan`, `rowspan` |
-| Lists | `<ul>`, `<ol type="a/A/i/I" start="N">`, `<li value="N">`, `<dl>/<dt>/<dd>` |
+| Lists | `<ul>`, `<ol type="a/A/i/I" start="N">`, `<li value="N">`, `<dl>/<dt>/<dd>`; Word numbering labels from `.class::marker { content: … counter(list-item) / counters(list-item, ".") … }` in a `<style>`; `<li style="list-style-type:none">` holding only a nested list is a label-less parent (`3.` → `3.1.`) |
 | Custom tags | `<page-number/>`, `<page-total/>`, `<current-date format="...">`, `<page-break>` |
 | Marker classes | `class="page-number"`, `class="page-total"`, `class="page-break"` — same fields, spelled so an HTML sanitizer keeps them |
 | Layout | `<hr>`, `<br>`, `<figure>/<figcaption>` |
@@ -530,10 +530,16 @@ $imported->watermarkText;    // ?string
 $imported->pageSettings;     // PageSetup
 $imported->variables;        // list<DetectedVariable>
 $imported->media;            // array<filename, bytes>
+$imported->css;              // string — ::marker rules of Word's numbering labels
 ```
 
-HTML output uses inline styles only — re-loadable into the same library
-via `Html\Converter::fromHtml($imported->bodyHtml)`.
+HTML output uses inline styles, plus `css` for the labels of Word's
+multilevel numbering (`3.1.`, `4.1.`): `::marker` rules on the classes of
+the list items, with `<ol start>` where a list broken off by a paragraph
+numbers on. Re-loadable into the same library via
+`Html\Converter::fromHtml('<style>'.$imported->css.'</style>'.$imported->bodyHtml)`;
+an application that inlines CSS first keeps the labels with
+`Converter::markerStyleOf($html)`.
 
 ---
 
diff --git a/docs/de/README.md b/docs/de/README.md
index 4e7f83c..ca091a8 100644
--- a/docs/de/README.md
+++ b/docs/de/README.md
@@ -187,7 +187,7 @@ Das Eingabe-HTML darf **nur Inline-Styles** verwenden (keine
 | Links | `<a href>` extern, `<a href="#anchor">` intern, `<a id>` Lesezeichen |
 | Bilder | `<img src="data:image/...;base64,...">` |
 | Tabellen | `<table>`, `<thead>/<tbody>`, `<tr>`, `<th>/<td>`, `<colgroup>/<col>`, `<caption>`, `colspan`, `rowspan` |
-| Listen | `<ul>`, `<ol type="a/A/i/I" start="N">`, `<li value="N">`, `<dl>/<dt>/<dd>` |
+| Listen | `<ul>`, `<ol type="a/A/i/I" start="N">`, `<li value="N">`, `<dl>/<dt>/<dd>`; Nummerierungsbeschriftungen von Word aus `.class::marker { content: … counter(list-item) / counters(list-item, ".") … }` in einem `<style>`; ein `<li style="list-style-type:none">` nur mit einer verschachtelten Liste ist ein Elternteil ohne Beschriftung (`3.` → `3.1.`) |
 | Eigene Tags | `<page-number/>`, `<page-total/>`, `<current-date format="...">`, `<page-break>` |
 | Layout | `<hr>`, `<br>`, `<figure>/<figcaption>` |
 
@@ -452,11 +452,16 @@ $imported->watermarkText;
 $imported->pageSettings;
 $imported->variables;
 $imported->media;
+$imported->css;
 ```
 
-Die HTML-Ausgabe verwendet nur Inline-Styles und ist über
-`Html\Converter::fromHtml($imported->bodyHtml)` wieder in dieselbe
-Bibliothek ladbar.
+Die HTML-Ausgabe verwendet Inline-Styles und `css` für die Beschriftungen
+der mehrstufigen Nummerierung von Word (`3.1.`, `4.1.`): `::marker`-Regeln
+auf den Klassen der Listeneinträge, dazu `<ol start>`, wo eine durch einen
+Absatz unterbrochene Liste weiterzählt. Wieder ladbar über
+`Html\Converter::fromHtml('<style>'.$imported->css.'</style>'.$imported->bodyHtml)`;
+eine Anwendung, die CSS vorher inline setzt, behält die Beschriftungen mit
+`Converter::markerStyleOf($html)`.
 
 ---
 
diff --git a/docs/ru/README.md b/docs/ru/README.md
index 975adcf..144dc03 100644
--- a/docs/ru/README.md
+++ b/docs/ru/README.md
@@ -185,7 +185,7 @@ $imported->media;
 | Ссылки | `<a href>` внешние, `<a href="#anchor">` внутренние, `<a id>` bookmarks |
 | Картинки | `<img src="data:image/...;base64,...">` |
 | Таблицы | `<table>`, `<thead>/<tbody>`, `<tr>`, `<th>/<td>`, `<colgroup>/<col>`, `<caption>`, `colspan`, `rowspan` |
-| Списки | `<ul>`, `<ol type="a/A/i/I" start="N">`, `<li value="N">`, `<dl>/<dt>/<dd>` |
+| Списки | `<ul>`, `<ol type="a/A/i/I" start="N">`, `<li value="N">`, `<dl>/<dt>/<dd>`; метки нумерации Word из `.class::marker { content: … counter(list-item) / counters(list-item, ".") … }` в `<style>`; `<li style="list-style-type:none">` только со вложенным списком — родитель без метки (`3.` → `3.1.`) |
 | Custom-теги | `<page-number/>`, `<page-total/>`, `<current-date format="...">`, `<page-break>` |
 | Layout | `<hr>`, `<br>`, `<figure>/<figcaption>` |
 
@@ -446,10 +446,16 @@ $imported->watermarkText;
 $imported->pageSettings;
 $imported->variables;
 $imported->media;
+$imported->css;
 ```
 
-HTML-output использует только inline-стили — можно подгрузить обратно
-через `Html\Converter::fromHtml($imported->bodyHtml)`.
+HTML-output использует inline-стили и `css` для меток многоуровневой
+нумерации Word (`3.1.`, `4.1.`): правила `::marker` на классах пунктов
+списка и `<ol start>` там, где прерванный абзацем список продолжает счёт.
+Подгрузить обратно —
+`Html\Converter::fromHtml('<style>'.$imported->css.'</style>'.$imported->bodyHtml)`;
+приложение, которое сначала встраивает CSS, сохраняет метки через
+`Converter::markerStyleOf($html)`.
 
 ---
 
diff --git a/docs/zh/README.md b/docs/zh/README.md
index 851daef..819c280 100644
--- a/docs/zh/README.md
+++ b/docs/zh/README.md
@@ -180,7 +180,7 @@ $imported->media;
 | 链接 | `<a href>` 外部，`<a href="#anchor">` 内部，`<a id>` 书签 |
 | 图片 | `<img src="data:image/...;base64,...">` |
 | 表格 | `<table>`、`<thead>/<tbody>`、`<tr>`、`<th>/<td>`、`<colgroup>/<col>`、`<caption>`、`colspan`、`rowspan` |
-| 列表 | `<ul>`、`<ol type="a/A/i/I" start="N">`、`<li value="N">`、`<dl>/<dt>/<dd>` |
+| 列表 | `<ul>`、`<ol type="a/A/i/I" start="N">`、`<li value="N">`、`<dl>/<dt>/<dd>`；`<style>` 中 `.class::marker { content: … counter(list-item) / counters(list-item, ".") … }` 形式的 Word 编号标签；仅包含嵌套列表的 `<li style="list-style-type:none">` 是无标签的父项（`3.` → `3.1.`） |
 | 自定义标签 | `<page-number/>`、`<page-total/>`、`<current-date format="...">`、`<page-break>` |
 | 布局 | `<hr>`、`<br>`、`<figure>/<figcaption>` |
 
@@ -441,10 +441,15 @@ $imported->watermarkText;
 $imported->pageSettings;
 $imported->variables;
 $imported->media;
+$imported->css;
 ```
 
-HTML 输出仅使用 inline 样式，可通过
-`Html\Converter::fromHtml($imported->bodyHtml)` 重新加载到同一个库。
+HTML 输出使用 inline 样式，并通过 `css` 提供 Word 多级编号的标签（`3.1.`、
+`4.1.`）：列表项类上的 `::marker` 规则，以及被段落打断的列表继续计数时的
+`<ol start>`。可通过
+`Html\Converter::fromHtml('<style>'.$imported->css.'</style>'.$imported->bodyHtml)`
+重新加载到同一个库；先内联 CSS 的应用可用 `Converter::markerStyleOf($html)`
+保留这些标签。
 
 ---
 
diff --git a/phpstan-baseline.neon b/phpstan-baseline.neon
index e011373..fd82c3a 100644
--- a/phpstan-baseline.neon
+++ b/phpstan-baseline.neon
@@ -84,12 +84,6 @@ parameters:
 			count: 1
 			path: src/Reader/BodyReader.php
 
-		-
-			message: '#^Strict comparison using \=\=\= between '''' and '''' will always evaluate to true\.$#'
-			identifier: identical.alwaysTrue
-			count: 1
-			path: src/Reader/BodyReader.php
-
 		-
 			message: '#^Strict comparison using \=\=\= between array\{\} and array\{\} will always evaluate to true\.$#'
 			identifier: identical.alwaysTrue
@@ -99,7 +93,7 @@ parameters:
 		-
 			message: '#^Unreachable statement \- code above always terminates\.$#'
 			identifier: deadCode.unreachable
-			count: 2
+			count: 1
 			path: src/Reader/BodyReader.php
 
 		-
@@ -114,12 +108,6 @@ parameters:
 			count: 1
 			path: src/Reader/DocxReader.php
 
-		-
-			message: '#^Parameter \#1 \$byNumId of class Dskripchenko\\PhpDocx\\Reader\\NumberingDefinitions constructor expects array\<int, array\<int, array\{format\: Dskripchenko\\PhpDocx\\Element\\ListFormat, startAt\: int\}\>\>, array\<int, array\<int, array\{format\?\: Dskripchenko\\PhpDocx\\Element\\ListFormat, startAt\: int\}\>\> given\.$#'
-			identifier: argument.type
-			count: 1
-			path: src/Reader/NumberingReader.php
-
 		-
 			message: '#^Parameter \#1 \$key of function array_key_exists expects int\|string, string\|null given\.$#'
 			identifier: argument.type
diff --git a/src/Element/Footnote.php b/src/Element/Footnote.php
index ea79046..2eb11e2 100644
--- a/src/Element/Footnote.php
+++ b/src/Element/Footnote.php
@@ -14,5 +14,9 @@
  */
 final readonly class Footnote implements InlineElement
 {
-    public function __construct(public string $content) {}
+    public function __construct(
+        public string $content,
+        /** The size the note is set in at the foot of the page; null for the consumer's own. */
+        public ?float $sizePt = null,
+    ) {}
 }
diff --git a/src/Element/ListItem.php b/src/Element/ListItem.php
index 424f0af..5af12f4 100644
--- a/src/Element/ListItem.php
+++ b/src/Element/ListItem.php
@@ -28,5 +28,12 @@ public function __construct(
          * diverged from the original in how it broke into pages.
          */
         public ParagraphStyle $style = new ParagraphStyle,
+        /**
+         * An item that only carries a nested list and shows no label of its
+         * own: it stands for a parent item outside this list, so that the
+         * nested one numbers on from it (`3.1.` after a paragraph that broke
+         * the list off at `3.`).
+         */
+        public bool $markerHidden = false,
     ) {}
 }
diff --git a/src/Element/ListNode.php b/src/Element/ListNode.php
index b69d5c8..be04463 100644
--- a/src/Element/ListNode.php
+++ b/src/Element/ListNode.php
@@ -25,6 +25,13 @@
      *                                   $ordered.
      * @param  int  $startAt  The number to start from (default 1). Ignored for
      *                       bullet lists.
+     * @param  string|null  $levelText  Word's label pattern for this level
+     *                                  (`%1.%2.`, `4.%1.`): `%N` is the
+     *                                  number of level N. Null — the plain
+     *                                  `%1.` of the format.
+     * @param  string|null  $markerClass  The class that names this list
+     *                                    level in HTML: the label rule hangs
+     *                                    on it.
      */
     public function __construct(
         public array $items,
@@ -32,6 +39,14 @@ public function __construct(
         public int $levelStart = 0,
         public ?ListFormat $format = null,
         public int $startAt = 1,
+        public ?string $levelText = null,
+        public ?string $markerClass = null,
+        /**
+         * Where the level's text starts, in twips from the margin — Word
+         * places a level by its numbering, not by how deep it is nested.
+         * Null for the plain nesting indent.
+         */
+        public ?int $indentLeftTwips = null,
     ) {}
 
     public function effectiveFormat(): ListFormat
diff --git a/src/Html/Converter.php b/src/Html/Converter.php
index 1cf4c68..8dc81dc 100644
--- a/src/Html/Converter.php
+++ b/src/Html/Converter.php
@@ -52,6 +52,14 @@ final class Converter
     /** The tags that turn into a BlockElement or cause one to be split. */
     private const BLOCK_TAGS = ['p', 'div', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'table', 'hr', 'ul', 'ol', 'blockquote', 'pagebreak', 'pre', 'dl', 'figure', 'section', 'article', 'aside', 'header', 'footer', 'nav', 'main'];
 
+    /**
+     * The `::marker` contents of the style sheets, by class: the list labels
+     * an import from Word writes (`.wl5-1::marker { content: counters(…) }`).
+     *
+     * @var array<string, string>
+     */
+    private array $markerRules = [];
+
     public function __construct(
         private readonly PageSetup $defaultPageSetup = new PageSetup,
         /**
@@ -76,11 +84,14 @@ public function fromHtmlWithStyles(
         ?string $watermarkText = null,
     ): Document {
         $pre = $this->preprocessor ?? new CssInlinerPreprocessor;
+        // An inliner drops the rules it cannot put on an element; the list
+        // labels (`::marker`) are carried past it.
+        $keep = static fn (string $html): string => self::markerStyleOf($html).$pre->preprocess($html);
 
         return $this->fromHtml(
-            $pre->preprocess($body),
-            $header !== null ? $pre->preprocess($header) : null,
-            $footer !== null ? $pre->preprocess($footer) : null,
+            $keep($body),
+            $header !== null ? $keep($header) : null,
+            $footer !== null ? $keep($footer) : null,
             $pageSetup,
             $watermarkText,
         );
@@ -118,6 +129,10 @@ private function parseBlocks(string $html): array
         if (! $body instanceof \DOMElement) {
             return [];
         }
+        $this->markerRules = [];
+        foreach ($doc->getElementsByTagName('style') as $style) {
+            $this->markerRules = array_merge($this->markerRules, self::markerRules($style->textContent));
+        }
 
         // The body's inline style is the basis for every child. We simulate
         // the CSS inheritance: the font-family, colour and font-size of the
@@ -163,6 +178,10 @@ private function processChildNodes(\DOMElement $parent, RunStyle $runStyle, Para
             }
 
             $tag = strtolower($child->tagName);
+            // A style sheet is read for the list labels, never printed.
+            if ($tag === 'style' || $tag === 'script') {
+                continue;
+            }
             if (in_array($tag, self::BLOCK_TAGS, true)) {
                 $flushInline();
                 $produced = $this->processBlockElement($child, $runStyle, $paraStyle);
@@ -879,7 +898,7 @@ private function parseHr(\DOMElement $node): array
     /**
      * @return list<BlockElement>
      */
-    private function parseList(\DOMElement $node, RunStyle $runStyle, ParagraphStyle $paraStyle, bool $ordered): array
+    private function parseList(\DOMElement $node, RunStyle $runStyle, ParagraphStyle $paraStyle, bool $ordered, int $depth = 0): array
     {
         $type = $ordered ? ($node->getAttribute('type') ?: null) : null;
         $format = ListFormat::fromHtmlType($type, $ordered);
@@ -897,6 +916,7 @@ private function parseList(\DOMElement $node, RunStyle $runStyle, ParagraphStyle
         }
 
         $items = [];
+        $levelText = null;
         foreach ($node->childNodes as $child) {
             if (! $child instanceof \DOMElement) {
                 continue;
@@ -904,13 +924,14 @@ private function parseList(\DOMElement $node, RunStyle $runStyle, ParagraphStyle
             if (strtolower($child->tagName) !== 'li') {
                 continue;
             }
-            $items[] = $this->parseListItem($child, $runStyle);
+            $items[] = $this->parseListItem($child, $runStyle, $depth);
+            $levelText ??= $ordered ? $this->levelTextOf($child, $depth) : null;
         }
         if ($items === []) {
             return [];
         }
 
-        return [new ListNode($items, ordered: $ordered, format: $format, startAt: $startAt)];
+        return [new ListNode($items, ordered: $ordered, format: $format, startAt: $startAt, levelText: $levelText)];
     }
 
     private function findFirstChild(\DOMElement $node, string $tagName): ?\DOMElement
@@ -924,7 +945,7 @@ private function findFirstChild(\DOMElement $node, string $tagName): ?\DOMElemen
         return null;
     }
 
-    private function parseListItem(\DOMElement $li, RunStyle $runStyle): ListItem
+    private function parseListItem(\DOMElement $li, RunStyle $runStyle, int $depth = 0): ListItem
     {
         $inlines = [];
         $nestedList = null;
@@ -945,7 +966,7 @@ private function parseListItem(\DOMElement $li, RunStyle $runStyle): ListItem
                 // A nested list — we take the first one encountered. parseList
                 // reads the type and the start of the nested <ol> itself.
                 if ($nestedList === null) {
-                    $produced = $this->parseList($child, $runStyle, new ParagraphStyle, ordered: $tag === 'ol');
+                    $produced = $this->parseList($child, $runStyle, new ParagraphStyle, ordered: $tag === 'ol', depth: $depth + 1);
                     if ($produced !== [] && $produced[0] instanceof ListNode) {
                         $nestedList = $produced[0];
                     }
@@ -958,7 +979,92 @@ private function parseListItem(\DOMElement $li, RunStyle $runStyle): ListItem
             }
         }
 
-        return new ListItem(children: $this->trimInline($inlines), nestedList: $nestedList);
+        $inlines = $this->trimInline($inlines);
+        $css = InlineStyleParser::parse($li->getAttribute('style'));
+        $noMarker = strtolower(trim($css['list-style-type'] ?? ($css['list-style'] ?? ''))) === 'none';
+
+        return new ListItem(
+            children: $inlines,
+            nestedList: $nestedList,
+            // A label-less item that only carries a nested list stands for a
+            // parent outside the list (the nested one numbers on from it).
+            markerHidden: $noMarker && $inlines === [] && $nestedList !== null,
+        );
+    }
+
+    /**
+     * Word's label pattern of a list level out of its item's `::marker`
+     * rule: `counters(list-item, ".")` at depth 1 is `%1.%2`, a
+     * `counter(list-item)` is the level's own `%N`, strings stay as they
+     * are. Null without a rule, or with a content it cannot say.
+     */
+    private function levelTextOf(\DOMElement $li, int $depth): ?string
+    {
+        foreach (preg_split('/\s+/', trim($li->getAttribute('class'))) ?: [] as $class) {
+            $content = $this->markerRules[$class] ?? null;
+            if ($content === null) {
+                continue;
+            }
+            $text = '';
+            $rest = trim($content);
+            while ($rest !== '') {
+                if (preg_match('/^"((?:[^"\\\\]|\\\\.)*)"\s*/', $rest, $m) === 1) {
+                    $text .= stripcslashes($m[1]);
+                } elseif (preg_match('/^counters\(\s*list-item\s*,\s*"((?:[^"\\\\]|\\\\.)*)"\s*(?:,\s*[\w-]+\s*)?\)\s*/', $rest, $m) === 1) {
+                    $text .= implode(stripcslashes($m[1]), array_map(static fn (int $l): string => '%'.$l, range(1, $depth + 1)));
+                } elseif (preg_match('/^counter\(\s*list-item\s*(?:,\s*[\w-]+\s*)?\)\s*/', $rest, $m) === 1) {
+                    $text .= '%'.($depth + 1);
+                } else {
+                    return null;
+                }
+                $rest = substr($rest, strlen($m[0]));
+            }
+
+            // The space after the label is the tab Word puts there itself.
+            return rtrim($text) !== '' ? rtrim($text) : null;
+        }
+
+        return null;
+    }
+
+    /**
+     * The list-label rules (`.class::marker { content: … }`) of the HTML's
+     * `<style>` blocks as a `<style>` of their own, or '' without any. For a
+     * caller that inlines CSS before {@see fromHtml()}: an inliner cannot put
+     * a `::marker` rule on an element and drops it, and with it the labels
+     * Word's numbering came with (`3.1.`).
+     */
+    public static function markerStyleOf(string $html): string
+    {
+        if (! str_contains($html, '::marker') || preg_match_all('#<style\b[^>]*>(.*?)</style>#is', $html, $blocks) === 0) {
+            return '';
+        }
+        $css = '';
+        foreach (self::markerRules(implode("\n", $blocks[1])) as $class => $content) {
+            $css .= '.'.$class.'::marker { content: '.$content." }\n";
+        }
+
+        return $css !== '' ? '<style>'.$css.'</style>' : '';
+    }
+
+    /**
+     * `.class::marker { content: … }` rules of a style sheet, by class.
+     *
+     * @return array<string, string>
+     */
+    private static function markerRules(string $css): array
+    {
+        $rules = [];
+        $css = (string) preg_replace('#/\*.*?\*/#s', '', $css);
+        if (preg_match_all('/\.([\w-]+)::marker\s*\{([^}]*)\}/', $css, $matches, PREG_SET_ORDER) > 0) {
+            foreach ($matches as [, $class, $body]) {
+                if (preg_match('/(?:^|;)\s*content\s*:\s*([^;]+)/', $body, $m) === 1) {
+                    $rules[$class] = trim($m[1]);
+                }
+            }
+        }
+
+        return $rules;
     }
 
     private function parseInlineImage(\DOMElement $node): ?Image
diff --git a/src/Html/ImportedDocument.php b/src/Html/ImportedDocument.php
index f0eebd2..6797bd3 100644
--- a/src/Html/ImportedDocument.php
+++ b/src/Html/ImportedDocument.php
@@ -40,5 +40,11 @@ public function __construct(
         public PageSetup $pageSettings = new PageSetup,
         public array $variables = [],
         public array $media = [],
+        /**
+         * The style sheet the HTML needs beyond inline styles: the list labels
+         * of Word's numbering (`3.1.`, `4.1.`) as `::marker` rules on the
+         * classes of the list items. Empty when there are none.
+         */
+        public string $css = '',
     ) {}
 }
diff --git a/src/Html/Serializer.php b/src/Html/Serializer.php
index fb4e1f8..51c3841 100644
--- a/src/Html/Serializer.php
+++ b/src/Html/Serializer.php
@@ -71,6 +71,9 @@ final class Serializer
 
     private int $mediaCounter = 0;
 
+    /** @var array<string, string> list-level class → its `::marker` content */
+    private array $markerRules = [];
+
     /**
      * @param  list<DetectedVariable>  $variables  An optional list of variables
      *         (when the caller ran VariableDetector separately).
@@ -79,6 +82,7 @@ public function serialize(Document $document, array $variables = []): ImportedDo
     {
         $this->media = [];
         $this->mediaCounter = 0;
+        $this->markerRules = [];
 
         $bodyHtml = $this->renderBlocks($document->section->body);
         $headerHtml = $document->section->header !== []
@@ -104,9 +108,69 @@ public function serialize(Document $document, array $variables = []): ImportedDo
             pageSettings: $document->section->pageSetup,
             variables: $variables,
             media: $this->media,
+            css: $this->markerCss(),
         );
     }
 
+    /** The `::marker` rules of the list levels met, one per class. */
+    private function markerCss(): string
+    {
+        $css = '';
+        foreach ($this->markerRules as $class => $content) {
+            $css .= '.'.$class.'::marker { content: '.$content." }\n";
+        }
+
+        return $css;
+    }
+
+    /**
+     * Word's label pattern as CSS `content` for a list level: `%1.%2.` is
+     * `counters(list-item, ".")` plus the trailing `.`, `4.%1.` is a string
+     * around `counter(list-item)`. Null for the plain `%N.` the browser
+     * draws anyway, and for patterns CSS cannot say (`%1-%3`).
+     */
+    private static function markerContent(ListNode $list, int $depth): ?string
+    {
+        $text = $list->levelText;
+        if ($text === null) {
+            return null;
+        }
+        $parts = preg_split('/%([1-9])/', $text, -1, PREG_SPLIT_DELIM_CAPTURE) ?: [];
+        $literals = [];
+        $levels = [];
+        foreach ($parts as $i => $part) {
+            if ($i % 2 === 0) {
+                $literals[] = $part;
+            } else {
+                $levels[] = (int) $part;
+            }
+        }
+        $style = match ($list->effectiveFormat()) {
+            \Dskripchenko\PhpDocx\Element\ListFormat::LowerLetter => 'lower-alpha',
+            \Dskripchenko\PhpDocx\Element\ListFormat::UpperLetter => 'upper-alpha',
+            \Dskripchenko\PhpDocx\Element\ListFormat::LowerRoman => 'lower-roman',
+            \Dskripchenko\PhpDocx\Element\ListFormat::UpperRoman => 'upper-roman',
+            default => null,
+        };
+        $prefix = $literals[0];
+        $suffix = $literals[count($literals) - 1];
+        $quote = static fn (string $s): string => '"'.str_replace(['\\', '"'], ['\\\\', '\\"'], $s).'"';
+        $styleArg = $style !== null ? ', '.$style : '';
+
+        if ($levels === [$depth + 1]) {
+            if ($prefix === '' && $suffix === '.') {
+                return null; // the browser's own label
+            }
+            $counter = 'counter(list-item'.$styleArg.')';
+        } elseif ($levels === range(1, $depth + 1) && count(array_unique(array_slice($literals, 1, -1))) === 1) {
+            $counter = 'counters(list-item, '.$quote($literals[1]).$styleArg.')';
+        } else {
+            return null;
+        }
+
+        return trim(($prefix !== '' ? $quote($prefix).' ' : '').$counter.' '.$quote($suffix.' '));
+    }
+
     /**
      * @param  list<BlockElement>  $blocks
      */
@@ -170,7 +234,7 @@ private function renderInline(InlineElement $el): string
             $el instanceof Hyperlink => $this->renderHyperlink($el),
             $el instanceof Image => $this->renderImage($el),
             $el instanceof Bookmark => $this->renderBookmark($el),
-            $el instanceof Footnote => '<span class="footnote">'.$this->escape($el->content).'</span>',
+            $el instanceof Footnote => '<span class="footnote"'.($el->sizePt !== null ? ' style="font-size:'.rtrim(rtrim(sprintf('%.2f', $el->sizePt), '0'), '.').'pt"' : '').'>'.$this->escape($el->content).'</span>',
             $el instanceof Field => $this->renderField($el),
             $el instanceof PageBreak => '', // обычно split'ится в Paragraph
             default => '',
@@ -332,10 +396,12 @@ private function dataUrl(string $bytes, ImageFormat $format): string
         return 'data:'.$mime.';base64,'.base64_encode($bytes);
     }
 
-    private function renderList(ListNode $list): string
+    private function renderList(ListNode $list, int $depth = 0, int $parentLeftTwips = 0): string
     {
         $tag = $list->ordered ? 'ol' : 'ul';
-        $attrs = '';
+        // A level placed by Word's numbering: no nesting indent of the
+        // browser's own, every item moved by what its level adds.
+        $attrs = $list->indentLeftTwips !== null ? ' style="margin:0;padding-left:0"' : '';
         if ($list->ordered) {
             $type = $this->listTypeAttr($list);
             if ($type !== null) {
@@ -345,9 +411,14 @@ private function renderList(ListNode $list): string
                 $attrs .= ' start="'.$list->startAt.'"';
             }
         }
+        $class = null;
+        if ($list->ordered && $list->markerClass !== null && ($content = self::markerContent($list, $depth)) !== null) {
+            $class = $list->markerClass;
+            $this->markerRules[$class] = $content;
+        }
         $items = '';
         foreach ($list->items as $item) {
-            $items .= $this->renderListItem($item);
+            $items .= $this->renderListItem($item, $class, $depth, $list->indentLeftTwips, $parentLeftTwips);
         }
 
         return '<'.$tag.$attrs.'>'.$items.'</'.$tag.'>';
@@ -364,12 +435,27 @@ private function listTypeAttr(ListNode $list): ?string
         };
     }
 
-    private function renderListItem(ListItem $item): string
+    private function renderListItem(ListItem $item, ?string $class = null, int $depth = 0, ?int $levelLeftTwips = null, int $parentLeftTwips = 0): string
     {
         $inner = $this->renderInlines($item->children);
-        $nested = $item->nestedList !== null ? $this->renderList($item->nestedList) : '';
-        $css = $this->paragraphStyleCss($item->style);
-        $attrs = $css !== '' ? ' style="'.$css.'"' : '';
+        $style = $item->style;
+        $left = $parentLeftTwips;
+        if ($levelLeftTwips !== null) {
+            // The paragraph's own indent wins over its level's; the label hangs
+            // outside the text, so the first-line offset goes.
+            $left = $style->indentLeftTwips !== 0 ? $style->indentLeftTwips : $levelLeftTwips;
+            $style = $style->copy(indentLeftTwips: $left - $parentLeftTwips, indentFirstLineTwips: 0);
+        }
+        $nested = $item->nestedList !== null ? $this->renderList($item->nestedList, $depth + 1, $left) : '';
+        $css = $this->paragraphStyleCss($style);
+        // An item that only carries a nested list shows no label: it stands
+        // for a parent outside the list, and its number is what the nested
+        // one counts on from.
+        if ($item->markerHidden) {
+            $css = trim('list-style-type:none;'.$css, ';');
+        }
+        $attrs = ($class !== null && ! $item->markerHidden ? ' class="'.$class.'"' : '')
+            .($css !== '' ? ' style="'.$css.'"' : '');
 
         return '<li'.$attrs.'>'.$inner.$nested.'</li>';
     }
diff --git a/src/Reader/BodyReader.php b/src/Reader/BodyReader.php
index 45c7ba8..cef98bc 100644
--- a/src/Reader/BodyReader.php
+++ b/src/Reader/BodyReader.php
@@ -50,6 +50,15 @@ final class BodyReader
 {
     private ?TableReader $tableReader = null;
 
+    /**
+     * The running numbers of the lists, by counter key and level: Word
+     * numbers on across lists of one numbering, so a list broken off by a
+     * paragraph continues where it stopped.
+     *
+     * @var array<string, array<int, int>>
+     */
+    private array $counters = [];
+
     public function __construct(
         private readonly StylesResolver $styles = new StylesResolver,
         private readonly NumberingDefinitions $numbering = new NumberingDefinitions,
@@ -164,8 +173,35 @@ private function buildListNode(array $items, ?int $numId): ListNode
             // It should not happen — but a fallback.
             return new ListNode([]);
         }
-        $minIlvl = $this->minIlvl($items);
-        $root = $this->buildRecursive($items, 0, count($items), $minIlvl, $numId);
+        $key = $this->numbering->counterKey($numId);
+        $before = $this->counters[$key] ?? [];
+
+        // A list that starts below the top level, after the list was broken
+        // off: it hangs under its parent's number (3. → 3.1.) through
+        // label-less wrapper items, as deep as the counters go.
+        // The same when the level's label names the levels above it (`%1.%2.`)
+        // with none of them met yet: Word shows their starts there.
+        $depth = $this->minIlvl($items);
+        while ($depth > 0 && (isset($before[$depth - 1]) || $this->namesUpperLevel($numId, $depth))) {
+            $depth--;
+        }
+
+        // Every item's number: on from the last one of its level, a higher
+        // level restarting the deeper ones.
+        foreach ($items as $i => $item) {
+            $level = $item['ilvl'];
+            $counters = $this->counters[$key] ?? [];
+            $counters[$level] = isset($counters[$level]) ? $counters[$level] + 1 : $this->numbering->startAtFor($numId, $level);
+            foreach (array_keys($counters) as $deeper) {
+                if ($deeper > $level) {
+                    unset($counters[$deeper]);
+                }
+            }
+            $this->counters[$key] = $counters;
+            $items[$i]['number'] = $counters[$level];
+        }
+
+        $root = $this->buildRecursive($items, 0, count($items), $depth, $numId, $before);
         if ($root instanceof ListNode) {
             return $root;
         }
@@ -173,6 +209,23 @@ private function buildListNode(array $items, ?int $numId): ListNode
         return new ListNode([]);
     }
 
+    /** Whether a level's label pattern shows a level above it (`%1` in `%1.%2.`). */
+    private function namesUpperLevel(int $numId, int $level): bool
+    {
+        $text = $this->numbering->levelTextFor($numId, $level) ?? '';
+
+        if (preg_match_all('/%([1-9])/', $text, $m) === 0) {
+            return false;
+        }
+        foreach ($m[1] as $named) {
+            if ((int) $named <= $level) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
     /**
      * @param  list<array{numId:int, ilvl:int, inlines:list<InlineElement>, style:ParagraphStyle}>  $items
      */
@@ -193,11 +246,13 @@ private function minIlvl(array $items): int
      * items with ilvl == depth become siblings inside the current ListNode; the
      * items with ilvl > depth are nested inside the previous sibling.
      *
-     * @param  list<array{numId:int, ilvl:int, inlines:list<InlineElement>, style:ParagraphStyle}>  $items
+     * @param  list<array{numId:int, ilvl:int, inlines:list<InlineElement>, style:ParagraphStyle, number?:int}>  $items
+     * @param  array<int, int>  $before  The counters as they stood before this list: a wrapper item shows its parent's number.
      */
-    private function buildRecursive(array $items, int $from, int $to, int $depth, int $numId): ListNode
+    private function buildRecursive(array $items, int $from, int $to, int $depth, int $numId, array $before = []): ListNode
     {
         $siblings = [];
+        $startAt = null;
         $i = $from;
         while ($i < $to) {
             $cur = $items[$i];
@@ -210,14 +265,16 @@ private function buildRecursive(array $items, int $from, int $to, int $depth, in
                 while ($j < $to && $items[$j]['ilvl'] > $depth) {
                     $j++;
                 }
-                $nested = $this->buildRecursive($items, $i, $j, $depth + 1, $numId);
+                $nested = $this->buildRecursive($items, $i, $j, $depth + 1, $numId, $before);
                 // Attach it as the nestedList of the last sibling, when there is one.
                 if ($siblings !== []) {
                     $last = $siblings[count($siblings) - 1];
                     $siblings[count($siblings) - 1] = new ListItem($last->children, $nested, $last->style);
                 } else {
-                    // There is no previous sibling — we wrap it into an empty parent item.
-                    $siblings[] = new ListItem([], $nested);
+                    // There is no previous sibling: a label-less parent item
+                    // that carries the parent's number.
+                    $siblings[] = new ListItem([], $nested, markerHidden: true);
+                    $startAt ??= $before[$depth] ?? $this->numbering->startAtFor($numId, $depth);
                 }
                 $i = $j;
 
@@ -225,19 +282,22 @@ private function buildRecursive(array $items, int $from, int $to, int $depth, in
             }
             // ilvl == depth — an ordinary sibling.
             $siblings[] = new ListItem($cur['inlines'], null, $cur['style']);
+            $startAt ??= $cur['number'] ?? null;
             $i++;
         }
 
         $format = $this->numbering->formatFor($numId, $depth);
-        $startAt = $this->numbering->startAtFor($numId, $depth);
         $ordered = $this->numbering->isOrdered($numId, $depth);
 
         return new ListNode(
             items: $siblings,
             ordered: $ordered,
-            levelStart: 0, // дочерние уровни сами знают свой ilvl через nesting
+            levelStart: 0, // the nested levels know their ilvl through the nesting
             format: $format,
-            startAt: $startAt,
+            startAt: $startAt ?? $this->numbering->startAtFor($numId, $depth),
+            levelText: $ordered ? $this->numbering->levelTextFor($numId, $depth) : null,
+            markerClass: $ordered ? 'wl'.$numId.'-'.$depth : null,
+            indentLeftTwips: $this->numbering->indentLeftFor($numId, $depth),
         );
     }
 
@@ -432,6 +492,10 @@ private function readRunWithFieldState(
         }
 
         $flushText = function () use (&$emitted, &$textBuffer, &$state, &$valueSeen, $suppressValue, $runStyle): void {
+            // By reference: the run's text and state as they are now, not at
+            // the closure's creation (phpstan 2.3 reads them as the latter).
+            /** @var string $textBuffer */
+            /** @var string|null $state */
             if ($textBuffer === '') {
                 return;
             }
@@ -522,7 +586,7 @@ private function readRunWithFieldState(
                         $id = $child->getAttributeNS(OoxmlNs::W, 'id');
                         $text = ctype_digit(ltrim($id, '-')) ? $this->footnotes->text((int) $id) : null;
                         if ($text !== null) {
-                            $emitted[] = new Footnote($text);
+                            $emitted[] = new Footnote($text, $this->footnotes->size((int) $id));
                         }
                     }
                     break;
diff --git a/src/Reader/DocxReader.php b/src/Reader/DocxReader.php
index 1f40246..0f94e99 100644
--- a/src/Reader/DocxReader.php
+++ b/src/Reader/DocxReader.php
@@ -54,9 +54,20 @@ public function readPackage(DocxPackage $pkg): Document
         $body = $bodyReader->read($bodyEl);
         $pageSetup = (new SectionReader)->readPageSetup($bodyEl);
 
-        // Map path → type through the sectPr references.
-        $headerTypes = $this->resolveHeaderTypes($bodyEl, $pkg, isFooter: false);
-        $footerTypes = $this->resolveHeaderTypes($bodyEl, $pkg, isFooter: true);
+        // Map path → type through the references of the FIRST section: the
+        // document is read as one section, and its first pages are what the
+        // first section's parts govern. Taking the references of every
+        // section let a later section's parts win, and a first-page footer
+        // showed up where Word shows none.
+        $sectPr = $bodyEl->getElementsByTagNameNS(OoxmlNs::W, 'sectPr')->item(0);
+        $scope = $sectPr instanceof \DOMElement ? $sectPr : $bodyEl;
+        $headerTypes = $this->resolveHeaderTypes($scope, $pkg, isFooter: false);
+        $footerTypes = $this->resolveHeaderTypes($scope, $pkg, isFooter: true);
+        // Word shows the first-page parts only with <w:titlePg/>, the
+        // even-page ones only with <w:evenAndOddHeaders/> in the settings.
+        $usesFirst = $sectPr instanceof \DOMElement && self::onFlag($sectPr, 'titlePg');
+        $usesEven = $pkg->settingsXml?->documentElement instanceof \DOMElement
+            && self::onFlag($pkg->settingsXml->documentElement, 'evenAndOddHeaders');
 
         $headersBy = [
             'default' => [],
@@ -71,13 +82,13 @@ public function readPackage(DocxPackage $pkg): Document
         $watermarkText = null;
 
         foreach ($pkg->headers as $partPath => $headerDoc) {
-            $type = $headerTypes[$partPath] ?? 'default';
+            $type = $headerTypes[$partPath] ?? null;
             // A watermark usually sits in the default header; extract it from any
             // one (the first found wins) so that HTML does not get duplicates.
             $watermarkText ??= (new WatermarkExtractor)->extract($headerDoc);
 
             $headerRoot = $headerDoc->documentElement;
-            if (! $headerRoot instanceof \DOMElement) {
+            if ($type === null || ! $headerRoot instanceof \DOMElement) {
                 continue;
             }
             $hImg = new ImageReader($pkg, $partPath);
@@ -86,9 +97,9 @@ public function readPackage(DocxPackage $pkg): Document
         }
 
         foreach ($pkg->footers as $partPath => $footerDoc) {
-            $type = $footerTypes[$partPath] ?? 'default';
+            $type = $footerTypes[$partPath] ?? null;
             $footerRoot = $footerDoc->documentElement;
-            if (! $footerRoot instanceof \DOMElement) {
+            if ($type === null || ! $footerRoot instanceof \DOMElement) {
                 continue;
             }
             $fImg = new ImageReader($pkg, $partPath);
@@ -102,10 +113,10 @@ public function readPackage(DocxPackage $pkg): Document
                 header: $headersBy['default'],
                 footer: $footersBy['default'],
                 pageSetup: $pageSetup,
-                firstHeader: $headersBy['first'],
-                firstFooter: $footersBy['first'],
-                evenHeader: $headersBy['even'],
-                evenFooter: $footersBy['even'],
+                firstHeader: $usesFirst ? $headersBy['first'] : [],
+                firstFooter: $usesFirst ? $footersBy['first'] : [],
+                evenHeader: $usesEven ? $headersBy['even'] : [],
+                evenFooter: $usesEven ? $footersBy['even'] : [],
             ),
             watermarkText: $watermarkText,
         );
@@ -146,6 +157,18 @@ private function resolveHeaderTypes(\DOMElement $body, DocxPackage $pkg, bool $i
         return $out;
     }
 
+    /** An on/off element among the children: present and not `w:val="0|false|off"`. */
+    private static function onFlag(\DOMElement $parent, string $name): bool
+    {
+        foreach ($parent->childNodes as $child) {
+            if ($child instanceof \DOMElement && $child->namespaceURI === OoxmlNs::W && $child->localName === $name) {
+                return ! in_array(strtolower($child->getAttributeNS(OoxmlNs::W, 'val')), ['0', 'false', 'off'], true);
+            }
+        }
+
+        return false;
+    }
+
     /**
      * @param  list<mixed>  $items
      * @return list<BlockElement>
diff --git a/src/Reader/FootnoteReader.php b/src/Reader/FootnoteReader.php
index 2c8f4f4..4f3de5b 100644
--- a/src/Reader/FootnoteReader.php
+++ b/src/Reader/FootnoteReader.php
@@ -7,15 +7,19 @@
 /**
  * The footnote texts from `word/footnotes.xml`, by their identifiers.
  *
- * The formatting of a footnote is deliberately not carried over: at the foot of
- * the page it is set in its own size, and the markup of the source paragraph
- * decides nothing there. What is needed is the text.
+ * The text and the size it is set in at the foot of the page — notes are
+ * usually smaller than the body (7–10 pt), and printed at the body's size a
+ * note takes lines the page does not have. The rest of the formatting is not
+ * carried over.
  */
 final class FootnoteReader
 {
     /** @var array<int, string> */
     private array $byId = [];
 
+    /** @var array<int, float> */
+    private array $sizeById = [];
+
     public function __construct(?\DOMDocument $footnotesXml)
     {
         if ($footnotesXml === null) {
@@ -37,6 +41,7 @@ public function __construct(?\DOMDocument $footnotesXml)
 
             $parts = [];
             $first = true;
+            unset($size);
             foreach ($footnote->getElementsByTagNameNS(OoxmlNs::W, 'r') as $run) {
                 // A footnote mark is its number. Word places it either with the
                 // internal `w:footnoteRef` or simply as a superscript in the
@@ -51,10 +56,19 @@ public function __construct(?\DOMDocument $footnotesXml)
                 foreach ($run->getElementsByTagNameNS(OoxmlNs::W, 't') as $t) {
                     $parts[] = $t->textContent;
                 }
+                // The size of the first run of text is the note's size.
+                if (! isset($size) && $run->getElementsByTagNameNS(OoxmlNs::W, 't')->length > 0) {
+                    $sz = $run->getElementsByTagNameNS(OoxmlNs::W, 'sz')->item(0);
+                    $val = $sz instanceof \DOMElement ? $sz->getAttributeNS(OoxmlNs::W, 'val') : '';
+                    $size = ctype_digit($val) ? ((int) $val) / 2 : null;
+                }
             }
             $text = trim(preg_replace('/\s+/u', ' ', implode('', $parts)) ?? '');
             if ($text !== '') {
                 $this->byId[(int) $id] = $text;
+                if (isset($size)) {
+                    $this->sizeById[(int) $id] = $size;
+                }
             }
         }
     }
@@ -74,4 +88,10 @@ public function text(int $id): ?string
     {
         return $this->byId[$id] ?? null;
     }
+
+    /** The note's size in points, when its text says it. */
+    public function size(int $id): ?float
+    {
+        return $this->sizeById[$id] ?? null;
+    }
 }
diff --git a/src/Reader/NumberingDefinitions.php b/src/Reader/NumberingDefinitions.php
index 496e589..b1091cc 100644
--- a/src/Reader/NumberingDefinitions.php
+++ b/src/Reader/NumberingDefinitions.php
@@ -15,12 +15,42 @@
 final readonly class NumberingDefinitions
 {
     /**
-     * @param  array<int, array<int, array{format: ListFormat, startAt: int}>>  $byNumId
+     * @param  array<int, array<int, array{format?: ListFormat, startAt?: int, levelText?: string|null, indentLeft?: int|null}>>  $byNumId
+     * @param  array<int, int>  $abstractOf  numId → abstractNumId
+     * @param  array<int, true>  $restarts  numIds with a level override — they restart the numbering
      */
     public function __construct(
         public array $byNumId = [],
+        public array $abstractOf = [],
+        public array $restarts = [],
     ) {}
 
+    /** Where a level's text starts, in twips from the margin; null when the level does not say. */
+    public function indentLeftFor(int $numId, int $level = 0): ?int
+    {
+        return $this->byNumId[$numId][$level]['indentLeft'] ?? null;
+    }
+
+    /** Word's label pattern of a level (`%1.%2.`); null when not given. */
+    public function levelTextFor(int $numId, int $level = 0): ?string
+    {
+        $text = $this->byNumId[$numId][$level]['levelText'] ?? null;
+
+        return $text !== null && $text !== '' ? $text : null;
+    }
+
+    /**
+     * What a list's numbers continue from: lists of one abstract numbering
+     * count on together in Word, unless an instance restarts with a level
+     * override.
+     */
+    public function counterKey(int $numId): string
+    {
+        return isset($this->restarts[$numId]) || ! isset($this->abstractOf[$numId])
+            ? 'n'.$numId
+            : 'a'.$this->abstractOf[$numId];
+    }
+
     public function formatFor(int $numId, int $level = 0): ListFormat
     {
         return $this->byNumId[$numId][$level]['format']
diff --git a/src/Reader/NumberingReader.php b/src/Reader/NumberingReader.php
index 9057bd7..00bd7b7 100644
--- a/src/Reader/NumberingReader.php
+++ b/src/Reader/NumberingReader.php
@@ -42,6 +42,8 @@ public function read(?\DOMDocument $numberingXml): NumberingDefinitions
 
         // Concrete instances: numId → abstractNumId + overrides.
         $byNumId = [];
+        $abstractOf = [];
+        $restarts = [];
         foreach (OoxmlNs::children($root, OoxmlNs::W, 'num') as $num) {
             $numId = $num->getAttributeNS(OoxmlNs::W, 'numId');
             if ($numId === '' || ! ctype_digit($numId)) {
@@ -79,13 +81,17 @@ public function read(?\DOMDocument $numberingXml): NumberingDefinitions
             }
 
             $byNumId[(int) $numId] = $absLevels;
+            $abstractOf[(int) $numId] = (int) $abstractId;
+            if (OoxmlNs::children($num, OoxmlNs::W, 'lvlOverride') !== []) {
+                $restarts[(int) $numId] = true;
+            }
         }
 
-        return new NumberingDefinitions($byNumId);
+        return new NumberingDefinitions($byNumId, $abstractOf, $restarts);
     }
 
     /**
-     * @return array<int, array{format: ListFormat, startAt: int}>
+     * @return array<int, array{format: ListFormat, startAt: int, levelText: string|null, indentLeft: int|null}>
      */
     private function readAbstractLevels(\DOMElement $abstractNum): array
     {
@@ -102,12 +108,13 @@ private function readAbstractLevels(\DOMElement $abstractNum): array
     }
 
     /**
-     * @return array{format: ListFormat, startAt: int}
+     * @return array{format: ListFormat, startAt: int, levelText: string|null, indentLeft: int|null}
      */
     private function readSingleLevel(\DOMElement $lvl): array
     {
         $numFmt = OoxmlNs::firstChild($lvl, OoxmlNs::W, 'numFmt');
         $start = OoxmlNs::firstChild($lvl, OoxmlNs::W, 'start');
+        $lvlText = OoxmlNs::firstChild($lvl, OoxmlNs::W, 'lvlText');
 
         $format = ListFormat::Decimal;
         if ($numFmt !== null) {
@@ -129,6 +136,26 @@ private function readSingleLevel(\DOMElement $lvl): array
             }
         }
 
-        return ['format' => $format, 'startAt' => $startAt];
+        // The level's own indent: where its text starts, the label hanging
+        // in front of it.
+        $indentLeft = null;
+        $pPr = OoxmlNs::firstChild($lvl, OoxmlNs::W, 'pPr');
+        $ind = $pPr !== null ? OoxmlNs::firstChild($pPr, OoxmlNs::W, 'ind') : null;
+        if ($ind !== null) {
+            foreach (['left', 'start'] as $attr) {
+                $v = $ind->getAttributeNS(OoxmlNs::W, $attr);
+                if ($v !== '' && is_numeric($v)) {
+                    $indentLeft = (int) $v;
+                    break;
+                }
+            }
+        }
+
+        return [
+            'format' => $format,
+            'startAt' => $startAt,
+            'levelText' => $lvlText !== null ? OoxmlNs::wVal($lvlText) : null,
+            'indentLeft' => $indentLeft,
+        ];
     }
 }
diff --git a/src/Reader/TableReader.php b/src/Reader/TableReader.php
index 48e78b9..f512514 100644
--- a/src/Reader/TableReader.php
+++ b/src/Reader/TableReader.php
@@ -177,20 +177,10 @@ private function readCell(\DOMElement $tc): TableCell
         $tcPr = OoxmlNs::firstChild($tc, OoxmlNs::W, 'tcPr');
         $style = $this->readCellStyle($tcPr);
 
-        $children = [];
-        foreach ($tc->childNodes as $child) {
-            if (! $child instanceof \DOMElement || $child->namespaceURI !== OoxmlNs::W) {
-                continue;
-            }
-            if ($child->localName === 'p') {
-                foreach ($this->body->readParagraph($child) as $b) {
-                    $children[] = $b;
-                }
-            } elseif ($child->localName === 'tbl') {
-                $children[] = $this->read($child);
-            }
-            // tcPr — skip
-        }
+        // A cell holds what a body holds: paragraphs, lists, tables. Read
+        // paragraph by paragraph, its numbered and bulleted items lost their
+        // markers.
+        $children = $this->body->read($tc);
         if ($children === []) {
             $children = [new Paragraph([])];
         }
diff --git a/src/Writer/BodyXmlBuilder.php b/src/Writer/BodyXmlBuilder.php
index 2cf8c51..c8c392f 100644
--- a/src/Writer/BodyXmlBuilder.php
+++ b/src/Writer/BodyXmlBuilder.php
@@ -99,6 +99,15 @@ private function renderBlock(BlockElement $block): string
 
     private function renderListNode(ListNode $list): string
     {
+        if (self::carriesWordNumbering($list)) {
+            $levels = [];
+            self::collectLevels($list, 0, $levels);
+            $numId = $this->numbering->instanceForLevels($levels);
+            $this->usesNumbering = true;
+
+            return $this->renderTreeItems($list, $numId, 0);
+        }
+
         $numId = $this->numbering->instanceFor($list->effectiveFormat(), $list->startAt);
         $this->usesNumbering = true;
 
@@ -110,6 +119,70 @@ private function renderListNode(ListNode $list): string
         return $xml;
     }
 
+    /**
+     * Whether a list tree carries Word's own numbering — level patterns, or
+     * label-less parent items: it is then written as one multilevel
+     * numbering, as Word keeps it.
+     */
+    private static function carriesWordNumbering(ListNode $list): bool
+    {
+        if ($list->levelText !== null) {
+            return true;
+        }
+        foreach ($list->items as $item) {
+            if ($item->markerHidden || ($item->nestedList !== null && self::carriesWordNumbering($item->nestedList))) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * The levels of a list tree: the first list met at each depth gives its
+     * format, start and pattern.
+     *
+     * @param  array<int, array{format: \Dskripchenko\PhpDocx\Element\ListFormat, startAt: int, levelText: string|null}>  $levels
+     */
+    private static function collectLevels(ListNode $list, int $depth, array &$levels): void
+    {
+        $levels[$depth] ??= ['format' => $list->effectiveFormat(), 'startAt' => $list->startAt, 'levelText' => $list->levelText];
+        foreach ($list->items as $item) {
+            if ($item->nestedList !== null) {
+                self::collectLevels($item->nestedList, $depth + 1, $levels);
+            }
+        }
+    }
+
+    /**
+     * The items of a tree as numbered paragraphs at their depth. A
+     * label-less parent item writes no paragraph of its own: its number is
+     * the start of its level, which the nested items show (`3.1.`).
+     */
+    private function renderTreeItems(ListNode $list, int $numId, int $depth): string
+    {
+        $xml = '';
+        foreach ($list->items as $item) {
+            if (! $item->markerHidden) {
+                $pPr = $this->renderParagraphProperties($item->style, null);
+                $numPr = '<w:numPr><w:ilvl w:val="'.min(8, $depth).'"/><w:numId w:val="'.$numId.'"/></w:numPr>';
+                $pPr = $pPr === ''
+                    ? '<w:pPr><w:pStyle w:val="ListParagraph"/>'.$numPr.'</w:pPr>'
+                    : (string) preg_replace('/^<w:pPr>/', '<w:pPr><w:pStyle w:val="ListParagraph"/>'.$numPr, $pPr, 1);
+                $children = '';
+                foreach ($item->children as $child) {
+                    $children .= $this->renderInline($child);
+                }
+                $xml .= '<w:p>'.$pPr.$children.'</w:p>';
+            }
+            if ($item->nestedList !== null) {
+                $xml .= $this->renderTreeItems($item->nestedList, $numId, $depth + 1);
+            }
+        }
+
+        return $xml;
+    }
+
     private function renderListItem(ListItem $item, int $numId, int $level): string
     {
         $level = max(0, min(NumberingXmlBuilder::MAX_LEVELS - 1, $level));
diff --git a/src/Writer/NumberingXmlBuilder.php b/src/Writer/NumberingXmlBuilder.php
index 42ecb46..c46845c 100644
--- a/src/Writer/NumberingXmlBuilder.php
+++ b/src/Writer/NumberingXmlBuilder.php
@@ -34,6 +34,14 @@ final class NumberingXmlBuilder
 
     private int $nextNumId = 3;
 
+    /**
+     * Numberings of their own, one per list tree that carries Word's level
+     * patterns: numId → its levels.
+     *
+     * @var array<int, array<int, array{format: ListFormat, startAt: int, levelText: string|null}>>
+     */
+    private array $treeInstances = [];
+
     private bool $used = false;
 
     public function isUsed(): bool
@@ -65,6 +73,23 @@ public function instanceFor(ListFormat $format, int $startAt = 1): int
         return $this->instanceMap[$key];
     }
 
+    /**
+     * Registers a numbering of its own for one list tree: every level with
+     * its format, start and label pattern (`%1.%2.`). Lists broken off and
+     * continued carry their numbers in the starts, so every tree is
+     * independent.
+     *
+     * @param  array<int, array{format: ListFormat, startAt: int, levelText: string|null}>  $levels
+     */
+    public function instanceForLevels(array $levels): int
+    {
+        $this->used = true;
+        $numId = $this->nextNumId++;
+        $this->treeInstances[$numId] = $levels;
+
+        return $numId;
+    }
+
     public function render(): string
     {
         $xml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>'
@@ -74,17 +99,24 @@ public function render(): string
         $xml .= $this->renderOrderedAbstractNum(1, ListFormat::Decimal, 1);
 
         // A custom abstract+concrete pair for every non-standard instance.
+        // The schema wants every abstractNum before the first num.
         $abstractIdCursor = 2;
+        $nums = '';
         foreach ($this->customInstances as $inst) {
             $key = $inst['format']->value.'_'.$inst['startAt'];
             $numId = $this->instanceMap[$key];
             $xml .= $this->renderOrderedAbstractNum($abstractIdCursor, $inst['format'], $inst['startAt']);
-            $xml .= '<w:num w:numId="'.$numId.'"><w:abstractNumId w:val="'.$abstractIdCursor.'"/></w:num>';
+            $nums .= '<w:num w:numId="'.$numId.'"><w:abstractNumId w:val="'.$abstractIdCursor.'"/></w:num>';
+            $abstractIdCursor++;
+        }
+
+        foreach ($this->treeInstances as $numId => $levels) {
+            $xml .= $this->renderTreeAbstractNum($abstractIdCursor, $levels);
+            $nums .= '<w:num w:numId="'.$numId.'"><w:abstractNumId w:val="'.$abstractIdCursor.'"/></w:num>';
             $abstractIdCursor++;
         }
 
-        // The standard concrete instances come after the custom ones — the
-        // order does not matter to Word or Pages.
+        $xml .= $nums;
         $xml .= '<w:num w:numId="'.self::BULLET_NUM_ID.'"><w:abstractNumId w:val="0"/></w:num>';
         $xml .= '<w:num w:numId="'.self::ORDERED_NUM_ID.'"><w:abstractNumId w:val="1"/></w:num>';
 
@@ -93,6 +125,31 @@ public function render(): string
         return $xml;
     }
 
+    /**
+     * @param  array<int, array{format: ListFormat, startAt: int, levelText: string|null}>  $levels
+     */
+    private function renderTreeAbstractNum(int $id, array $levels): string
+    {
+        $bullets = ['●', '○', '■'];
+        $deepest = $levels === [] ? 0 : max(array_keys($levels));
+        $xml = '<w:abstractNum w:abstractNumId="'.$id.'"><w:multiLevelType w:val="multilevel"/>';
+        for ($lvl = 0; $lvl <= min(8, $deepest); $lvl++) {
+            $level = $levels[$lvl] ?? ['format' => ListFormat::Decimal, 'startAt' => 1, 'levelText' => null];
+            $bullet = $level['format'] === ListFormat::Bullet;
+            $text = $bullet ? ($bullets[$lvl % 3]) : ($level['levelText'] ?? '%'.($lvl + 1).'.');
+            $xml .= '<w:lvl w:ilvl="'.$lvl.'">'
+                .'<w:start w:val="'.max(1, $level['startAt']).'"/>'
+                .'<w:numFmt w:val="'.$level['format']->value.'"/>'
+                .'<w:lvlText w:val="'.XmlEscape::attr($text).'"/>'
+                .'<w:lvlJc w:val="left"/>'
+                .'<w:pPr><w:ind w:left="'.(720 + $lvl * 360).'" w:hanging="360"/></w:pPr>'
+                .($bullet ? '<w:rPr><w:rFonts w:ascii="Symbol" w:hAnsi="Symbol" w:hint="default"/></w:rPr>' : '')
+                .'</w:lvl>';
+        }
+
+        return $xml.'</w:abstractNum>';
+    }
+
     private function renderBulletAbstractNum(int $id): string
     {
         $bullets = ['●', '○', '■'];
diff --git a/tests/Html/SerializerTest.php b/tests/Html/SerializerTest.php
index 24d680f..cdb7d09 100644
--- a/tests/Html/SerializerTest.php
+++ b/tests/Html/SerializerTest.php
@@ -216,7 +216,7 @@ public function full_roundtrip_html_writer_reader_serializer(): void
         self::assertStringContainsString('<h1', $imported->bodyHtml);
         self::assertStringContainsString('<strong>Bold</strong>', $imported->bodyHtml);
         self::assertStringContainsString('<em>italic</em>', $imported->bodyHtml);
-        self::assertStringContainsString('<ul>', $imported->bodyHtml);
+        self::assertStringContainsString('<ul', $imported->bodyHtml);
         self::assertStringContainsString('<table', $imported->bodyHtml);
         // Cell content; a semantic th/td can be lost without a <thead> wrapper in
         // the source HTML (a converter limitation, not a serializer one).
diff --git a/tests/Html/WordNumberingRoundTripTest.php b/tests/Html/WordNumberingRoundTripTest.php
new file mode 100644
index 0000000..8814653
--- /dev/null
+++ b/tests/Html/WordNumberingRoundTripTest.php
@@ -0,0 +1,79 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Dskripchenko\PhpDocx\Tests\Html;
+
+use Dskripchenko\PhpDocx\Html\Converter;
+use Dskripchenko\PhpDocx\Html\Serializer;
+use Dskripchenko\PhpDocx\Reader\DocxReader;
+use Dskripchenko\PhpDocx\Writer\Word2007Writer;
+use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Word's multilevel numbering through HTML and back: a list broken off by
+ * a paragraph numbers on (`3.`), the level below shows its parent's number
+ * (`3.1.`), a level with a literal prefix keeps it (`4.1.`).
+ */
+final class WordNumberingRoundTripTest extends TestCase
+{
+    private const HTML = '<style>.wl5-1::marker { content: counters(list-item, ".") ". " }'
+        .'.wl7-0::marker { content: "4." counter(list-item) ". " }</style>'
+        .'<ol><li>One<ol><li class="wl5-1">One-one</li></ol></li></ol>'
+        .'<p>Break</p>'
+        .'<ol start="3"><li style="list-style-type:none"><ol><li class="wl5-1">Three-one</li><li class="wl5-1">Three-two</li></ol></li></ol>'
+        .'<ol><li class="wl7-0">Four-one</li></ol>';
+
+    #[Test]
+    public function html_labels_become_word_numbering(): void
+    {
+        $doc = (new Converter)->fromHtml(self::HTML);
+        $docx = (new Word2007Writer)->write($doc);
+        $numbering = self::part($docx, 'word/numbering.xml');
+        $body = self::part($docx, 'word/document.xml');
+
+        self::assertStringContainsString('<w:lvlText w:val="%1.%2."/>', $numbering);
+        self::assertStringContainsString('<w:lvlText w:val="4.%1."/>', $numbering);
+        // The label-less parent writes no paragraph; its number is the start.
+        self::assertStringContainsString('<w:start w:val="3"/>', $numbering);
+        self::assertSame(5, substr_count($body, '<w:numPr>'));
+    }
+
+    #[Test]
+    public function word_numbering_survives_the_round_trip(): void
+    {
+        $docx = (new Word2007Writer)->write((new Converter)->fromHtml(self::HTML));
+        $imported = (new Serializer)->serialize((new DocxReader)->read($docx));
+
+        self::assertStringContainsString('counters(list-item, ".") ". "', $imported->css);
+        self::assertStringContainsString('"4." counter(list-item) ". "', $imported->css);
+        self::assertMatchesRegularExpression('/<ol style="margin:0;padding-left:0" start="3"><li style="list-style-type:none[^"]*"><ol /', $imported->bodyHtml);
+        // A level is placed by its numbering's indent, not by the nesting.
+        self::assertStringContainsString('<ol style="margin:0;padding-left:0">', $imported->bodyHtml);
+    }
+
+    #[Test]
+    public function marker_rules_pass_an_inliner(): void
+    {
+        self::assertSame(
+            '<style>.wl5-1::marker { content: counters(list-item, ".") ". " }'."\n"
+            .'.wl7-0::marker { content: "4." counter(list-item) ". " }'."\n".'</style>',
+            Converter::markerStyleOf(self::HTML),
+        );
+        self::assertSame('', Converter::markerStyleOf('<p>x</p>'));
+    }
+
+    private static function part(string $docx, string $name): string
+    {
+        $path = tempnam(sys_get_temp_dir(), 'docx');
+        file_put_contents($path, $docx);
+        $zip = new \ZipArchive;
+        $zip->open($path);
+        $xml = (string) $zip->getFromName($name);
+        $zip->close();
+        @unlink($path);
+
+        return $xml;
+    }
+}
diff --git a/tests/Reader/SectionHeadersTest.php b/tests/Reader/SectionHeadersTest.php
new file mode 100644
index 0000000..98e7f03
--- /dev/null
+++ b/tests/Reader/SectionHeadersTest.php
@@ -0,0 +1,97 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Dskripchenko\PhpDocx\Tests\Reader;
+
+use Dskripchenko\PhpDocx\Build\DocumentBuilder;
+use Dskripchenko\PhpDocx\Element\Paragraph;
+use Dskripchenko\PhpDocx\Reader\DocxReader;
+use Dskripchenko\PhpDocx\Writer\Word2007Writer;
+use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Which headers and footers a document shows, as Word decides it: the first
+ * section's parts govern the document's start, first-page parts need
+ * `<w:titlePg/>`, even-page ones `<w:evenAndOddHeaders/>`.
+ */
+final class SectionHeadersTest extends TestCase
+{
+    private static function docx(): string
+    {
+        return (new Word2007Writer)->write(DocumentBuilder::new()
+            ->footer(fn ($f) => $f->paragraph('Default footer'))
+            ->firstFooter(fn ($f) => $f->paragraph('First footer'))
+            ->paragraph('Body')
+            ->build());
+    }
+
+    /** @param  \Closure(string): string  $edit */
+    private static function editDocumentXml(string $docx, \Closure $edit): string
+    {
+        $path = tempnam(sys_get_temp_dir(), 'docx');
+        file_put_contents($path, $docx);
+        $zip = new \ZipArchive;
+        $zip->open($path);
+        $zip->addFromString('word/document.xml', $edit((string) $zip->getFromName('word/document.xml')));
+        $zip->close();
+        $bytes = (string) file_get_contents($path);
+        @unlink($path);
+
+        return $bytes;
+    }
+
+    /** @param  list<\Dskripchenko\PhpDocx\Element\BlockElement>  $blocks */
+    private static function text(array $blocks): string
+    {
+        $p = $blocks[0] ?? null;
+
+        return $p instanceof Paragraph ? implode('', array_map(static fn ($r) => $r->text ?? '', $p->children)) : '';
+    }
+
+    #[Test]
+    public function first_page_parts_need_title_pg(): void
+    {
+        $with = (new DocxReader)->read(self::docx());
+        self::assertSame('First footer', self::text($with->section->firstFooter));
+
+        $without = (new DocxReader)->read(self::editDocumentXml(self::docx(), static fn (string $xml): string => str_replace('<w:titlePg/>', '', $xml)));
+        self::assertSame([], $without->section->firstFooter);
+        self::assertSame('Default footer', self::text($without->section->footer));
+    }
+
+    #[Test]
+    public function the_first_sections_parts_win_over_later_sections(): void
+    {
+        // A section break before the body's own section: the first section
+        // shows the first-page footer part as its default footer, without
+        // titlePg.
+        $bytes = self::editDocumentXml(self::docx(), static function (string $xml): string {
+            preg_match('/<w:footerReference w:type="first" r:id="(\w+)"\/>/', $xml, $m);
+
+            return (string) preg_replace(
+                '/<w:p>/',
+                '<w:p><w:pPr><w:sectPr><w:footerReference w:type="default" r:id="'.$m[1].'"/></w:sectPr></w:pPr>',
+                $xml,
+                1,
+            );
+        });
+
+        $doc = (new DocxReader)->read($bytes);
+        self::assertSame('First footer', self::text($doc->section->footer));
+        self::assertSame([], $doc->section->firstFooter);
+    }
+
+    #[Test]
+    public function even_parts_need_even_and_odd_headers(): void
+    {
+        $bytes = (new Word2007Writer)->write(DocumentBuilder::new()
+            ->footer(fn ($f) => $f->paragraph('Odd'))
+            ->evenFooter(fn ($f) => $f->paragraph('Even'))
+            ->paragraph('Body')
+            ->build());
+
+        self::assertSame('Even', self::text((new DocxReader)->read($bytes)->section->evenFooter));
+    }
+}