diff --git a/src/Filee.Engines/Hwp/Hwpx/Docx/DocxReader.Drawing.cs b/src/Filee.Engines/Hwp/Hwpx/Docx/DocxReader.Drawing.cs
index 6ceb124af..9e7b4e4f8 100644
--- a/src/Filee.Engines/Hwp/Hwpx/Docx/DocxReader.Drawing.cs
+++ b/src/Filee.Engines/Hwp/Hwpx/Docx/DocxReader.Drawing.cs
@@ -573,6 +573,9 @@ private IEnumerable<HInline> Vml(XElement container, HCharFormat format)
                 continue;
 
             var style = VmlStyle((string?)shape.Attribute("style"));
+            // Word doesn't draw a hidden shape (a stamp's text kept for later, a template's spare WordArt).
+            if (style.GetValueOrDefault("visibility") == "hidden")
+                continue;
             var width = HwpxUnits.ParseLength(style.GetValueOrDefault("width")) ?? 0;
             var height = HwpxUnits.ParseLength(style.GetValueOrDefault("height")) ?? 0;
             var anchor = style.GetValueOrDefault("position") == "absolute" ? VmlAnchor(shape, style) : null;
diff --git a/src/Filee.Engines/Hwp/Hwpx/Docx/DocxReader.Styles.cs b/src/Filee.Engines/Hwp/Hwpx/Docx/DocxReader.Styles.cs
index 39c9201ea..72266c0bc 100644
--- a/src/Filee.Engines/Hwp/Hwpx/Docx/DocxReader.Styles.cs
+++ b/src/Filee.Engines/Hwp/Hwpx/Docx/DocxReader.Styles.cs
@@ -305,6 +305,23 @@ private sealed class NumberingLevel
     private (string? Latin, string? EastAsian) _minorFont, _majorFont;
     private string? _minorComplexFont, _majorComplexFont;
 
+    /// <summary>
+    /// Word draws text whose styles and document defaults name no font in Times New Roman (Latin and complex script
+    /// characters); East Asian text keeps the font of its language.
+    /// </summary>
+    private void DefaultFonts()
+    {
+        var run = _defaultRun;
+        if (run.Ascii is not null || run.AsciiTheme is not null || run.AsciiOnly is not null || run.AsciiOnlyTheme is not null
+            || run.HighAnsi is not null || run.HighAnsiTheme is not null)
+            return;
+        run.Ascii = run.AsciiOnly = run.HighAnsi = WordDefaultFont;
+        if (run.ComplexScript is null && run.ComplexScriptTheme is null)
+            run.ComplexScript = WordDefaultFont;
+    }
+
+    private const string WordDefaultFont = "Times New Roman";
+
     private void LoadStyles(Part? part)
     {
         var root = part?.Xml.Root;
@@ -492,7 +509,10 @@ static void ApplyLevel(NumberingLevel[] levels, XElement lvl)
     private RunProps RunProperties(XElement? rPr, RunProps paragraphRun)
     {
         var run = paragraphRun.Clone();
-        if (Val(rPr?.Element(W + "rStyle")) is { } characterStyle && _styles.TryGetValue(characterStyle, out var style))
+        // Word and LibreOffice draw the entries of a table of contents in the TOC styles' look, though Word gives each
+        // entry's link the Hyperlink character style (blue, underlined).
+        if (Val(rPr?.Element(W + "rStyle")) is { } characterStyle && _styles.TryGetValue(characterStyle, out var style)
+            && !(InTableOfContents && (style.Id == "Hyperlink" || string.Equals(style.Name, "Hyperlink", StringComparison.OrdinalIgnoreCase))))
         {
             // Character styles only carry run properties; apply their chain on top of the paragraph's.
             var chain = new List<Style>();
diff --git a/src/Filee.Engines/Hwp/Hwpx/Docx/DocxReader.cs b/src/Filee.Engines/Hwp/Hwpx/Docx/DocxReader.cs
index 2561f2deb..8a085a48e 100644
--- a/src/Filee.Engines/Hwp/Hwpx/Docx/DocxReader.cs
+++ b/src/Filee.Engines/Hwp/Hwpx/Docx/DocxReader.cs
@@ -61,6 +61,12 @@ internal sealed partial class DocxReader
     /// <summary>Reading the header for the first page only, which becomes a text box (see <see cref="HSection.FirstPageHeader"/>).</summary>
     private bool _inFirstPageHeader;
 
+    /// <summary>
+    /// The block list whose next block starts a new page: a paragraph ended right after its page break, and Word keeps
+    /// such a paragraph's mark on the old page.
+    /// </summary>
+    private List<HBlock>? _pageBreakFor;
+
     /// <summary>Table cells, text boxes and notes around the blocks being read (see <see cref="ReadNestedBlocks"/>).</summary>
     private int _depth;
 
@@ -205,6 +211,7 @@ private HDocument ReadDocument()
     {
         var main = _part;
         LoadStyles(RelatedPart(main, "/styles"));
+        DefaultFonts();
         var theme = RelatedPart(main, "/theme");
         LoadTheme(theme);
         LoadThemeColors(theme);
@@ -647,7 +654,11 @@ private void ReadNestedBlocks(XElement container, List<HBlock> output)
 
     private void ReadBlock(XElement element, List<HBlock> output)
     {
-        if (element.Name == W + "p")
+        var count = output.Count;
+        var pageBreak = ReferenceEquals(_pageBreakFor, output);
+        if (element.Name == W + "p" && PageFrame(element) is { } frame)
+            ReadFramed(element, frame, output);
+        else if (element.Name == W + "p")
             ReadParagraph(element, output);
         else if (element.Name == W + "tbl")
         {
@@ -655,8 +666,114 @@ private void ReadBlock(XElement element, List<HBlock> output)
             output.Add(ReadTable(element));
             _tableDepth--;
         }
+        if (pageBreak && output.Count > count)
+        {
+            if (ReferenceEquals(_pageBreakFor, output))
+                _pageBreakFor = null;
+            switch (output[count])
+            {
+                case HParagraph paragraph:
+                    paragraph.PageBreakBefore = true;
+                    break;
+                case HTable table:
+                    table.PageBreakBefore = true;
+                    break;
+            }
+        }
+    }
+
+    // ───────────────────────── Frames ─────────────────────────
+
+    /// <summary>The frame paragraphs are being read into, while the next paragraph with the same w:framePr joins it.</summary>
+    private (XElement Properties, HTextBox Box, List<HBlock> Output, int Count)? _frame;
+
+    /// <summary>
+    /// The w:framePr of a paragraph Word sets in a frame of a given size at a place on the page or within the margins
+    /// (a verification code at the bottom of a form); null for other paragraphs, drop caps and frames that move with
+    /// the text, which stay in the text.
+    /// </summary>
+    private static XElement? PageFrame(XElement paragraph)
+    {
+        var frame = paragraph.Element(W + "pPr")?.Element(W + "framePr");
+        if (frame is null || Attr(frame, "dropCap") is "drop" or "margin" || Attr(frame, "vAnchor") is not ("page" or "margin")
+            || Twips(frame, "w") is not > 0 || Twips(frame, "h") is not (> 0 or < 0))
+            return null;
+        return frame;
     }
 
+    /// <summary>
+    /// A paragraph in a frame: a box without border or padding at the frame's place, floating at the paragraph before
+    /// it (the frame takes no room in the text). Consecutive paragraphs with the same frame share the box.
+    /// </summary>
+    private void ReadFramed(XElement paragraph, XElement properties, List<HBlock> output)
+    {
+        HTextBox box;
+        if (_frame is { } open && ReferenceEquals(open.Output, output) && open.Count == output.Count && XNode.DeepEquals(open.Properties, properties))
+        {
+            box = open.Box;
+        }
+        else
+        {
+            var height = Math.Abs(Twips(properties, "h") ?? 0);
+            box = new TextBoxBuilder(HwpxUnits.FromTwips(Twips(properties, "w") ?? 0), HwpxUnits.FromTwips(height), FrameAnchor(properties))
+            {
+                Line = HBorder.None,
+                Padding = new HInsets(0, 0, 0, 0),
+            }.Build();
+            if (output.LastOrDefault() is HParagraph host)
+            {
+                host.Inlines.Add(box);
+            }
+            else
+            {
+                var empty = new HParagraph();
+                empty.Inlines.Add(box);
+                output.Add(empty);
+            }
+        }
+        _textBoxDepth++;
+        try
+        {
+            ReadParagraph(paragraph, box.Blocks);
+        }
+        finally
+        {
+            _textBoxDepth--;
+        }
+        _frame = (properties, box, output, output.Count);
+    }
+
+    /// <summary>Where w:framePr puts its frame: x/xAlign from the page, margin or column, y/yAlign from the page or margin.</summary>
+    private static HAnchor FrameAnchor(XElement frame) => new(
+        HorizontalRelativeTo: Attr(frame, "hAnchor") switch
+        {
+            "page" => "PAPER",
+            "margin" => "PAGE",
+            _ => "COLUMN",
+        },
+        HorizontalAlign: Attr(frame, "xAlign") switch
+        {
+            "center" => "CENTER",
+            "right" or "outside" => "RIGHT",
+            _ => "LEFT",
+        },
+        HorizontalOffset: Attr(frame, "xAlign") is null ? HwpxUnits.FromTwips(Twips(frame, "x") ?? 0) : 0,
+        VerticalRelativeTo: Attr(frame, "vAnchor") == "page" ? "PAPER" : "PAGE",
+        VerticalAlign: Attr(frame, "yAlign") switch
+        {
+            "center" => "CENTER",
+            "bottom" or "outside" => "BOTTOM",
+            _ => "TOP",
+        },
+        VerticalOffset: Attr(frame, "yAlign") is null ? HwpxUnits.FromTwips(Twips(frame, "y") ?? 0) : 0,
+        Wrap: Attr(frame, "wrap") switch
+        {
+            "through" => "IN_FRONT_OF_TEXT",
+            "none" or "notBeside" => "TOP_AND_BOTTOM",
+            _ => "SQUARE",
+        },
+        AllowOverlap: true);
+
     // ───────────────────────── Paragraphs ─────────────────────────
 
     /// <summary>
@@ -672,6 +789,7 @@ private sealed class ParagraphBuilder
         private readonly int _heading;
         private readonly HListRef? _list;
         private readonly ParaProps _props;
+        private bool _pageBroken;
         private readonly Stack<List<HInline>> _sinks = new();
 
         public ParagraphBuilder(DocxReader reader, List<HBlock> output, ParaProps props, RunProps mark, XElement? pPr)
@@ -727,7 +845,7 @@ public void Break(bool page)
                 _sinks.Clear();
             }
             if (page)
-                Current.PageBreakBefore = true;
+                Current.PageBreakBefore = _pageBroken = true;
             else
                 Current.ColumnBreakBefore = true;
         }
@@ -743,7 +861,18 @@ public void NextRow()
             _sinks.Clear();
         }
 
-        public void Finish() => Emit();
+        /// <param name="endsSection">The paragraph holds a section's properties (its section ends here).</param>
+        public void Finish(bool endsSection = false)
+        {
+            // Word keeps the mark of a paragraph that ends right after a page break on the old page: the new page starts
+            // with the next paragraph, not with an empty line and the paragraph's space after.
+            if (_pageBroken && Current.Inlines.Count == 0 && Current.List is not { Numbered: true } && !endsSection)
+            {
+                _reader._pageBreakFor = _output;
+                return;
+            }
+            Emit();
+        }
 
         private void Emit()
         {
@@ -771,7 +900,7 @@ private void ReadParagraph(XElement p, List<HBlock> output)
         // Run formatting starts from the paragraph style, not from the paragraph mark's direct formatting.
         var styleRun = ParagraphStyle(Val(pPr?.Element(W + "pStyle")) ?? _defaultParagraphStyle).Run;
         ParagraphContent(p.Elements(), builder, styleRun);
-        builder.Finish();
+        builder.Finish(endsSection: pPr?.Element(W + "sectPr") is not null);
     }
 
     private void ParagraphContent(IEnumerable<XElement> elements, ParagraphBuilder builder, RunProps styleRun)
@@ -885,6 +1014,10 @@ private void RunChild(XElement child, ParagraphBuilder builder, HCharFormat form
                     foreach (var text in SymbolFonts.Runs(child.Value, format))
                         builder.Add(text);
                 }
+                else if (StoredResult() is { } stored && stored.Stored!.Length < 32)
+                {
+                    stored.Stored += child.Value;
+                }
                 break;
             case "tab" or "ptab":
                 if (ShowsText())
@@ -1123,11 +1256,26 @@ private sealed class FieldState
         public bool Result;
         public bool Suppress;
         public string? Target;
+
+        /// <summary>The page number field whose result text is kept as <see cref="HField.Stored"/>.</summary>
+        public HField? Stored;
+
+        /// <summary>A table of contents (TOC): its entries don't take the Hyperlink character style's look.</summary>
+        public bool TableOfContents;
     }
 
+    /// <summary>Text is in the entries of a table of contents.</summary>
+    private bool InTableOfContents => _fields.Any(f => f.Result && f.TableOfContents);
+
     /// <summary>Field result text is shown unless we are inside an instruction or a field we replace (PAGE ...).</summary>
     private bool ShowsText() => _fields.All(f => f.Result && !f.Suppress);
 
+    /// <summary>The page number whose result text is being read, when only that field hides it.</summary>
+    private HField? StoredResult() =>
+        _fields.Count > 0 && _fields[^1] is { Result: true, Stored: { } stored } && _fields.Take(_fields.Count - 1).All(f => f.Result && !f.Suppress)
+            ? stored
+            : null;
+
     private void FieldChar(XElement fldChar, ParagraphBuilder builder, HCharFormat format)
     {
         switch (Attr(fldChar, "fldCharType"))
@@ -1165,7 +1313,17 @@ private void StartFieldResult(FieldState field, ParagraphBuilder builder, HCharF
         switch (words.FirstOrDefault()?.ToUpperInvariant())
         {
             case "PAGE" or "NUMPAGES" or "SECTIONPAGES" when _inFirstPageHeader && _tableDepth > 0:
-                // rhwp leaves a page number in a table in a text box blank: Word's result, which comes next, stays.
+                {
+                    // rhwp leaves a page number in a table in a text box blank: the HWPX writer writes Word's result,
+                    // which comes next, as text. The layout engine counts the pages, as for any other page number.
+                    var number = new HField(words[0].Equals("PAGE", StringComparison.OrdinalIgnoreCase) ? HFieldKind.PageNumber : HFieldKind.TotalPages, format) { Stored = "" };
+                    builder.Add(number);
+                    field.Stored = number;
+                    field.Suppress = true;
+                    break;
+                }
+            case "TOC":
+                field.TableOfContents = true;
                 break;
             case "HYPERLINK":
                 {
diff --git a/src/Filee.Engines/Hwp/Hwpx/HwpxModel.cs b/src/Filee.Engines/Hwp/Hwpx/HwpxModel.cs
index 0ffcef3f9..35b7e2e54 100644
--- a/src/Filee.Engines/Hwp/Hwpx/HwpxModel.cs
+++ b/src/Filee.Engines/Hwp/Hwpx/HwpxModel.cs
@@ -577,6 +577,12 @@ internal sealed class HField(HFieldKind kind, HCharFormat format) : HInline
 
     /// <summary>The number's OWPML format (DIGIT, LATIN_CAPITAL, ROMAN_SMALL, ...); null for digits. Read for layout only.</summary>
     public string? NumberFormat { get; init; }
+
+    /// <summary>
+    /// The number Word last saved for the field, which the HWPX writer writes as text instead of the field (rhwp leaves
+    /// a page number in a table in a text box blank); null when it writes the field. The layout engine always counts.
+    /// </summary>
+    public string? Stored { get; set; }
 }
 
 /// <summary>
diff --git a/src/Filee.Engines/Hwp/Hwpx/HwpxWriter.Body.cs b/src/Filee.Engines/Hwp/Hwpx/HwpxWriter.Body.cs
index dd79f53e1..9dfbe936e 100644
--- a/src/Filee.Engines/Hwp/Hwpx/HwpxWriter.Body.cs
+++ b/src/Filee.Engines/Hwp/Hwpx/HwpxWriter.Body.cs
@@ -286,6 +286,10 @@ private void Inlines(IEnumerable<HInline> inlines, RunBuilder runs, string charP
                 case HBookmark bookmark:
                     runs.Control(charPrBase, $"<hp:ctrl><hp:bookmark name=\"{Escape(bookmark.Name)}\"/></hp:ctrl>");
                     break;
+                case HField { Stored: { } stored } field:
+                    if (stored.Length > 0)
+                        runs.Text(CharPr(charPrBase, field.Format, link), Escape(stored));
+                    break;
                 case HField field:
                     runs.Control(CharPr(charPrBase, field.Format), AutoNumber(field.Kind == HFieldKind.PageNumber ? "PAGE" : "TOTAL_PAGE", 1, ""));
                     break;
diff --git a/tests/Filee.Engines.Tests/ReportedCasesTests.cs b/tests/Filee.Engines.Tests/ReportedCasesTests.cs
index 8ed61fa64..5955e99f8 100644
--- a/tests/Filee.Engines.Tests/ReportedCasesTests.cs
+++ b/tests/Filee.Engines.Tests/ReportedCasesTests.cs
@@ -15,6 +15,7 @@
 using Filee.Core.Presets;
 using Filee.Engines.Documents;
 using Filee.Engines.Hwp.Hwpx;
+using Filee.Engines.Hwp.Hwpx.Docx;
 using Filee.Engines.Office;
 using Filee.Engines.Office.Sheets;
 using Filee.Engines.Rendering;
@@ -147,6 +148,55 @@ public async Task Issue1152_a_first_page_header_with_content_shows_on_page_one()
         Assert.Contains("Runningheader", Text(pages[1]));
     }
 
+    [Fact]
+    public async Task Issue1152_page_x_of_y_in_a_first_page_header_table_counts_every_page()
+    {
+        // The Doc Ref table of a first-page header: "Page 1 of 2" where Word last saved two pages, in a three-page
+        // document. The HWPX writer keeps Word's text there (rhwp leaves such a number blank); the renderer counts.
+        var docx = Docx(P(R("first")) + PageBreak + P(R("second")) + PageBreak + P(R("third")));
+        var cell = P(R("Page ") + Field("PAGE", "1") + R(" of ") + Field("NUMPAGES", "2"));
+        var first = docx.Header("<w:tbl><w:tblPr><w:tblW w:w=\"4000\" w:type=\"dxa\"/></w:tblPr><w:tblGrid><w:gridCol w:w=\"4000\"/></w:tblGrid>" +
+            $"<w:tr><w:tc><w:tcPr><w:tcW w:w=\"4000\" w:type=\"dxa\"/></w:tcPr>{cell}</w:tc></w:tr></w:tbl>" + P(""));
+        docx.SectionProperties = $"<w:headerReference w:type=\"first\" r:id=\"{first}\"/>{DefaultPage}<w:titlePg/>";
+        var path = docx.Save(Path.Combine(fx.NewFolder(), "case.docx"));
+
+        var pages = await ComposeAsync(path, "docx");
+
+        Assert.Equal(3, pages.Count);
+        Assert.Contains("Page1of3", Text(pages[0]));
+        var document = DocxReader.Read(path, fx.NewFolder());
+        var header = Assert.IsType<List<HBlock>>(Assert.Single(document.Sections).FirstPageHeader);
+        var fields = Assert.IsType<HTable>(header[0]).Rows[0].Cells[0].Blocks.OfType<HParagraph>().SelectMany(p => p.Inlines).OfType<HField>().ToList();
+        Assert.Equal(["1", "2"], fields.Select(f => f.Stored));
+        var hwpx = Path.Combine(fx.NewFolder(), "case.hwpx");
+        HwpxWriter.Write(document, hwpx);
+        using var zip = ZipFile.OpenRead(hwpx);
+        using var section = new StreamReader(zip.GetEntry("Contents/section0.xml")!.Open());
+        Assert.Contains("Page 1 of 2", await section.ReadToEndAsync(Token), StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task Issue1152_table_of_contents_entries_are_not_drawn_as_blue_links()
+    {
+        // Word writes each entry of a table of contents as a link in the Hyperlink character style (blue, underlined),
+        // yet draws it in the TOC style's black, as LibreOffice does; a link in the text stays blue.
+        const string Hyperlink = "<w:style w:type=\"character\" w:styleId=\"Hyperlink\"><w:name w:val=\"Hyperlink\"/><w:rPr><w:color w:val=\"0000FF\"/><w:u w:val=\"single\"/></w:rPr></w:style>";
+        static string Entry(string text, string anchor) =>
+            $"<w:hyperlink w:anchor=\"{anchor}\" w:history=\"1\">{R(text, "<w:rStyle w:val=\"Hyperlink\"/><w:noProof/>")}</w:hyperlink>";
+        var toc = P("<w:r><w:fldChar w:fldCharType=\"begin\"/></w:r><w:r><w:instrText xml:space=\"preserve\"> TOC \\o \"1-3\" \\h \\z \\u </w:instrText></w:r>" +
+                    "<w:r><w:fldChar w:fldCharType=\"separate\"/></w:r>" + Entry("Introduction", "_Toc1")) +
+                  P(Entry("Results", "_Toc2") + "<w:r><w:fldChar w:fldCharType=\"end\"/></w:r>");
+        var docx = Docx(toc + P(Entry("Elsewhere", "_Toc1")));
+        docx.Styles = NotoStyles + Hyperlink;
+
+        var page = Single(await DocxAsync(docx));
+
+        SKColor ColorOf(string word) => Glyphs(page).First(g => g.Char == word[0] && Lines(page).Any(l => l.Text == word && MathF.Round(g.Y, 1) == l.Y)).Run.Color;
+        Assert.Equal(SKColors.Black, ColorOf("Introduction"));
+        Assert.Equal(SKColors.Black, ColorOf("Results"));
+        Assert.Equal(new SKColor(0, 0, 0xFF), ColorOf("Elsewhere"));
+    }
+
     [Fact]
     public async Task Issue1152_a_header_taller_than_the_top_margin_moves_the_body_down()
     {
@@ -411,6 +461,30 @@ public void Issue356_a_word_document_with_an_ole_object_keeps_its_fallback_route
         Assert.Null(renderer.FirstUnsupported(plain, "docx"));
     }
 
+    [Fact]
+    public void Issue1180_text_in_a_document_that_names_no_font_is_in_times_new_roman()
+    {
+        // A worksheet whose styles and defaults name no font at all: Word draws it in Times New Roman, the renderer
+        // drew it in its own sans serif, wider, and the pages ran over. A theme or named font still wins.
+        const string Bare = """
+            <w:docDefaults><w:rPrDefault><w:rPr><w:sz w:val="22"/></w:rPr></w:rPrDefault></w:docDefaults>
+            <w:style w:type="paragraph" w:default="1" w:styleId="Normal"><w:name w:val="normal"/></w:style>
+            """;
+        var docx = new DocxBuilder { Styles = Bare }.Paragraph(P(R("Student Name")) + P(R("UID", "<w:rFonts w:ascii=\"Arial\" w:hAnsi=\"Arial\"/>")));
+        var themed = new DocxBuilder { Styles = Bare.Replace("<w:sz ", "<w:rFonts w:asciiTheme=\"minorHAnsi\" w:hAnsiTheme=\"minorHAnsi\"/><w:sz ", StringComparison.Ordinal) }.Paragraph(P(R("Body")));
+
+        var plain = DocxReader.Read(docx.Save(Path.Combine(fx.NewFolder(), "bare.docx")), fx.NewFolder());
+        var theme = DocxReader.Read(themed.Save(Path.Combine(fx.NewFolder(), "themed.docx")), fx.NewFolder());
+
+        var texts = Assert.Single(plain.Sections).Blocks.OfType<HParagraph>().Select(p => p.Inlines.OfType<HText>().Single()).ToList();
+        Assert.Equal("Times New Roman", texts[0].Format.Font);
+        Assert.Equal("Times New Roman", texts[0].Format.Layout?.WordFonts?.Ascii);
+        Assert.Equal("Times New Roman", texts[0].Format.Layout?.WordFonts?.ComplexScript);
+        Assert.Equal("Arial", texts[1].Format.Font);
+        var body = Assert.Single(theme.Sections).Blocks.OfType<HParagraph>().Single().Inlines.OfType<HText>().Single();
+        Assert.NotEqual("Times New Roman", body.Format.Font);
+    }
+
     // ───────────────────────── Word: fixes that came with the main merge (#1194, #355, #1237) ─────────────────────────
 
     [Fact]
@@ -429,6 +503,31 @@ static string Styles(string contextual) => NotoStyles +
         Assert.Equal(single + 10, Pitch(loose), 0.1f);
     }
 
+    [Fact]
+    public async Task Issue1194_a_page_break_at_the_end_of_a_paragraph_leaves_no_empty_line_on_the_next_page()
+    {
+        // Each chapter of the report starts after a paragraph holding only a page break. Word keeps that paragraph's
+        // mark on the old page; the renderer put it on the new one, an empty line and 10 pt above every chapter.
+        var styles = NotoStyles.Replace("<w:spacing w:after=\"0\" w:line=\"240\" w:lineRule=\"auto\"/></w:pPr></w:pPrDefault>",
+            "<w:spacing w:after=\"200\" w:line=\"276\" w:lineRule=\"auto\"/></w:pPr></w:pPrDefault>", StringComparison.Ordinal);
+        Assert.NotEqual(NotoStyles, styles);
+        const string Break = "<w:r><w:br w:type=\"page\"/></w:r>";
+        var own = new DocxBuilder { Styles = styles, SectionProperties = DefaultPage }.Paragraph(P(R("Chapter 1")) + P(Break) + P(R("Chapter 2")));
+        var ending = new DocxBuilder { Styles = styles, SectionProperties = DefaultPage }.Paragraph(P(R("Chapter 1") + Break) + P(R("Chapter 2")));
+        var property = new DocxBuilder { Styles = styles, SectionProperties = DefaultPage }.Paragraph(P(R("Chapter 1")) + P(R("Chapter 2"), "<w:pageBreakBefore/>"));
+        var middle = new DocxBuilder { Styles = styles, SectionProperties = DefaultPage }.Paragraph(P(R("Chapter 1") + Break + R("Chapter 2")));
+
+        var expected = Lines((await DocxAsync(property))[1]).Single().Y;
+        foreach (var docx in new[] { own, ending, middle })
+        {
+            var pages = await DocxAsync(docx);
+            Assert.Equal(2, pages.Count);
+            var line = Assert.Single(Lines(pages[1]));
+            Assert.Equal("Chapter2", line.Text);
+            Assert.Equal(expected, line.Y, 0.1f);
+        }
+    }
+
     [Fact]
     public async Task Issue355_an_equation_number_after_a_hash_sits_at_the_right_margin()
     {
@@ -463,6 +562,32 @@ await File.WriteAllTextAsync(path,
         Assert.Equal(SKColors.Black, Runs(page).First(r => r.Text.Contains("Plain", StringComparison.Ordinal)).Color);
     }
 
+    [Fact]
+    public async Task Issue1313_a_frame_sits_where_its_page_position_puts_it()
+    {
+        // The form's verification code: a paragraph in a frame (w:framePr) 492 pt from the left and 720 pt from the top
+        // of the page, 84 × 98 pt, centred. It came out under the signature in the text, in the middle of the page.
+        var frame = "<w:framePr w:w=\"1680\" w:h=\"1961\" w:hRule=\"exact\" w:wrap=\"none\" w:vAnchor=\"page\" w:hAnchor=\"page\" w:x=\"9840\" w:y=\"14400\" w:anchorLock=\"1\"/><w:jc w:val=\"center\"/>";
+        var docx = Docx(P(R("Signature")) + P(R("Code"), frame) + P(R("Check"), frame) + P(R("After")));
+
+        var page = Single(await DocxAsync(docx));
+
+        var lines = Lines(page);
+        var signature = lines.Single(l => l.Text == "Signature");
+        var after = lines.Single(l => l.Text == "After");
+        Assert.Equal(LineHeight(RepositoryFonts.Latin, 10), after.Y - signature.Y, 0.5f);
+        var codeLine = lines.Single(l => l.Text == "Code");
+        var code = Glyphs(page).Where(g => g.Text.Length > 0 && MathF.Round(g.Y, 1) == codeLine.Y).ToList();
+        Assert.Equal(4, code.Count);
+        Assert.InRange(codeLine.Y, 720, 720 + 98);
+        Assert.InRange(code.Min(g => g.X), 492, 492 + 84);
+        Assert.InRange(code.Max(g => g.X), 492, 492 + 84);
+        // Centred in the frame, the two paragraphs one under the other.
+        Assert.InRange((code.Min(g => g.X) + code.Max(g => g.X)) / 2, 492 + 42 - 12, 492 + 42 + 12);
+        var check = lines.Single(l => l.Text == "Check");
+        Assert.True(check.Y > code[0].Y && check.Y < 720 + 98, $"second line at {check.Y}");
+    }
+
     // ───────────────────────── Word: right-to-left documents (#202, #216, #620) ─────────────────────────
 
     [Fact]
diff --git a/tests/Filee.Engines.Tests/WordWatermarkTests.cs b/tests/Filee.Engines.Tests/WordWatermarkTests.cs
index c3c07cc2a..8d0c1b07e 100644
--- a/tests/Filee.Engines.Tests/WordWatermarkTests.cs
+++ b/tests/Filee.Engines.Tests/WordWatermarkTests.cs
@@ -77,6 +77,24 @@ public void A_vml_watermark_is_wordart_turned_half_see_through_and_centred_behin
         Assert.True(text.Format.Size > 5000, $"size {text.Format.Size}");
     }
 
+    [Fact]
+    public void A_hidden_wordart_shape_is_left_out()
+    {
+        // A form kept a spare copy of its WordArt as a hidden 50 pt shape at the top left (visibility:hidden), next to
+        // the one it shows; Word draws only the visible one (#1313).
+        string Shape(string id, string visibility) =>
+            $"<v:shape id=\"{id}\" style=\"position:absolute;margin-left:0;margin-top:0;width:50pt;height:50pt;z-index:251658240;visibility:{visibility}\" " +
+            "coordsize=\"21600,21600\" o:spt=\"100\" path=\"m,l,m,21600r,m21600,10800l,10800e\"><v:path textpathok=\"t\"/>" +
+            $"<v:textpath on=\"t\" fitshape=\"t\" style=\"font-family:&quot;Calibri&quot;;font-size:1in\" string=\"{id}\"/></v:shape>";
+        var body = $"<w:p><w:r><w:pict {Office}>{Shape("Spare", "hidden")}{Shape("Shown", "visible")}</w:pict></w:r></w:p>";
+
+        var document = Read(new DocxBuilder().Paragraph(body));
+
+        var boxes = document.Sections[0].Blocks.OfType<HParagraph>().SelectMany(p => p.Inlines).OfType<HTextBox>().ToList();
+        var text = Assert.IsType<HText>(Assert.Single(Assert.IsType<HParagraph>(Assert.Single(Assert.Single(boxes).Blocks)).Inlines));
+        Assert.Equal("Shown", text.Text);
+    }
+
     [Fact]
     public void A_picture_watermark_keeps_its_washout()
     {