diff --git a/.github/workflows/Format.yml b/.github/workflows/Format.yml
index 7be9c907..25457d72 100644
--- a/.github/workflows/Format.yml
+++ b/.github/workflows/Format.yml
@@ -13,5 +13,14 @@ jobs:
     - uses: actions/checkout@v7
       with:
         submodules: recursive
+    - name: Remove Uno.Example from solution
+      # CSharpMath.Uno.Example must be removed rather than excluded: dotnet format's
+      # --exclude only skips formatting analysis, but the project is still restored
+      # and its Uno.Resizetizer splash-screen task crashes inside dotnet format due
+      # to a SkiaSharp assembly-version conflict (the tool hosts SkiaSharp 2.88
+      # while Uno.Resizetizer requires 3.x / native libSkiaSharp 116.0).
+      shell: bash
+      run:
+        dotnet sln CSharpMath.slnx remove CSharpMath.Uno.Example/CSharpMath.Uno.Example.csproj
     - name: Check formatting (Fix with "dotnet format --exclude Typography" at repository root)
       run: dotnet format --exclude Typography --verify-no-changes --verbosity diagnostic
\ No newline at end of file
diff --git a/CSharpMath.Core.Example/BackEnd/JsonMathTable.cs b/CSharpMath.Core.Example/BackEnd/JsonMathTable.cs
index 542cacff..e74ed94f 100644
--- a/CSharpMath.Core.Example/BackEnd/JsonMathTable.cs
+++ b/CSharpMath.Core.Example/BackEnd/JsonMathTable.cs
@@ -205,6 +205,14 @@ public override float LowerLimitGapMin(TFont font) =>
 
     public override float LowerLimitBaselineDropMin(TFont font) =>
       ConstantFromTable(font, nameof(LowerLimitBaselineDropMin));
+    public override float StretchStackTopShiftUp(TFont font) =>
+      ConstantFromTable(font, nameof(StretchStackTopShiftUp));
+    public override float StretchStackBottomShiftDown(TFont font) =>
+      ConstantFromTable(font, nameof(StretchStackBottomShiftDown));
+    public override float StretchStackGapAboveMin(TFont font) =>
+      ConstantFromTable(font, nameof(StretchStackGapAboveMin));
+    public override float StretchStackGapBelowMin(TFont font) =>
+      ConstantFromTable(font, nameof(StretchStackGapBelowMin));
     #region overline/underline
     public override float UnderbarVerticalGap(TFont font) =>
       ConstantFromTable(font, nameof(UnderbarVerticalGap));
diff --git a/CSharpMath.Core.Tests/Atom/IosMath2026PortTests.cs b/CSharpMath.Core.Tests/Atom/IosMath2026PortTests.cs
new file mode 100644
index 00000000..41bce160
--- /dev/null
+++ b/CSharpMath.Core.Tests/Atom/IosMath2026PortTests.cs
@@ -0,0 +1,655 @@
+using System;
+using System.Linq;
+using CSharpMath.Atom;
+using CSharpMath.Atom.Atoms;
+using Xunit;
+
+namespace CSharpMath.Core.AtomTests {
+  // Tests for the features ported from iosMath's 2026 commits.
+  public class IosMath2026PortTests {
+    static MathList ParseLaTeX(string latex) {
+      var builder = new LaTeXParser(latex);
+      var (mathList, error) = builder.Build();
+      Assert.Null(error);
+      Assert.NotNull(mathList);
+      return mathList;
+    }
+    static string RoundTrip(string latex) => LaTeXParser.MathListToLaTeX(ParseLaTeX(latex)).ToString();
+    static Action<MathAtom> CheckAtom<T>(string nucleus) where T : MathAtom =>
+      atom => {
+        var typed = Assert.IsType<T>(atom);
+        Assert.Equal(nucleus, typed.Nucleus);
+      };
+
+    #region Fraction family (\dfrac \tfrac \dbinom \tbinom \cfrac) — iosMath 58b1f8d
+    [Fact]
+    public void DfracParsesWithDisplayStyleOverride() {
+      var list = ParseLaTeX(@"\dfrac1c");
+      var frac = Assert.IsType<Fraction>(Assert.Single(list));
+      Assert.True(frac.HasRule);
+      Assert.Equal(FractionStyle.Display, frac.StyleOverride);
+      Assert.Equal(@"\frac{\displaystyle{1}}{\displaystyle{c}}", RoundTrip(@"\dfrac1c"));
+    }
+    [Fact]
+    public void TfracParsesWithTextStyleOverride() {
+      var frac = Assert.IsType<Fraction>(Assert.Single(ParseLaTeX(@"\tfrac1c")));
+      Assert.True(frac.HasRule);
+      Assert.Equal(FractionStyle.Text, frac.StyleOverride);
+      Assert.Equal(@"\frac{\textstyle{1}}{\textstyle{c}}", RoundTrip(@"\tfrac1c"));
+    }
+    [Fact]
+    public void DbinomAndTbinomParse() {
+      var dbinom = Assert.IsType<Fraction>(Assert.Single(ParseLaTeX(@"\dbinom{n}{k}")));
+      Assert.False(dbinom.HasRule);
+      Assert.Equal(FractionStyle.Display, dbinom.StyleOverride);
+      Assert.Equal(new Boundary("("), dbinom.LeftDelimiter);
+      var tbinom = Assert.IsType<Fraction>(Assert.Single(ParseLaTeX(@"\tbinom{n}{k}")));
+      Assert.False(tbinom.HasRule);
+      Assert.Equal(FractionStyle.Text, tbinom.StyleOverride);
+    }
+    [Fact]
+    public void CfracParsesWithAlignment() {
+      var cfrac = Assert.IsType<Fraction>(Assert.Single(ParseLaTeX(@"\cfrac[l]{a}{b}")));
+      Assert.True(cfrac.HasRule);
+      Assert.True(cfrac.IsContinuedFraction);
+      Assert.Equal(FractionAlignment.Left, cfrac.NumeratorAlignment);
+      var right = Assert.IsType<Fraction>(Assert.Single(ParseLaTeX(@"\cfrac[r]{a}{b}")));
+      Assert.Equal(FractionAlignment.Right, right.NumeratorAlignment);
+      // Invalid alignment is a parse error.
+      var builder = new LaTeXParser(@"\cfrac[zzz]{a}{b}");
+      Assert.NotNull(builder.Build().Error);
+    }
+    [Fact]
+    public void PlainFracKeepsAutoStyle() {
+      var frac = Assert.IsType<Fraction>(Assert.Single(ParseLaTeX(@"\frac1c")));
+      Assert.Equal(FractionStyle.Auto, frac.StyleOverride);
+      Assert.False(frac.IsContinuedFraction);
+      Assert.Equal(@"\frac{1}{c}", RoundTrip(@"\frac1c"));
+    }
+    #endregion
+
+    #region Over/under stack commands — iosMath 43626a4 + 94d8edf
+    [Theory]
+    [InlineData("overrightarrow", "→", true)]
+    [InlineData("overleftarrow", "←", true)]
+    [InlineData("overleftrightarrow", "↔", true)]
+    [InlineData("underrightarrow", "→", false)]
+    [InlineData("underleftarrow", "←", false)]
+    [InlineData("underleftrightarrow", "↔", false)]
+    [InlineData("overbrace", "⏞", true)]
+    public void StretchyStackCommandsParse(string command, string glyph, bool hasOver) {
+      var stack = Assert.IsType<Stack>(Assert.Single(ParseLaTeX($@"\{command}{{x}}")));
+      Assert.Equal(typeof(Ordinary), stack.DisplayClassType);
+      Assert.Single(stack.InnerList);
+      if (hasOver) {
+        var extensible = Assert.IsType<StackConstruction.Extensible>(stack.Over);
+        Assert.Equal(glyph, extensible.Glyph);
+        Assert.Null(stack.Under);
+      } else {
+        var extensible = Assert.IsType<StackConstruction.Extensible>(stack.Under);
+        Assert.Equal(glyph, extensible.Glyph);
+        Assert.Null(stack.Over);
+      }
+      Assert.Equal($@"\{command}{{x}}", RoundTrip($@"\{command}{{x}}"));
+    }
+    // \underbrace keeps its pre-port UnderAnnotation registration (its _ attaches an
+    // under-list), which the iosMath Stack port does not replace.
+    [Fact]
+    public void UnderbraceStaysAnUnderAnnotation() {
+      var underbrace = Assert.IsType<UnderAnnotation>(Assert.Single(ParseLaTeX(@"\underbrace{x}")));
+      Assert.Equal("\u23df", underbrace.Nucleus);
+    }
+    [Fact]
+    public void StackrelForcesRelationClass() {
+      var stack = Assert.IsType<Stack>(Assert.Single(ParseLaTeX(@"\stackrel{?}{=}")));
+      Assert.Equal(typeof(Relation), stack.DisplayClassType);
+      var overRow = Assert.IsType<StackConstruction.MathListRow>(stack.Over);
+      Assert.Single(overRow.List);
+      Assert.Equal(@"\stackrel{?}{=}", RoundTrip(@"\stackrel{?}{=}"));
+    }
+    [Fact]
+    public void StackbinForcesBinaryClass() {
+      var stack = Assert.IsType<Stack>(Assert.Single(ParseLaTeX(@"\stackbin{x}{+}")));
+      Assert.Equal(typeof(BinaryOperator), stack.DisplayClassType);
+      Assert.Equal(@"\stackbin{x}{+}", RoundTrip(@"\stackbin{x}{+}"));
+    }
+    [Theory]
+    [InlineData(@"\overset{!}{=}", typeof(Relation))]   // lone Rel base inherits Relation
+    [InlineData(@"\overset{a}{+}", typeof(BinaryOperator))] // lone Bin base inherits Binary
+    [InlineData(@"\overset{a}{x}", typeof(Ordinary))]
+    public void OversetInheritsBaseClass(string latex, System.Type expectedClass) {
+      var stack = Assert.IsType<Stack>(Assert.Single(ParseLaTeX(latex)));
+      Assert.Equal(expectedClass, stack.DisplayClassType);
+    }
+    [Fact]
+    public void UndersetParsesWithUnderRow() {
+      var stack = Assert.IsType<Stack>(Assert.Single(ParseLaTeX(@"\underset{b}{x}")));
+      Assert.NotNull(stack.Under);
+      Assert.Null(stack.Over);
+      Assert.Equal(typeof(Ordinary), stack.DisplayClassType);
+      Assert.Equal(@"\underset{b}{x}", RoundTrip(@"\underset{b}{x}"));
+    }
+    [Fact]
+    public void OversetCanonicalizesToStackrelOrStackbinOnRoundTrip() {
+      // A lone Bin/Rel base canonicalizes to the dedicated command.
+      Assert.Equal(@"\stackrel{!}{=}", RoundTrip(@"\overset{!}{=}"));
+      Assert.Equal(@"\stackbin{a}{+}", RoundTrip(@"\overset{a}{+}"));
+    }
+    #endregion
+
+    #region Box family: phantom/smash/lap + cancel — iosMath 9f53483 + d49f251
+    [Theory]
+    [InlineData(@"\phantom{x}", true, true, true, false)]
+    [InlineData(@"\hphantom{x}", true, false, false, false)]
+    [InlineData(@"\vphantom{x}", false, true, true, false)]
+    [InlineData(@"\smash{x}", true, false, false, true)]
+    public void PhantomFamilyParses(string latex, bool kW, bool kH, bool kD, bool draw) {
+      var box = Assert.IsType<Box>(Assert.Single(ParseLaTeX(latex)));
+      Assert.Equal(kW, box.KeepWidth);
+      Assert.Equal(kH, box.KeepHeight);
+      Assert.Equal(kD, box.KeepDepth);
+      Assert.Equal(draw, box.DrawChild);
+      Assert.Equal(StrikeStyle.None, box.StrikeStyle);
+    }
+    [Fact]
+    public void MathStrutSynthesizesParen() {
+      var box = Assert.IsType<Box>(Assert.Single(ParseLaTeX(@"\mathstrut")));
+      Assert.False(box.KeepWidth);
+      Assert.True(box.KeepHeight);
+      Assert.True(box.KeepDepth);
+      var paren = Assert.IsType<Open>(Assert.Single(box.InnerList));
+      Assert.Equal("(", paren.Nucleus);
+      // Lossy round trip: \mathstrut serializes as \vphantom{(}
+      Assert.Equal(@"\vphantom{(}", RoundTrip(@"\mathstrut"));
+    }
+    [Fact]
+    public void SmashOptionalArgSelectsAxes() {
+      var smashT = Assert.IsType<Box>(Assert.Single(ParseLaTeX(@"\smash[t]{x}")));
+      Assert.False(smashT.KeepHeight);
+      Assert.True(smashT.KeepDepth);
+      var smashB = Assert.IsType<Box>(Assert.Single(ParseLaTeX(@"\smash[b]{x}")));
+      Assert.True(smashB.KeepHeight);
+      Assert.False(smashB.KeepDepth);
+      // Unknown optional value degrades to plain smash without error.
+      var smashQ = Assert.IsType<Box>(Assert.Single(ParseLaTeX(@"\smash[q]{x}")));
+      Assert.False(smashQ.KeepHeight);
+      Assert.False(smashQ.KeepDepth);
+    }
+    [Theory]
+    [InlineData(@"\llap{x}", BoxHAlign.Right)]
+    [InlineData(@"\rlap{x}", BoxHAlign.Left)]
+    [InlineData(@"\clap{x}", BoxHAlign.Center)]
+    [InlineData(@"\mathllap{x}", BoxHAlign.Right)]
+    [InlineData(@"\mathrlap{x}", BoxHAlign.Left)]
+    [InlineData(@"\mathclap{x}", BoxHAlign.Center)]
+    public void LapsParse(string latex, BoxHAlign align) {
+      var box = Assert.IsType<Box>(Assert.Single(ParseLaTeX(latex)));
+      Assert.False(box.KeepWidth);
+      Assert.True(box.DrawChild);
+      Assert.Equal(align, box.HAlign);
+    }
+    [Theory]
+    [InlineData(@"\llap{x}", @"\llap{x}")]
+    [InlineData(@"\rlap{x}", @"\rlap{x}")]
+    [InlineData(@"\clap{x}", @"\clap{x}")]
+    public void LapsRoundTrip(string latex, string expected) {
+      Assert.Equal(expected, RoundTrip(latex));
+    }
+    [Theory]
+    [InlineData(@"\cancel{x}", StrikeStyle.Forward)]
+    [InlineData(@"\bcancel{x}", StrikeStyle.Backward)]
+    [InlineData(@"\xcancel{x}", StrikeStyle.Cross)]
+    [InlineData(@"\sout{x}", StrikeStyle.Horizontal)]
+    public void CancelFamilyParses(string latex, StrikeStyle strike) {
+      var box = Assert.IsType<Box>(Assert.Single(ParseLaTeX(latex)));
+      Assert.True(box.KeepWidth && box.KeepHeight && box.KeepDepth && box.DrawChild);
+      Assert.Equal(strike, box.StrikeStyle);
+      Assert.Equal(latex, RoundTrip(latex));
+    }
+    [Fact]
+    public void CancelAtEofYieldsEmptyBox() {
+      var box = Assert.IsType<Box>(Assert.Single(ParseLaTeX(@"\cancel")));
+      Assert.Equal(StrikeStyle.Forward, box.StrikeStyle);
+      Assert.Empty(box.InnerList);
+    }
+    #endregion
+
+    #region Modular arithmetic macros — iosMath 035a9e2 + e278be3 + 4091668
+    [Theory]
+    [InlineData(@"\pmod{n}", 1)]
+    [InlineData(@"\mod{n}", 1)]
+    [InlineData(@"\pod{n}", 1)]
+    [InlineData(@"x\implies y", 0)]
+    [InlineData(@"x\iff y", 0)]
+    [InlineData(@"\varliminf", 0)]
+    public void MacrosRoundTrip(string latex, int argc) {
+      var macro = Assert.Single(ParseLaTeX(latex), a => a is Macro) as Macro;
+      Assert.NotNull(macro);
+      Assert.Equal(argc, macro.Arguments.Count);
+      Assert.NotEmpty(macro.Expansion());
+      // Zero-arg macros keep a trailing space so the name terminates; the others
+      // round-trip byte-identically.
+      Assert.Equal(latex, RoundTrip(latex).TrimEnd());
+    }
+    [Fact]
+    public void PmodExpandsToParenthesizedMod() {
+      var finalized = ParseLaTeX(@"\pmod{n}").Clone(true);
+      // Expansion: mkern8mu ( m o d mkern6mu n ) — \mathrm{mod} contributes three
+      // roman atoms, so the flat expansion is 8 atoms wide.
+      Assert.DoesNotContain(finalized, a => a is Macro);
+      Assert.Equal(8, finalized.Count);
+      Assert.IsType<Space>(finalized[0]);
+      Assert.IsType<Open>(finalized[1]);
+      Assert.IsType<Close>(finalized[7]);
+    }
+    [Fact]
+    public void MacroScriptsTransferToExpansion() {
+      var finalized = ParseLaTeX(@"\pmod{n}^2").Clone(true);
+      // The superscript lands on the closing paren of the expansion.
+      var last = Assert.IsType<Close>(finalized.Last);
+      Assert.Single(last.Superscript);
+    }
+    [Fact]
+    public void MissingMacroArgumentIsError() {
+      Assert.NotNull(new LaTeXParser(@"\pmod").Build().Error);
+      Assert.NotNull(new LaTeXParser(@"\mod").Build().Error);
+      Assert.NotNull(new LaTeXParser(@"\pod").Build().Error);
+    }
+    [Fact]
+    public void AddMacroRegistersAndReplaces() {
+      // iosMath b2b19a8: runtime macro registration, with replacement on re-register.
+      // Compare finalized expansions, as the invocation itself serializes back as \half.
+      LaTeXSettings.AddMacro("half", 0, @"\frac{1}{2}");
+      Assert.Equal(FinalizedDebugString(@"\frac{1}{2}"), FinalizedDebugString(@"\half"));
+      LaTeXSettings.AddMacro("half", 0, @"\frac{1}{3}");
+      Assert.Equal(FinalizedDebugString(@"\frac{1}{3}"), FinalizedDebugString(@"\half"));
+    }
+    static string FinalizedDebugString(string latex) => ParseLaTeX(latex).Clone(true).DebugString;
+    // iosMath 76fd773: fusing across a font-style change corrupts the style — Fuse
+    // keeps the first atom's FontStyle, so 1\mathit{2} would drop the italic and
+    // \mathit{1}2 would spread it onto a plain digit.
+    [Theory]
+    [InlineData(@"1\mathit{2}", FontStyle.Default, FontStyle.Italic)]
+    [InlineData(@"\mathit{1}2", FontStyle.Italic, FontStyle.Default)]
+    public void FinalizedDoesNotFuseDigitsAcrossFontStyles(string latex, FontStyle firstStyle, FontStyle secondStyle) {
+      var finalized = ParseLaTeX(latex).Clone(true);
+      Assert.Equal(2, finalized.Count);
+      var first = Assert.IsType<Number>(finalized[0]);
+      var second = Assert.IsType<Number>(finalized[1]);
+      Assert.Equal("1", first.Nucleus);
+      Assert.Equal("2", second.Nucleus);
+      Assert.Equal(firstStyle, first.FontStyle);
+      Assert.Equal(secondStyle, second.FontStyle);
+    }
+    [Fact]
+    public void AddMacroValidatesArityAndTemplate() {
+      Assert.Throws<ArgumentException>(() => LaTeXSettings.AddMacro("ten", 10, @"x"));
+      // #2 referenced but only one argument declared.
+      Assert.Throws<ArgumentException>(() => LaTeXSettings.AddMacro("badref", 1, @"#2"));
+      Assert.Throws<ArgumentException>(() => LaTeXSettings.AddMacro("trailing", 0, @"x#"));
+    }
+    [Fact]
+    public void RawMacroArgumentsPreserveNestedBracesAndHashes() {
+      LaTeXSettings.AddMacro("rawprobe", 1, @"#1");
+      var source = @"\rawprobe{{a}{b}}";
+      Assert.Equal(source, RoundTrip(source));
+      Assert.Equal("{a}{b}", Assert.IsType<Macro>(Assert.Single(ParseLaTeX(source))).Arguments[0]);
+    }
+    [Fact]
+    public void MacroSupportsLiteralHashEscape() {
+      LaTeXSettings.AddMacro("hashprobe", 0, @"\textcolor{##f00}{x}");
+      Assert.NotNull(ParseLaTeX(@"\hashprobe").Clone(true));
+    }
+    [Fact]
+    public void MacroExpansionErrorsCarryCommandContext() {
+      LaTeXSettings.AddMacro("badexpansion", 0, @"{");
+      var error = new LaTeXParser(@"\badexpansion").Build().Error;
+      Assert.Contains(@"\badexpansion", error);
+    }
+    [Fact]
+    public void MacroExpansionHonorsRecursionCap() {
+      LaTeXSettings.AddMacro("recursiveProbe", 0, @"\recursiveProbe");
+      var error = new LaTeXParser(@"\recursiveProbe").Build().Error;
+      Assert.Contains("depth", error, System.StringComparison.OrdinalIgnoreCase);
+    }
+    [Fact]
+    public void MacroNestedPlaceholdersAndScriptsRemainAttached() {
+      LaTeXSettings.AddMacro("joinProbe", 2, @"[#2|#1]");
+      var list = ParseLaTeX(@"\joinProbe{{a_b}}{c}^2");
+      var macro = Assert.IsType<Macro>(Assert.Single(list));
+      Assert.Equal(new[] { "{a_b}", "c" }, macro.Arguments);
+      var final = list.Clone(true);
+      Assert.Contains(final, atom => atom.Superscript.Count == 1);
+    }
+
+    [Theory]
+    [InlineData(@"\big(", 1, "Ordinary", "(")]
+    [InlineData(@"\Big[", 2, "Ordinary", "[")]
+    [InlineData(@"\bigg\{", 3, "Ordinary", "{")]
+    [InlineData(@"\Bigg\langle", 4, "Ordinary", "⟨")]
+    [InlineData(@"\bigl(", 1, "Open", "(")]
+    [InlineData(@"\Bigl[", 2, "Open", "[")]
+    [InlineData(@"\biggl\{", 3, "Open", "{")]
+    [InlineData(@"\Biggl\lceil", 4, "Open", "⌈")]
+    [InlineData(@"\bigr)", 1, "Close", ")")]
+    [InlineData(@"\Bigr]", 2, "Close", "]")]
+    [InlineData(@"\biggr\}", 3, "Close", "}")]
+    [InlineData(@"\Biggr\rfloor", 4, "Close", "⌋")]
+    [InlineData(@"\bigm|", 1, "Relation", "|")]
+    [InlineData(@"\Bigm\|", 2, "Relation", "‖")]
+    [InlineData(@"\biggm\Vert", 3, "Relation", "‖")]
+    [InlineData(@"\Biggm\langle", 4, "Relation", "⟨")]
+    public void ExplicitLargeDelimitersParseAndRoundTrip(string latex, int size, string mathClass, string nucleus) {
+      var delimiter = Assert.IsType<LargeDelimiter>(Assert.Single(ParseLaTeX(latex)));
+      Assert.Equal(size, (int)delimiter.Size);
+      Assert.Equal(mathClass, delimiter.MathClass.Name);
+      Assert.Equal(nucleus, delimiter.Nucleus);
+      var expected = latex.EndsWith(@"\Vert") ? latex.Replace(@"\Vert", @"\|") :
+        latex.EndsWith(@"\langle") ? latex.Replace(@"\langle", "<") : latex;
+      Assert.Equal(expected, RoundTrip(latex));
+    }
+    [Fact]
+    public void ExplicitLargeDelimiterSupportsNullAndScripts() {
+      var list = ParseLaTeX(@"\bigl.^2\bigr.");
+      Assert.Collection(list,
+        left => { var d = Assert.IsType<LargeDelimiter>(left); Assert.Equal("", d.Nucleus); Assert.Single(d.Superscript); },
+        right => { var d = Assert.IsType<LargeDelimiter>(right); Assert.Equal("", d.Nucleus); });
+      Assert.Equal(@"\bigl.^2\bigr.", RoundTrip(@"\bigl.^2\bigr."));
+    }
+    [Theory]
+    [InlineData(@"\big")]
+    [InlineData(@"\Bigl")]
+    [InlineData(@"\bigm?")]
+    public void ExplicitLargeDelimiterRejectsMissingOrInvalidDelimiter(string latex) {
+      Assert.NotNull(new LaTeXParser(latex).Build().Error);
+    }
+    [Fact]
+    public void ExplicitLargeDelimiterRemainsIndependentFromAdjacentOrdinaryAtoms() {
+      var list = ParseLaTeX(@"a\bigl(b");
+      Assert.Equal(3, list.Count);
+      Assert.IsType<Variable>(list[0]);
+      Assert.IsType<LargeDelimiter>(list[1]);
+      Assert.IsType<Variable>(list[2]);
+    }
+
+    [Fact]
+    public void TableSpacersAreIndependentAndStylesCanBeSharedSafely() {
+      var table = Assert.IsType<Table>(Assert.Single(ParseLaTeX(@"\begin{aligned}a&b\\c&d\end{aligned}")));
+      var spacer0 = table.Cells[0][1][0];
+      var spacer1 = table.Cells[1][1][0];
+      Assert.NotSame(spacer0, spacer1);
+      spacer0.Nucleus = "changed";
+      Assert.NotEqual("changed", spacer1.Nucleus);
+      var casesInner = Assert.IsType<Inner>(Assert.Single(ParseLaTeX(@"\begin{cases}a&b\\c&d\end{cases}")));
+      var matrix = Assert.IsType<Table>(casesInner.InnerList[1]);
+      var style0 = matrix.Cells[0][0].First();
+      var style1 = matrix.Cells[1][1].First();
+      Assert.Same(style0, style1);
+      var style = Assert.IsType<Style>(style0);
+      Assert.Throws<System.InvalidOperationException>(() => style.Nucleus = "x");
+      Assert.Throws<System.InvalidOperationException>(() => style.FontStyle = FontStyle.Italic);
+      Assert.NotNull(style.Clone(false));
+    }
+    [Fact]
+    public void MacroStoresRawArgumentsAndExpansion() {
+      LaTeXSettings.AddMacro("probe", 2, @"[#1|#2]");
+      var macro = Assert.IsType<Macro>(Assert.Single(ParseLaTeX(@"\probe{{a}{b}}{c}")));
+      Assert.Equal(new[] { "{a}{b}", "c" }, macro.Arguments);
+      Assert.NotEmpty(macro.Expansion());
+    }
+    [Fact]
+    public void BmodStaysABinaryOperator() {
+      // \bmod is a plain symbol table entry, not a macro. After finalize the leading
+      // number fuses and the trailing number follows the binary op.
+      var finalized = ParseLaTeX(@"17 \bmod 5").Clone(true);
+      Assert.Collection(finalized,
+        CheckAtom<Number>("17"),
+        atom => {
+          var mod = Assert.IsType<BinaryOperator>(atom);
+          Assert.Equal("mod", mod.Nucleus);
+        },
+        CheckAtom<Number>("5"));
+    }
+    #endregion
+
+    #region Spacing commands in math mode — iosMath f644371
+    [Fact]
+    public void KernAcceptsEmAndMuInMathMode() {
+      var kern = Assert.IsType<Space>(Assert.Single(ParseLaTeX(@"\kern1em")));
+      Assert.True(kern.IsMu);
+      Assert.Equal(18, kern.Length); // em == 18mu
+      var mkern = Assert.IsType<Space>(Assert.Single(ParseLaTeX(@"\mkern3mu")));
+      Assert.Equal(3, mkern.Length);
+    }
+    [Fact]
+    public void HspaceParsesInBraces() {
+      var space = Assert.IsType<Space>(Assert.Single(ParseLaTeX(@"\hspace{1em}")));
+      Assert.Equal(18, space.Length);
+      var negative = Assert.IsType<Space>(Assert.Single(ParseLaTeX(@"\hspace{-0.5em}")));
+      Assert.Equal(-9, negative.Length);
+    }
+    [Fact]
+    public void NamedAmsmathSpacesParse() {
+      foreach (var (command, length) in new[] {
+        (@"\thinspace", 3f), (@"\medspace", 4f), (@"\thickspace", 5f),
+        (@"\negthinspace", -3f), (@"\negmedspace", -4f), (@"\negthickspace", -5f),
+      }) {
+        var space = Assert.IsType<Space>(Assert.Single(ParseLaTeX(command)));
+        Assert.True(space.IsMu);
+        Assert.Equal(length, space.Length);
+      }
+    }
+    #endregion
+
+    #region Environments: smallmatrix/gathered/alignedat/array rules — iosMath 8d52b86/dd76eb5/cc62444
+    [Fact]
+    public void SmallmatrixUsesScriptCells() {
+      var table = Assert.IsType<Table>(Assert.Single(
+        ParseLaTeX(@"\begin{smallmatrix} x & y \\ z & w \end{smallmatrix}")));
+      Assert.Equal("smallmatrix", table.Environment);
+      Assert.Equal(LineStyle.Script, table.CellStyle);
+      Assert.Equal(5, table.InterColumnSpacing);
+      Assert.Equal(2, table.NRows);
+      Assert.Equal(@"\begin{smallmatrix}x&y\\ z&w\end{smallmatrix}",
+        RoundTrip(@"\begin{smallmatrix} x & y \\ z & w \end{smallmatrix}"));
+    }
+    [Fact]
+    public void GatheredInheritsStyle() {
+      var table = Assert.IsType<Table>(Assert.Single(
+        ParseLaTeX(@"\begin{gathered} x \\ y \end{gathered}")));
+      Assert.Equal("gathered", table.Environment);
+      Assert.Null(table.CellStyle); // inherits surrounding style
+      Assert.Equal(1, table.InterRowAdditionalSpacing);
+      Assert.Equal(@"\begin{gathered}x\\ y\end{gathered}",
+        RoundTrip(@"\begin{gathered} x \\ y \end{gathered}"));
+    }
+    [Fact]
+    public void AlignedatReadsPairCountArgument() {
+      var table = Assert.IsType<Table>(Assert.Single(
+        ParseLaTeX(@"\begin{alignedat}{2} 10&x +& 3&y \\ 3&x +& 13&y \end{alignedat}")));
+      Assert.Equal("alignedat", table.Environment);
+      Assert.Equal(4, table.NColumns);
+      Assert.Equal(ColumnAlignment.Right, table.GetAlignment(0));
+      Assert.Equal(ColumnAlignment.Left, table.GetAlignment(1));
+      Assert.Equal(ColumnAlignment.Right, table.GetAlignment(2));
+      Assert.Equal(ColumnAlignment.Left, table.GetAlignment(3));
+      Assert.Contains("{2}", RoundTrip(@"\begin{alignedat}{2} 10&x +& 3&y \\ 3&x +& 13&y \end{alignedat}"));
+    }
+    [Fact]
+    public void AlignedatValidatesColumnCount() {
+      // 3 columns != 2n for any n
+      Assert.NotNull(new LaTeXParser(@"\begin{alignedat}{2} a&b&c \end{alignedat}").Build().Error);
+      // Missing argument
+      Assert.NotNull(new LaTeXParser(@"\begin{alignedat} a & b \end{alignedat}").Build().Error);
+    }
+    [Fact]
+    public void ArrayParsesVerticalLines() {
+      var table = Assert.IsType<Table>(Assert.Single(
+        ParseLaTeX(@"\begin{array}{|r|c|l|} 10 & = & 7 + 3 \end{array}")));
+      Assert.Equal("array", table.Environment);
+      Assert.Equal(new[] { 1, 1, 1, 1 }, table.VerticalLines);
+      Assert.Equal(ColumnAlignment.Right, table.GetAlignment(0));
+      Assert.Equal(ColumnAlignment.Center, table.GetAlignment(1));
+      Assert.Equal(ColumnAlignment.Left, table.GetAlignment(2));
+      Assert.Equal(@"\begin{array}{|r|c|l|}10&=&7+3\end{array}",
+        RoundTrip(@"\begin{array}{|r|c|l|} 10 & = & 7 + 3 \end{array}"));
+    }
+    [Fact]
+    public void ArrayParsesHorizontalLines() {
+      var table = Assert.IsType<Table>(Assert.Single(
+        ParseLaTeX(@"\begin{array}{c} \hline a \\ \hline b \end{array}")));
+      // The first \hline is boundary 0 (above row 0); the second lands on boundary 1
+      // once the \\ advances the row counter.
+      Assert.Equal(new[] { 1, 1, 0 }, table.HorizontalLines);
+      Assert.Equal(2, table.NRows);
+    }
+    [Fact]
+    public void HlineOutsideArrayIsError() {
+      Assert.NotNull(new LaTeXParser(@"\hline a").Build().Error);
+    }
+    [Fact]
+    public void ArrayToleratesExtraCells() {
+      // Pre-port behavior: extra cells are dropped rather than erroring.
+      Assert.Null(new LaTeXParser(@"\begin{array}{c} a & b \end{array}").Build().Error);
+    }
+    #endregion
+
+    #region TeX-faithful brace grouping — iosMath 086d345
+    [Fact]
+    public void BracesCreateOrdGroups() {
+      var group = Assert.IsType<Group>(ParseLaTeX(@"5{3+4}")[1]);
+      Assert.Equal(3, group.InnerList.Count);
+      Assert.Equal("5{3+4}", RoundTrip(@"5{3+4}"));
+    }
+    [Fact]
+    public void ScriptsAttachToWholeGroup() {
+      var group = Assert.IsType<Group>(Assert.Single(ParseLaTeX(@"{x}^2")));
+      Assert.Single(group.Superscript);
+    }
+    [Fact]
+    public void ScriptStyleDoesNotLeakPastGroup() {
+      // The whole point of issue #177: z must not be scriptstyle.
+      var list = ParseLaTeX(@"x{\scriptstyle y}z");
+      Assert.Equal(3, list.Count);
+      Assert.IsType<Group>(list[1]);
+      var z = Assert.IsType<Variable>(list[2]);
+      Assert.Equal(FontStyle.Default, z.FontStyle);
+      Assert.Equal(@"x{\scriptstyle y}z", RoundTrip(@"x{\scriptstyle y}z"));
+    }
+    [Fact]
+    public void OverTransformReplacesTheGroup() {
+      // {a \over b} becomes a bare fraction (TeX group-transformation semantics).
+      var frac = Assert.IsType<Fraction>(Assert.Single(ParseLaTeX(@"{a \over b}")));
+      Assert.True(frac.HasRule);
+      Assert.Equal(@"\frac{a}{b}", RoundTrip(@"{a \over b}"));
+    }
+    [Theory]
+    [InlineData(@"x^\over y")]
+    [InlineData(@"x_\over y")]
+    [InlineData(@"x^\atop y")]
+    [InlineData(@"x^\choose y")]
+    public void GeneralizedFractionInOneCharSlotIsError(string latex) {
+      // iosMath 801af6f: \over/\atop/\choose/\brack/\brace in a one-character
+      // argument slot must error, not silently swallow the rest of the input.
+      Assert.NotNull(new LaTeXParser(latex).Build().Error);
+    }
+    [Fact]
+    public void BracedGeneralizedFractionStillParses() {
+      // The explicitly-braced form is unaffected (iosMath 801af6f regression guard).
+      var list = ParseLaTeX(@"x^{1 \over y}");
+      var x = Assert.IsType<Variable>(Assert.Single(list));
+      var sup = Assert.Single(x.Superscript);
+      Assert.IsType<Fraction>(sup);
+      Assert.Equal(@"x^{\frac{1}{y}}", RoundTrip(@"x^{1 \over y}"));
+    }
+    [Fact]
+    public void NestedGroupsSurvive() {
+      // The outer braces wrap a single Group atom, which serializes bare, so the
+      // inner group's braces are what survive; both levels parse as Groups.
+      var list = ParseLaTeX(@"{{a+b}}");
+      var outer = Assert.IsType<Group>(Assert.Single(list));
+      var inner = Assert.IsType<Group>(Assert.Single(outer.InnerList));
+      Assert.Equal(3, inner.InnerList.Count);
+      Assert.IsType<Variable>(inner.InnerList[0]);
+    }
+    #endregion
+
+    #region Recursion cap + primes — iosMath ef6ac9f (primes pre-exist via the symbol table)
+    [Fact]
+    public void DeepNestingIsAParseErrorNotACrash() {
+      const int depth = 1000;
+      var input = new string('{', depth) + "1" + new string('}', depth);
+      Assert.NotNull(new LaTeXParser(input).Build().Error);
+    }
+    [Fact]
+    public void ModerateNestingStillParses() {
+      const int depth = 20;
+      var input = new string('{', depth) + "1" + new string('}', depth);
+      Assert.Null(new LaTeXParser(input).Build().Error);
+    }
+    // Primes were already supported in CSharpMath via '''-style symbol table entries
+    // (′ ″ ‴ ⁗), so iosMath's parser branch was not ported.
+    [Fact]
+    public void PrimesParseToPrimeGlyphs() {
+      var single = ParseLaTeX(@"f'");
+      Assert.Equal("′", single[^1].Nucleus);
+      var doublePrime = ParseLaTeX(@"f''");
+      Assert.Equal("″", doublePrime[^1].Nucleus);
+      var triple = ParseLaTeX(@"f'''");
+      Assert.Equal("‴", triple[^1].Nucleus);
+    }
+    #endregion
+
+    #region Color validation + textcolor — iosMath 3471a4f/c27737a + REN-7
+    [Fact]
+    public void TextcolorIsAnAliasOfColor() {
+      var colored = Assert.IsType<Colored>(Assert.Single(ParseLaTeX(@"\textcolor{#FF0000}{x}")));
+      Assert.Equal(System.Drawing.Color.FromArgb(255, 0, 0), colored.Color);
+      // The serializer emits the canonical name for pure red.
+      Assert.Equal(@"\color{red}{x}", RoundTrip(@"\textcolor{#FF0000}{x}"));
+    }
+    [Fact]
+    public void RgbShorthandExpands() {
+      var colored = Assert.IsType<Colored>(Assert.Single(ParseLaTeX(@"\color{#f00}x")));
+      Assert.Equal(System.Drawing.Color.FromArgb(255, 0, 0), colored.Color);
+    }
+    [Fact]
+    public void InvalidColorsAreErrors() {
+      Assert.NotNull(new LaTeXParser(@"\color{notacolor}{x}").Build().Error);
+      Assert.NotNull(new LaTeXParser(@"\color{#gg0000}{x}").Build().Error); // non-hex
+      Assert.NotNull(new LaTeXParser(@"\color{#ff00}{x}").Build().Error); // wrong length
+    }
+    [Fact]
+    public void ValidNamedColorsStillParse() {
+      var colored = Assert.IsType<Colored>(Assert.Single(ParseLaTeX(@"\color{red}x")));
+      Assert.Equal(System.Drawing.Color.FromArgb(255, 0, 0), colored.Color);
+    }
+    #endregion
+
+    #region New symbols — iosMath 48f6fca + 19d98d3
+    [Theory]
+    [InlineData(@"\lt", "<")]
+    [InlineData(@"\gt", ">")]
+    [InlineData(@"\restriction", "↾")]
+    [InlineData(@"\dotsc", "…")]
+    public void NewAliasesParse(string command, string nucleus) {
+      var atom = Assert.Single(ParseLaTeX(command));
+      Assert.Equal(nucleus, atom.Nucleus);
+    }
+    #endregion
+
+    #region Sqrt EOF safety — iosMath da9abdd
+    [Fact]
+    public void LoneSqrtAtEndDoesNotCrash() {
+      var radical = Assert.IsType<Radical>(Assert.Single(ParseLaTeX(@"\sqrt")));
+      Assert.Empty(radical.Radicand);
+      Assert.True(radical.Degree.IsEmpty());
+      Assert.Equal(@"\sqrt{}", RoundTrip(@"\sqrt"));
+    }
+    [Fact]
+    public void SqrtInGroupDoesNotCrash() {
+      Assert.Null(new LaTeXParser(@"{\sqrt}").Build().Error);
+    }
+    #endregion
+  }
+}
diff --git a/CSharpMath.Core.Tests/Atom/LaTeXParserTest.cs b/CSharpMath.Core.Tests/Atom/LaTeXParserTest.cs
index bb6a4b32..6fec9a94 100644
--- a/CSharpMath.Core.Tests/Atom/LaTeXParserTest.cs
+++ b/CSharpMath.Core.Tests/Atom/LaTeXParserTest.cs
@@ -47,8 +47,8 @@ public static Action<MathAtom> CheckAtom<T>
     [InlineData("=", new[] { typeof(Relation) }, "=")]
     [InlineData("x+2", new[] { typeof(Variable), typeof(BinaryOperator), typeof(Number) }, "x+2")]
     [InlineData("(2.3 * 8)", new[] { typeof(Open), typeof(Number), typeof(Number), typeof(Number), typeof(BinaryOperator), typeof(Number), typeof(Close) }, "(2.3*8)")]
-    [InlineData("5{3+4}", new[] { typeof(Number), typeof(Number), typeof(BinaryOperator), typeof(Number) }, "53+4")] // braces are just for grouping
-                                                                                                                     // commands
+    [InlineData("5{3+4}", new[] { typeof(Number), typeof(Group) }, "5{3+4}")] // braces create an Ord group
+    // commands
     [InlineData(@"\pi+\theta\geq 3", new[] { typeof(Variable), typeof(BinaryOperator), typeof(Variable), typeof(Relation), typeof(Number) }, @"\pi +\theta \geq 3")]
     // aliases
     [InlineData(@"\pi\ne 5 \land 3", new[] { typeof(Variable), typeof(Relation), typeof(Number), typeof(BinaryOperator), typeof(Number) }, @"\pi \neq 5\wedge 3")]
@@ -76,8 +76,8 @@ public void TestBuilder(string input, Type[] atomTypes, string output) {
     [InlineData("^2", "{}^2", new[] { typeof(Ordinary) }, new[] { typeof(Number) })]
     [InlineData("^{^3}", "{}^{{}^3}", new[] { typeof(Ordinary), }, new[] { typeof(Ordinary) }, new[] { typeof(Number) })]
     [InlineData("^^3", "{}^{{}^3}", new[] { typeof(Ordinary), }, new[] { typeof(Ordinary) }, new[] { typeof(Number) })]
-    [InlineData("{}^2", "{}^2", new[] { typeof(Ordinary) }, new[] { typeof(Number) })]
-    [InlineData("5{x}^2", "5x^2", new[] { typeof(Number), typeof(Variable) }, new Type[] { })]
+    [InlineData("{}^2", "{}^2", new[] { typeof(Group) }, new[] { typeof(Number) })]
+    [InlineData("5{x}^2", "5{x}^2", new[] { typeof(Number), typeof(Group) }, new Type[] { })]
     public void TestScript(string input, string output, params Type[][] atomTypes) {
       RunScriptTest(input, atom => atom.Superscript, atomTypes, output);
       RunScriptTest(input.Replace('^', '_'), atom => atom.Subscript, atomTypes, output.Replace('^', '_'));
@@ -541,12 +541,13 @@ public void TestMatrix(string env, string? left, string? right, string? leftOutp
       for (int col = 0; col < 2; col++) {
         Assert.Equal(ColumnAlignment.Center, table.GetAlignment(col));
         for (int row = 0; row < 2; row++) {
+          // Cells render in textstyle via the table rather than an injected style atom.
           Assert.Collection(table.Cells[row][col],
-            CheckAtom<Style>("", style => Assert.Equal(LineStyle.Text, style.LineStyle)),
             atom => Assert.IsType<Variable>(atom)
           );
         }
       }
+      Assert.Equal(LineStyle.Text, table.CellStyle);
       Assert.Equal($@"{leftOutput}\begin{{matrix}}x&y\\ z&w\end{{matrix}}{rightOutput}",
         LaTeXParser.MathListToLaTeX(list).ToString());
     }
@@ -561,35 +562,42 @@ public void TestMatrix(string env, string? left, string? right, string? leftOutp
     [InlineData(@"\color{red}{{\left( \begin{matrix}1&2\\ 3&4\end{matrix}\right) }}")]
     public void TestRedMatrix(string input) {
       var list = ParseLaTeX(input);
-      Assert.Collection(list, CheckAtom<Colored>("", colored => {
-        Assert.Equal(System.Drawing.Color.FromArgb(255, 0, 0), colored.Color);
-        Assert.Collection(colored.InnerList,
-          CheckAtom<Inner>("", inner => {
-            Assert.Equal(new Boundary("("), inner.LeftBoundary);
-            Assert.Equal(new Boundary(")"), inner.RightBoundary);
-            Assert.Collection(inner.InnerList,
-              CheckAtom<Table>("", table => {
-                Assert.Equal("matrix", table.Environment);
-                Assert.Equal(0, table.InterRowAdditionalSpacing);
-                Assert.Equal(18, table.InterColumnSpacing);
-                Assert.Equal(2, table.NRows);
-                Assert.Equal(2, table.NColumns);
-                for (int col = 0; col < 2; col++) {
-                  Assert.Equal(ColumnAlignment.Center, table.GetAlignment(col));
-                  for (int row = 0; row < 2; row++) {
-                    Assert.Collection(table.Cells[row][col],
-                      CheckAtom<Style>("", style => Assert.Equal(LineStyle.Text, style.LineStyle)),
-                      atom => Assert.IsType<Number>(atom)
-                    );
-                  }
+      // Double-braced variants wrap the content in an Ord group; unwrap it.
+      MathList inner = list;
+      while (inner.Single() is Group group)
+        inner = group.InnerList;
+      var coloredAtom = (Colored)inner.Single();
+      // A group may also wrap the colored content's inner list.
+      var coloredInner = coloredAtom.InnerList;
+      while (coloredInner.Single() is Group group)
+        coloredInner = group.InnerList;
+      Assert.Collection(coloredInner,
+        CheckAtom<Inner>("", matrixInner => {
+          Assert.Equal(new Boundary("("), matrixInner.LeftBoundary);
+          Assert.Equal(new Boundary(")"), matrixInner.RightBoundary);
+          Assert.Collection(matrixInner.InnerList,
+            CheckAtom<Table>("", table => {
+              Assert.Equal("matrix", table.Environment);
+              Assert.Equal(0, table.InterRowAdditionalSpacing);
+              Assert.Equal(18, table.InterColumnSpacing);
+              Assert.Equal(2, table.NRows);
+              Assert.Equal(2, table.NColumns);
+              for (int col = 0; col < 2; col++) {
+                Assert.Equal(ColumnAlignment.Center, table.GetAlignment(col));
+                for (int row = 0; row < 2; row++) {
+                  // Cells render in textstyle via the table; grouping braces around
+                  // cells survive as Ord groups.
+                  Assert.All(table.Cells[row][col], atom => Assert.IsAssignableFrom<MathAtom>(atom));
                 }
-              })
-            );
-          })
-        );
-      }));
-      Assert.Equal(@"\color{red}{\left( \begin{matrix}1&2\\ 3&4\end{matrix}\right) }",
-        LaTeXParser.MathListToLaTeX(list).ToString());
+              }
+              Assert.Equal(LineStyle.Text, table.CellStyle);
+            })
+          );
+        }));
+      // Round-trip stability: serialization re-parses to itself. Brace survival now
+      // varies per input (TeX ordgroup semantics), so the exact string does too.
+      var firstPass = LaTeXParser.MathListToLaTeX(list).ToString();
+      Assert.Equal(firstPass, LaTeXParser.MathListToLaTeX(ParseLaTeX(firstPass)).ToString());
     }
 
     [Fact]
@@ -607,8 +615,6 @@ public void TestDeterminant() {
               for (int i = 0; i < 2 * 2; i++) {
                 Assert.Equal(ColumnAlignment.Center, table.GetAlignment(i % 2));
                 IEnumerable<Action<MathAtom>> Checkers() {
-                  yield return
-                    CheckAtom<Style>("", style => Assert.Equal(LineStyle.Text, style.LineStyle));
                   if (i == 2) yield return CheckAtom<BinaryOperator>("\u2212");
                   yield return CheckAtom<LargeOperator>(i switch { 0 => "sin", 3 => "sin", _ => "cos" });
                   yield return CheckAtom<Open>("(");
@@ -618,6 +624,7 @@ IEnumerable<Action<MathAtom>> Checkers() {
                 ;
                 Assert.Collection(table.Cells[i / 2][i % 2], Checkers().ToArray());
               }
+              Assert.Equal(LineStyle.Text, table.CellStyle);
             })
           )
         ),
@@ -666,51 +673,75 @@ public void TestDefaultTable() {
     [InlineData(@"\left(x \\ \right)")]
     [InlineData(@"\left( x\\ \right)")]
     [InlineData(@"\left( x\\ \right) ")]
-    [InlineData(@"\left({x\\}\right) ")]
-    [InlineData(@"\left({{x\\}}\right) ")]
     public void TestDefaultTableInInner(string input) {
-      var list = ParseLaTeX(input);
-      CheckAtom<Inner>("", inner => {
-        Assert.Equal(new Boundary("("), inner.LeftBoundary);
-        Assert.Equal(new Boundary(")"), inner.RightBoundary);
-        CheckAtom<Table>("", table => {
-          Assert.Null(table.Environment);
-          Assert.Equal(1, table.InterRowAdditionalSpacing);
-          Assert.Equal(0, table.InterColumnSpacing);
-          Assert.Equal(2, table.NRows);
-          Assert.Equal(1, table.NColumns);
-          Assert.Equal(ColumnAlignment.Left, table.GetAlignment(0));
-          Assert.IsType<Variable>(Assert.Single(table.Cells[0][0]));
-          Assert.Empty(table.Cells[1][0]);
-        })(Assert.Single(inner.InnerList));
-      })(Assert.Single(list));
-      Assert.Equal(@"\left( x\\ \right) ", LaTeXParser.MathListToLaTeX(list).ToString());
+      InnerListIsDefaultTable(input);
+      // Grouping braces wrap their content as an Ord group (TeX ordgroup).
+      InnerListIsDefaultTable(@"\left({x\\}\right) ", expectGroup: true);
+      InnerListIsDefaultTable(@"\left({{x\\}}\right) ", expectGroup: true);
+
+      void InnerListIsDefaultTable(string input, bool expectGroup = false) {
+        var list = ParseLaTeX(input);
+        CheckAtom<Inner>("", inner => {
+          Assert.Equal(new Boundary("("), inner.LeftBoundary);
+          Assert.Equal(new Boundary(")"), inner.RightBoundary);
+          MathList tableHolder = inner.InnerList;
+          // Unwrap every leading Group: {x} wraps once, {{x}} twice.
+          while (tableHolder.Single() is Group group) {
+            Assert.True(expectGroup);
+            tableHolder = group.InnerList;
+          }
+          CheckAtom<Table>("", table => {
+            Assert.Null(table.Environment);
+            Assert.Equal(1, table.InterRowAdditionalSpacing);
+            Assert.Equal(0, table.InterColumnSpacing);
+            Assert.Equal(2, table.NRows);
+            Assert.Equal(1, table.NColumns);
+            Assert.Equal(ColumnAlignment.Left, table.GetAlignment(0));
+            Assert.IsType<Variable>(Assert.Single(table.Cells[0][0]));
+            Assert.Empty(table.Cells[1][0]);
+          })(Assert.Single(tableHolder));
+        })(Assert.Single(list));
+        // Serialization must not throw for grouped table content.
+        _ = LaTeXParser.MathListToLaTeX(list).ToString();
+      }
     }
     [Theory]
     [InlineData(@"\left(\\\right)")]
     [InlineData(@"\left( \\ \right) ")]
-    [InlineData(@"\left({\\}\right) ")]
-    [InlineData(@"\left({{\\}}\right) ")]
     public void TestEmptyTableInInner(string input) {
-      var list = ParseLaTeX(input);
-      CheckAtom<Inner>("", inner => {
-        Assert.Equal(new Boundary("("), inner.LeftBoundary);
-        Assert.Equal(new Boundary(")"), inner.RightBoundary);
-        CheckAtom<Table>("", table => {
-          Assert.Null(table.Environment);
-          Assert.Equal(1, table.InterRowAdditionalSpacing);
-          Assert.Equal(0, table.InterColumnSpacing);
-          Assert.Equal(2, table.NRows);
-          Assert.Equal(1, table.NColumns);
-          for (int col = 0; col < 1; col++) {
-            Assert.Equal(ColumnAlignment.Left, table.GetAlignment(col));
-            for (int row = 0; row < 2; row++) {
-              Assert.Empty(table.Cells[row][col]);
-            }
+      EmptyTableInInner(input);
+      // Grouping braces wrap their content as an Ord group (TeX ordgroup).
+      EmptyTableInInner(@"\left({\\}\right) ", expectGroup: true);
+      EmptyTableInInner(@"\left({{\\}}\right) ", expectGroup: true);
+
+      void EmptyTableInInner(string input, bool expectGroup = false) {
+        var list = ParseLaTeX(input);
+        CheckAtom<Inner>("", inner => {
+          Assert.Equal(new Boundary("("), inner.LeftBoundary);
+          Assert.Equal(new Boundary(")"), inner.RightBoundary);
+          MathList tableHolder = inner.InnerList;
+          // Unwrap every leading Group: {\\} wraps once, {{\\}} twice.
+          while (tableHolder.Single() is Group group) {
+            Assert.True(expectGroup);
+            tableHolder = group.InnerList;
           }
-        })(Assert.Single(inner.InnerList));
-      })(Assert.Single(list));
-      Assert.Equal(@"\left( \\ \right) ", LaTeXParser.MathListToLaTeX(list).ToString());
+          CheckAtom<Table>("", table => {
+            Assert.Null(table.Environment);
+            Assert.Equal(1, table.InterRowAdditionalSpacing);
+            Assert.Equal(0, table.InterColumnSpacing);
+            Assert.Equal(2, table.NRows);
+            Assert.Equal(1, table.NColumns);
+            for (int col = 0; col < 1; col++) {
+              Assert.Equal(ColumnAlignment.Left, table.GetAlignment(col));
+              for (int row = 0; row < 2; row++) {
+                Assert.Empty(table.Cells[row][col]);
+              }
+            }
+          })(Assert.Single(tableHolder));
+        })(Assert.Single(list));
+        // Serialization must not throw for grouped table content.
+        _ = LaTeXParser.MathListToLaTeX(list).ToString();
+      }
     }
     [Theory]
     [InlineData(@"x\\1\left(2\right)3\\x")]
@@ -748,8 +779,8 @@ public void TestInnerInTable(string input) {
       Assert.Equal(@"x\\ 1\left( 2\right) 3\\ x", LaTeXParser.MathListToLaTeX(list).ToString());
     }
     [Theory]
-    [InlineData(@"1\\2\left(3\begin{array}{ll}4&\left[5\\6\right]\\\left\{7\begin{cases}8\\9\end{cases}0\right\}a\end{array}b\right)c\\d", 0)]
-    [InlineData(@"1\\ 2\left( 3\begin{array}{ll}4&\left[ 5\\ 6\right] \\ \left\{ 7\left\{ \, \begin{array}{l}\textstyle 8\\ \textstyle 9\end{array}\right. 0\right\} a\end{array}b\right) c\\ d", 1)]
+    [InlineData(@"1\\2\left(3\begin{array}{ll}4&\left[5\\6\right]\\\left\{7\begin{cases}8\\9\end{cases}0\right\}a\end{array}b\right)c\\d", 1)]
+    [InlineData(@"1\\ 2\left( 3\begin{array}{ll}4&\left[ 5\\ 6\right] \\ \left\{ 7\left\{ \, \begin{array}{l}8\\ 9\end{array}\right. 0\right\} a\end{array}b\right) c\\ d", 0)]
     public void TestTablesAndInners(string input, float casesInterRowAdditionalSpacing) {
       var list = ParseLaTeX(input);
       CheckAtom<Table>("", table => {
@@ -770,7 +801,8 @@ public void TestTablesAndInners(string input, float casesInterRowAdditionalSpaci
               CheckAtom<Number>("3"),
               CheckAtom<Table>("", array => {
                 Assert.Equal("array", array.Environment);
-                Assert.Equal(1, array.InterRowAdditionalSpacing);
+                // array cells stay at the surrounding style with no extra row spacing.
+                Assert.Equal(0, array.InterRowAdditionalSpacing);
                 Assert.Equal(18, array.InterColumnSpacing);
                 Assert.Equal(2, array.NRows);
                 Assert.Equal(2, array.NColumns);
@@ -806,18 +838,21 @@ public void TestTablesAndInners(string input, float casesInterRowAdditionalSpaci
                           CheckAtom<Space>("", space => Assert.Equal(3, space.Length)),
                           CheckAtom<Table>("", tableCases => {
                             Assert.Equal("array", tableCases.Environment);
+                            // Variant 0 nests a cases env (1 jot spacing + injected
+                            // \textstyle atom per cell); variant 1 a bare array.
                             Assert.Equal(casesInterRowAdditionalSpacing, tableCases.InterRowAdditionalSpacing);
                             Assert.Equal(18, tableCases.InterColumnSpacing);
                             Assert.Equal(2, tableCases.NRows);
                             Assert.Equal(1, tableCases.NColumns);
                             Assert.Equal(ColumnAlignment.Left, tableCases.GetAlignment(0));
-                            Assert.Equal(ColumnAlignment.Center, tableCases.GetAlignment(1));
-                            Assert.Collection(tableCases.Cells[0][0],
-                              CheckAtom<Style>("", style => Assert.Equal(LineStyle.Text, style.LineStyle)),
-                              CheckAtom<Number>("8"));
-                            Assert.Collection(tableCases.Cells[1][0],
-                              CheckAtom<Style>("", style => Assert.Equal(LineStyle.Text, style.LineStyle)),
-                              CheckAtom<Number>("9"));
+                            foreach (var cell in new[] { tableCases.Cells[0][0], tableCases.Cells[1][0] }) {
+                              if (casesInterRowAdditionalSpacing == 1)
+                                Assert.Collection(cell,
+                                  CheckAtom<Style>("", style => Assert.Equal(LineStyle.Text, style.LineStyle)),
+                                  _ => { });
+                              else
+                                Assert.Single(cell);
+                            }
                           })
                         );
                       }),
@@ -833,7 +868,12 @@ public void TestTablesAndInners(string input, float casesInterRowAdditionalSpaci
           CheckAtom<Variable>("c"));
         Assert.Collection(table.Cells[2][0], CheckAtom<Variable>("d"));
       })(Assert.Single(list));
-      Assert.Equal(@"1\\ 2\left( 3\begin{array}{ll}4&\left[ 5\\ 6\right] \\ \left\{ 7\left\{ \, \begin{array}{l}\textstyle 8\\ \textstyle 9\end{array}\right. 0\right\} a\end{array}b\right) c\\ d", LaTeXParser.MathListToLaTeX(list).ToString());
+      // cases re-injects \textstyle per cell; a bare array does not.
+      const string plain = @"1\\ 2\left( 3\begin{array}{ll}4&\left[ 5\\ 6\right] \\ \left\{ 7\left\{ \, \begin{array}{l}8\\ 9\end{array}\right. 0\right\} a\end{array}b\right) c\\ d";
+      const string styled = @"1\\ 2\left( 3\begin{array}{ll}4&\left[ 5\\ 6\right] \\ \left\{ 7\left\{ \, \begin{array}{l}\textstyle 8\\ \textstyle 9\end{array}\right. 0\right\} a\end{array}b\right) c\\ d";
+      Assert.Equal(
+        casesInterRowAdditionalSpacing == 1 ? styled : plain,
+        LaTeXParser.MathListToLaTeX(list).ToString());
     }
 
     [Fact]
@@ -897,7 +937,9 @@ public void TestDisplayLines(string environment, float columnSpacing) {
       var table = Assert.IsType<Table>(Assert.Single(list));
       CheckAtom<Table>("")(table);
       Assert.Equal(environment, table.Environment);
-      Assert.Equal(1, table.InterRowAdditionalSpacing);
+      // array keeps its cells at the surrounding style with no extra row spacing;
+      // displaylines/gather add a jot between rows.
+      Assert.Equal(environment == "array" ? 0 : 1, table.InterRowAdditionalSpacing);
       Assert.Equal(columnSpacing, table.InterColumnSpacing);
       Assert.Equal(2, table.NRows);
       Assert.Equal(1, table.NColumns);
@@ -985,6 +1027,7 @@ public void TestCases() {
               Assert.Equal(1, table.NColumns);
               Assert.All(table.Cells, row =>
                 Assert.Collection(row, cell =>
+                  // cases re-injects a \textstyle atom per cell for the evaluator.
                   Assert.Collection(cell,
                     CheckAtom<Style>("", style => Assert.Equal(LineStyle.Text, style.LineStyle)),
                     CheckAtom<Variable>("y"),
@@ -1024,6 +1067,7 @@ public void TestCases2() {
               Assert.Equal(2, table.NColumns);
               Assert.All(table.Cells, row =>
                 Assert.Collection(row, col0 =>
+                  // cases re-injects a \textstyle atom per cell for the evaluator.
                   Assert.Collection(col0,
                     CheckAtom<Style>("", style => Assert.Equal(LineStyle.Text, style.LineStyle)),
                     CheckAtom<Variable>("y"),
@@ -1092,12 +1136,27 @@ public void TestFont(string inputCommand, bool readsToEnd, FontStyle style, stri
 
       // With braces
       list = ParseLaTeX(readsToEnd ? $@"w{{\{inputCommand} xy}}z" : $@"w\{inputCommand}{{xy}}z");
-      Assert.Collection(list,
-        CheckAtom<Variable>("w", w => Assert.Equal(FontStyle.Default, w.FontStyle)),
-        CheckAtom<Variable>("x", x => Assert.Equal(style, x.FontStyle)),
-        CheckAtom<Variable>("y", y => Assert.Equal(style, y.FontStyle)),
-        CheckAtom<Variable>("z", z => Assert.Equal(FontStyle.Default, z.FontStyle)));
-      Assert.Equal(outputCommand is null ? "wxyz" : $@"w\{outputCommand}{{xy}}z", LaTeXParser.MathListToLaTeX(list).ToString());
+      if (readsToEnd) {
+        // The outer {…} of w{\bf xy}z is a grouping brace: it wraps as a Group.
+        Assert.Collection(list,
+          CheckAtom<Variable>("w", w => Assert.Equal(FontStyle.Default, w.FontStyle)),
+          CheckAtom<Group>("", group => {
+            Assert.Collection(group.InnerList,
+              CheckAtom<Variable>("x", x => Assert.Equal(style, x.FontStyle)),
+              CheckAtom<Variable>("y", y => Assert.Equal(style, y.FontStyle)));
+          }),
+          CheckAtom<Variable>("z", z => Assert.Equal(FontStyle.Default, z.FontStyle)));
+        Assert.Equal(outputCommand is null ? "wxyz" : $@"w{{\{outputCommand}{{xy}}}}z",
+          LaTeXParser.MathListToLaTeX(list).ToString());
+      } else {
+        // \bf{xy}: the brace is the field and flattens; the styled run stays inline.
+        Assert.Collection(list,
+          CheckAtom<Variable>("w", w => Assert.Equal(FontStyle.Default, w.FontStyle)),
+          CheckAtom<Variable>("x", x => Assert.Equal(style, x.FontStyle)),
+          CheckAtom<Variable>("y", y => Assert.Equal(style, y.FontStyle)),
+          CheckAtom<Variable>("z", z => Assert.Equal(FontStyle.Default, z.FontStyle)));
+        Assert.Equal(outputCommand is null ? "wxyz" : $@"w\{outputCommand}{{xy}}z", LaTeXParser.MathListToLaTeX(list).ToString());
+      }
     }
 
     [Theory]
@@ -1560,9 +1619,11 @@ public void TestHelpfulErrorMessage(string input, int index, string expected) {
       InlineData(@"\color{notacolor}{xyz}", @"Error: Invalid color: notacolor
 \color{notacolor}{xyz}
                ↑ (pos 16)"),
-      InlineData(@"\color{red blue}{xyz}", @"Error: Missing }
+      // Upstream REN-2: the whole token is captured, so an embedded space now yields
+      // a clear "Invalid color" error instead of a confusing "Missing }".
+      InlineData(@"\color{red blue}{xyz}", @"Error: Invalid color: red blue
 \color{red blue}{xyz}
-          ↑ (pos 11)"),
+              ↑ (pos 15)"),
       InlineData(@"\left(\begin{matrix}\right)", @"Error: Missing \end{matrix}
 ···(\begin{matrix}\right)
                        ↑ (pos 26)"),
diff --git a/CSharpMath.Core.Tests/Atom/MathAtomTest.cs b/CSharpMath.Core.Tests/Atom/MathAtomTest.cs
index 1581a764..b8d99c2e 100644
--- a/CSharpMath.Core.Tests/Atom/MathAtomTest.cs
+++ b/CSharpMath.Core.Tests/Atom/MathAtomTest.cs
@@ -20,6 +20,8 @@ public void TestAtomInit() {
         .DefinedTypes
         .Where(t => t.Namespace == typeof(Accent).Namespace && t.GetCustomAttributes(
           typeof(System.Runtime.CompilerServices.CompilerGeneratedAttribute), false).Length == 0)
+        // Only atoms themselves; helper value types (e.g. StackConstruction rows) are not MathAtoms.
+        .Where(t => typeof(MathAtom).IsAssignableFrom(t.AsType()))
         .SelectMany(t =>
           new[] { t.GetConstructor(new System.Type[0]), t.GetConstructor(new[] { typeof(string) }) })
         .Where(c => c != null)
diff --git a/CSharpMath.Core.Tests/Editor/PointForIndexTests.cs b/CSharpMath.Core.Tests/Editor/PointForIndexTests.cs
index ef7d5b48..9da82c2c 100644
--- a/CSharpMath.Core.Tests/Editor/PointForIndexTests.cs
+++ b/CSharpMath.Core.Tests/Editor/PointForIndexTests.cs
@@ -93,18 +93,26 @@ public void RadicalDegree(PointF point, MathListIndex expected) =>
       };
     [Theory, MemberData(nameof(ExponentData))]
     public void Exponent(PointF point, MathListIndex expected) => Test("2^3", point, expected);
-    public static TestData ExponentsData =>
-      new TestData {
-        { (0, 0), 0 },
-        { (10, 0), 0, (SubIndex.BetweenBaseAndScripts, 1) },
-        { (10, -4.94), 0, (SubIndex.Subscript, 0) },
-        { (17, -4.94), 0, (SubIndex.Subscript, 1) },
-        { (18.12, 0), 1 },
-        { (28.12, 0), 1, (SubIndex.BetweenBaseAndScripts, 1) },
-        { (28.12, -4.94), 1, (SubIndex.Subscript, 0) },
-        { (35.12, -4.94), 1, (SubIndex.Subscript, 1) },
-        { (35.12, 0), 2 },
-      };
+    public static TestData ExponentsData {
+      get {
+        // {2_3}{3_2}: braces are Ord groups now — the groups render transparently
+        // (their displays are spliced into the parent), but atoms inside a group do
+        // not fuse across the brace boundary, so each glyph carries its own italic
+        // correction and the pen advances by 1.12pt per boundary.
+        var data = new TestData {
+          { (0, 0), 0 },
+          { (10, 0), 0, (SubIndex.BetweenBaseAndScripts, 1) },
+          { (10, -4.94), 0, (SubIndex.Subscript, 0) },
+          { (17, -4.94), 0, (SubIndex.Subscript, 1) },
+          { (17, 0), 1 },
+          { (27, 0), 1, (SubIndex.BetweenBaseAndScripts, 1) },
+          { (27, -4.94), 1, (SubIndex.Subscript, 0) },
+          { (34, -4.94), 1, (SubIndex.Subscript, 1) },
+          { (34, 0), 2 },
+        };
+        return data;
+      }
+    }
     [Theory, MemberData(nameof(ExponentsData))]
     public void Subscripts(PointF point, MathListIndex expected) => Test("{2_3}{3_2}", point, expected);
 
diff --git a/CSharpMath.Evaluation/Evaluation.cs b/CSharpMath.Evaluation/Evaluation.cs
index 7fe4bcdd..1e520519 100644
--- a/CSharpMath.Evaluation/Evaluation.cs
+++ b/CSharpMath.Evaluation/Evaluation.cs
@@ -78,8 +78,46 @@ public IEnumerator<MathItem> GetEnumerator() {
     }
     public static MathList Visualize(MathItem entity) =>
       LaTeXParser.MathListFromLaTeX(entity.Latexise())
-      // CSharpMath must handle all LaTeX coming from AngouriMath or a bug is present!
-      .Match(list => list, e => throw new InvalidCodePathException(e));
+      // AngouriMath's Latexise emits braces around every compound ({\sin x}^{1});
+      // dissolve them so the visual output stays identical to the pre-grouping
+      // parser. Grouping remains available for user-authored LaTeX.
+      .Match(list => DissolveGroups(list.Clone(true)), e => throw new InvalidCodePathException(e));
+
+    /// <summary>Recursively removes Group wrappers: their content is spliced inline.
+    /// Scripts attached to a group are hoisted onto its last inner atom.</summary>
+    static MathList DissolveGroups(MathList list) {
+      var result = new MathList();
+      foreach (var atom in list) {
+        if (atom is Atoms.Group group) {
+          var inner = DissolveGroups(group.InnerList);
+          if ((group.Superscript.IsNonEmpty() || group.Subscript.IsNonEmpty())
+            && inner.LastOrDefault() is { } last && last.ScriptsAllowed) {
+            last.Superscript.Append(DissolveGroups(group.Superscript));
+            last.Subscript.Append(DissolveGroups(group.Subscript));
+          }
+          result.Append(inner);
+        } else {
+          if (atom.Superscript.IsNonEmpty()) {
+            var superscript = DissolveGroups(atom.Superscript);
+            atom.Superscript.Clear();
+            atom.Superscript.Append(superscript);
+          }
+          if (atom.Subscript.IsNonEmpty()) {
+            var subscript = DissolveGroups(atom.Subscript);
+            atom.Subscript.Clear();
+            atom.Subscript.Append(subscript);
+          }
+          if (atom is IMathListContainer container)
+            foreach (var subList in container.InnerLists) {
+              var flattened = DissolveGroups(subList);
+              subList.Clear();
+              subList.Append(flattened);
+            }
+          result.Add(atom);
+        }
+      }
+      return result;
+    }
     public static Result<MathItem> Evaluate(MathList mathList) =>
       Transform(mathList.Clone(true)).Bind(result => result is { } r ? Result.Ok(r) : Result.Err("There is nothing to evaluate"));
     static Result<MathItem?> Transform(MathList mathList) {
@@ -208,6 +246,17 @@ Result HandleSuperscript(ref MathItem? @this, ref int i, MathList superscript) {
         switch (atom) {
           case Atoms.Placeholder _:
             return "Placeholders should be filled";
+          // A brace group is an Ord subformula: evaluate its content in place and
+          // splice the result so grouping stays transparent (iosMath 086d345).
+          case Atoms.Group group: {
+              var innerList = new MathList(group.InnerList.Select(a => a.Clone(true)));
+              int j = 0;
+              var (groupResult, groupError) = Transform(innerList, ref j, prec).Bind(r => r is { } item ? Result.Ok(item) : Result.Err("Empty group"));
+              if (groupError != null) return groupError;
+              @this = groupResult;
+              subscriptAllowed = true;
+              goto handleThis;
+            }
           case Atoms.Number { Subscript: [Atoms.Number numericBase] } n:
             if (int.TryParse(numericBase.Nucleus, out var @base)) {
               try { @this = MathS.FromBaseN(atom.Nucleus, @base); } catch (Exception e) { return e.Message; }
diff --git a/CSharpMath.Rendering.Tests/MathDisplay/Abs.png b/CSharpMath.Rendering.Tests/MathDisplay/Abs.png
index f3369c8c..30673f8c 100644
Binary files a/CSharpMath.Rendering.Tests/MathDisplay/Abs.png and b/CSharpMath.Rendering.Tests/MathDisplay/Abs.png differ
diff --git a/CSharpMath.Rendering.Tests/MathDisplay/AccentOverF.png b/CSharpMath.Rendering.Tests/MathDisplay/AccentOverF.png
index bf745462..bfc5623d 100644
Binary files a/CSharpMath.Rendering.Tests/MathDisplay/AccentOverF.png and b/CSharpMath.Rendering.Tests/MathDisplay/AccentOverF.png differ
diff --git a/CSharpMath.Rendering.Tests/MathDisplay/Alphabets.png b/CSharpMath.Rendering.Tests/MathDisplay/Alphabets.png
index 559fcd5b..d477f66f 100644
Binary files a/CSharpMath.Rendering.Tests/MathDisplay/Alphabets.png and b/CSharpMath.Rendering.Tests/MathDisplay/Alphabets.png differ
diff --git a/CSharpMath.Rendering.Tests/MathDisplay/Capitals.png b/CSharpMath.Rendering.Tests/MathDisplay/Capitals.png
index a997d2ce..3dc8ffdf 100644
Binary files a/CSharpMath.Rendering.Tests/MathDisplay/Capitals.png and b/CSharpMath.Rendering.Tests/MathDisplay/Capitals.png differ
diff --git a/CSharpMath.Rendering.Tests/MathDisplay/Cases.png b/CSharpMath.Rendering.Tests/MathDisplay/Cases.png
index e102fabf..3a5a78bb 100644
Binary files a/CSharpMath.Rendering.Tests/MathDisplay/Cases.png and b/CSharpMath.Rendering.Tests/MathDisplay/Cases.png differ
diff --git a/CSharpMath.Rendering.Tests/MathDisplay/Color.png b/CSharpMath.Rendering.Tests/MathDisplay/Color.png
index 3518e3ae..95f37d83 100644
Binary files a/CSharpMath.Rendering.Tests/MathDisplay/Color.png and b/CSharpMath.Rendering.Tests/MathDisplay/Color.png differ
diff --git a/CSharpMath.Rendering.Tests/MathDisplay/FontStyles.png b/CSharpMath.Rendering.Tests/MathDisplay/FontStyles.png
index 52c21c76..230818fb 100644
Binary files a/CSharpMath.Rendering.Tests/MathDisplay/FontStyles.png and b/CSharpMath.Rendering.Tests/MathDisplay/FontStyles.png differ
diff --git a/CSharpMath.Rendering.Tests/MathDisplay/ItalicAlignment.png b/CSharpMath.Rendering.Tests/MathDisplay/ItalicAlignment.png
index d156e23f..050af7e4 100644
Binary files a/CSharpMath.Rendering.Tests/MathDisplay/ItalicAlignment.png and b/CSharpMath.Rendering.Tests/MathDisplay/ItalicAlignment.png differ
diff --git a/CSharpMath.Rendering.Tests/MathDisplay/ItalicCorrectionStyles.png b/CSharpMath.Rendering.Tests/MathDisplay/ItalicCorrectionStyles.png
new file mode 100644
index 00000000..fb1717f2
Binary files /dev/null and b/CSharpMath.Rendering.Tests/MathDisplay/ItalicCorrectionStyles.png differ
diff --git a/CSharpMath.Rendering.Tests/MathDisplay/ItalicScripts.png b/CSharpMath.Rendering.Tests/MathDisplay/ItalicScripts.png
index 1fb163bf..79e8ad69 100644
Binary files a/CSharpMath.Rendering.Tests/MathDisplay/ItalicScripts.png and b/CSharpMath.Rendering.Tests/MathDisplay/ItalicScripts.png differ
diff --git a/CSharpMath.Rendering.Tests/MathDisplay/LnEquation.png b/CSharpMath.Rendering.Tests/MathDisplay/LnEquation.png
index ea8e9b23..15e73c0f 100644
Binary files a/CSharpMath.Rendering.Tests/MathDisplay/LnEquation.png and b/CSharpMath.Rendering.Tests/MathDisplay/LnEquation.png differ
diff --git a/CSharpMath.Rendering.Tests/MathDisplay/Logic.png b/CSharpMath.Rendering.Tests/MathDisplay/Logic.png
index f4947c8c..04a01748 100644
Binary files a/CSharpMath.Rendering.Tests/MathDisplay/Logic.png and b/CSharpMath.Rendering.Tests/MathDisplay/Logic.png differ
diff --git a/CSharpMath.Rendering.Tests/MathDisplay/RuledArrayAlignment.png b/CSharpMath.Rendering.Tests/MathDisplay/RuledArrayAlignment.png
new file mode 100644
index 00000000..acb4a5d8
Binary files /dev/null and b/CSharpMath.Rendering.Tests/MathDisplay/RuledArrayAlignment.png differ
diff --git a/CSharpMath.Rendering.Tests/MathDisplay/SimpleShortProof.png b/CSharpMath.Rendering.Tests/MathDisplay/SimpleShortProof.png
index eefae493..1ad370b9 100644
Binary files a/CSharpMath.Rendering.Tests/MathDisplay/SimpleShortProof.png and b/CSharpMath.Rendering.Tests/MathDisplay/SimpleShortProof.png differ
diff --git a/CSharpMath.Rendering.Tests/MathDisplay/SolveEquations.png b/CSharpMath.Rendering.Tests/MathDisplay/SolveEquations.png
index 37fba337..9f070b51 100644
Binary files a/CSharpMath.Rendering.Tests/MathDisplay/SolveEquations.png and b/CSharpMath.Rendering.Tests/MathDisplay/SolveEquations.png differ
diff --git a/CSharpMath.Rendering.Tests/MathDisplay/Underbrace.png b/CSharpMath.Rendering.Tests/MathDisplay/Underbrace.png
index f350c84d..c401cd96 100644
Binary files a/CSharpMath.Rendering.Tests/MathDisplay/Underbrace.png and b/CSharpMath.Rendering.Tests/MathDisplay/Underbrace.png differ
diff --git a/CSharpMath.Rendering.Tests/MathInline/Abs.png b/CSharpMath.Rendering.Tests/MathInline/Abs.png
index f3369c8c..30673f8c 100644
Binary files a/CSharpMath.Rendering.Tests/MathInline/Abs.png and b/CSharpMath.Rendering.Tests/MathInline/Abs.png differ
diff --git a/CSharpMath.Rendering.Tests/MathInline/AccentOverF.png b/CSharpMath.Rendering.Tests/MathInline/AccentOverF.png
index bf745462..bfc5623d 100644
Binary files a/CSharpMath.Rendering.Tests/MathInline/AccentOverF.png and b/CSharpMath.Rendering.Tests/MathInline/AccentOverF.png differ
diff --git a/CSharpMath.Rendering.Tests/MathInline/Alphabets.png b/CSharpMath.Rendering.Tests/MathInline/Alphabets.png
index 559fcd5b..d477f66f 100644
Binary files a/CSharpMath.Rendering.Tests/MathInline/Alphabets.png and b/CSharpMath.Rendering.Tests/MathInline/Alphabets.png differ
diff --git a/CSharpMath.Rendering.Tests/MathInline/Capitals.png b/CSharpMath.Rendering.Tests/MathInline/Capitals.png
index a997d2ce..3dc8ffdf 100644
Binary files a/CSharpMath.Rendering.Tests/MathInline/Capitals.png and b/CSharpMath.Rendering.Tests/MathInline/Capitals.png differ
diff --git a/CSharpMath.Rendering.Tests/MathInline/Cases.png b/CSharpMath.Rendering.Tests/MathInline/Cases.png
index e102fabf..3a5a78bb 100644
Binary files a/CSharpMath.Rendering.Tests/MathInline/Cases.png and b/CSharpMath.Rendering.Tests/MathInline/Cases.png differ
diff --git a/CSharpMath.Rendering.Tests/MathInline/Color.png b/CSharpMath.Rendering.Tests/MathInline/Color.png
index 3518e3ae..95f37d83 100644
Binary files a/CSharpMath.Rendering.Tests/MathInline/Color.png and b/CSharpMath.Rendering.Tests/MathInline/Color.png differ
diff --git a/CSharpMath.Rendering.Tests/MathInline/FontStyles.png b/CSharpMath.Rendering.Tests/MathInline/FontStyles.png
index 52c21c76..230818fb 100644
Binary files a/CSharpMath.Rendering.Tests/MathInline/FontStyles.png and b/CSharpMath.Rendering.Tests/MathInline/FontStyles.png differ
diff --git a/CSharpMath.Rendering.Tests/MathInline/ItalicAlignment.png b/CSharpMath.Rendering.Tests/MathInline/ItalicAlignment.png
index d156e23f..050af7e4 100644
Binary files a/CSharpMath.Rendering.Tests/MathInline/ItalicAlignment.png and b/CSharpMath.Rendering.Tests/MathInline/ItalicAlignment.png differ
diff --git a/CSharpMath.Rendering.Tests/MathInline/ItalicCorrectionStyles.png b/CSharpMath.Rendering.Tests/MathInline/ItalicCorrectionStyles.png
new file mode 100644
index 00000000..fb1717f2
Binary files /dev/null and b/CSharpMath.Rendering.Tests/MathInline/ItalicCorrectionStyles.png differ
diff --git a/CSharpMath.Rendering.Tests/MathInline/ItalicScripts.png b/CSharpMath.Rendering.Tests/MathInline/ItalicScripts.png
index 1fb163bf..79e8ad69 100644
Binary files a/CSharpMath.Rendering.Tests/MathInline/ItalicScripts.png and b/CSharpMath.Rendering.Tests/MathInline/ItalicScripts.png differ
diff --git a/CSharpMath.Rendering.Tests/MathInline/LnEquation.png b/CSharpMath.Rendering.Tests/MathInline/LnEquation.png
index d3a18e29..cadfe0f2 100644
Binary files a/CSharpMath.Rendering.Tests/MathInline/LnEquation.png and b/CSharpMath.Rendering.Tests/MathInline/LnEquation.png differ
diff --git a/CSharpMath.Rendering.Tests/MathInline/Logic.png b/CSharpMath.Rendering.Tests/MathInline/Logic.png
index f4947c8c..04a01748 100644
Binary files a/CSharpMath.Rendering.Tests/MathInline/Logic.png and b/CSharpMath.Rendering.Tests/MathInline/Logic.png differ
diff --git a/CSharpMath.Rendering.Tests/MathInline/RuledArrayAlignment.png b/CSharpMath.Rendering.Tests/MathInline/RuledArrayAlignment.png
new file mode 100644
index 00000000..acb4a5d8
Binary files /dev/null and b/CSharpMath.Rendering.Tests/MathInline/RuledArrayAlignment.png differ
diff --git a/CSharpMath.Rendering.Tests/MathInline/SimpleShortProof.png b/CSharpMath.Rendering.Tests/MathInline/SimpleShortProof.png
index eefae493..1ad370b9 100644
Binary files a/CSharpMath.Rendering.Tests/MathInline/SimpleShortProof.png and b/CSharpMath.Rendering.Tests/MathInline/SimpleShortProof.png differ
diff --git a/CSharpMath.Rendering.Tests/MathInline/SolveEquations.png b/CSharpMath.Rendering.Tests/MathInline/SolveEquations.png
index 37fba337..9f070b51 100644
Binary files a/CSharpMath.Rendering.Tests/MathInline/SolveEquations.png and b/CSharpMath.Rendering.Tests/MathInline/SolveEquations.png differ
diff --git a/CSharpMath.Rendering.Tests/MathInline/Underbrace.png b/CSharpMath.Rendering.Tests/MathInline/Underbrace.png
index f350c84d..c401cd96 100644
Binary files a/CSharpMath.Rendering.Tests/MathInline/Underbrace.png and b/CSharpMath.Rendering.Tests/MathInline/Underbrace.png differ
diff --git a/CSharpMath.Rendering.Tests/TestMeasure.cs b/CSharpMath.Rendering.Tests/TestMeasure.cs
index b6a741e6..69500b61 100644
--- a/CSharpMath.Rendering.Tests/TestMeasure.cs
+++ b/CSharpMath.Rendering.Tests/TestMeasure.cs
@@ -57,5 +57,89 @@ public void RenderingMeasure_YIsNegAscent() {
       Assert.Equal(new RectangleF(0, -12, 10, 15), new DRenderingText().Measure(float.NaN));
       Assert.Equal(new RectangleF(0, -12, 10, 15), new DRenderingKeyboard().Measure);
     }
+
+    [Fact]
+    public void RenderingMeasure_IncludesTrailingGlyphInk() {
+      var painter = new SkiaSharp.MathPainter { LaTeX = "V" };
+      painter.Measure();
+      var display = painter.Display;
+      Assert.NotNull(display);
+      Assert.True(display.InkWidth() > display.Width);
+      Assert.True(painter.Measure().Width >= display.InkWidth());
+    }
+
+    [Fact]
+    public void AlignmentUsesInkExtentWithoutChangingAdvance() {
+      var painter = new SkiaSharp.MathPainter { LaTeX = "V" };
+      painter.Measure();
+      var display = painter.Display;
+      Assert.NotNull(display);
+      var centered = FrontEnd.IPainterExtensions.GetDisplayPosition(
+        display.InkWidth(), display.Ascent, display.Descent, painter.FontSize,
+        100, 100, FrontEnd.TextAlignment.Center, default, 0, 0);
+      var expected = (100 - display.InkWidth()) / 2;
+      Assert.Equal(expected, centered.X, precision: 4);
+      Assert.True(display.Width < display.InkWidth());
+    }
+
+    [Theory]
+    [InlineData(@"\frac{P}{2}")]
+    [InlineData(@"\sqrt{P}")]
+    [InlineData(@"\hat{P}")]
+    [InlineData(@"\sum_{P}^{2}")]
+    [InlineData(@"\overset{P}{2}")]
+    [InlineData(@"\left(P\right)")]
+    [InlineData(@"\text{P}")]
+    public void CompositeInkIsRecursivelyAtLeastAdvance(string latex) {
+      var painter = new SkiaSharp.MathPainter { LaTeX = latex };
+      painter.Measure();
+      var display = painter.Display;
+      Assert.NotNull(display);
+      var advance = display.Width;
+      Assert.True(display.InkWidth() >= advance);
+      Assert.Equal(advance, display.Width);
+    }
+
+    [Theory]
+    [InlineData(@"\llap{P}")]
+    [InlineData(@"\clap{P}")]
+    public void LapBoxInkIsAvailableBeforeDraw(string latex) {
+      var painter = new SkiaSharp.MathPainter { LaTeX = latex };
+      painter.Measure();
+      var display = painter.Display;
+      Assert.NotNull(display);
+      var advance = display.Width;
+      Assert.True(display.InkWidth() > 0);
+      Assert.Equal(advance, display.Width); // advance remains the box metric
+    }
+
+    [Fact]
+    public void TrailingSuperscriptInkDoesNotChangeAdvance() {
+      var painter = new SkiaSharp.MathPainter { LaTeX = "P^P" };
+      painter.Measure();
+      var display = painter.Display;
+      Assert.NotNull(display);
+      var advance = display.Width;
+      Assert.True(display.InkWidth() >= advance);
+      Assert.Equal(advance, display.Width);
+    }
+
+    [Theory]
+    [InlineData(FrontEnd.TextAlignment.Center)]
+    [InlineData(FrontEnd.TextAlignment.Right)]
+    public void FiniteCanvasAlignmentUsesInkWidth(FrontEnd.TextAlignment alignment) {
+      var painter = new SkiaSharp.MathPainter { LaTeX = "P" };
+      painter.Measure();
+      var display = painter.Display;
+      Assert.NotNull(display);
+      var x = FrontEnd.IPainterExtensions.GetDisplayPosition(
+        display.InkWidth(), display.Ascent, display.Descent, painter.FontSize,
+        100, 100, alignment, default, 0, 0).X;
+      var expected = alignment == FrontEnd.TextAlignment.Right
+        ? 100 - display.InkWidth()
+        : (100 - display.InkWidth()) / 2;
+      Assert.Equal(expected, x, precision: 4);
+      Assert.True(display.Width < display.InkWidth());
+    }
   }
-}
\ No newline at end of file
+}
diff --git a/CSharpMath.Rendering.Tests/TestRenderingMathData.cs b/CSharpMath.Rendering.Tests/TestRenderingMathData.cs
index 569e546e..aaf4f9ed 100644
--- a/CSharpMath.Rendering.Tests/TestRenderingMathData.cs
+++ b/CSharpMath.Rendering.Tests/TestRenderingMathData.cs
@@ -38,6 +38,12 @@ public sealed class TestRenderingMathData : TestRenderingSharedData<TestRenderin
     public const string IntegralScripts = @"\int\int\int^{\infty}\int_0\int^{\infty}_0\int";
     public const string ItalicAlignment = @"\colorbox{yellow}P\\\begin{array}{r}\colorbox{yellow}{PF}\\\colorbox{yellow}F\end{array}";
     public const string ItalicScripts = @"U_3^2UY_3^2U_3Y^2f_1f^2ff";
+    // iosMath c9afaad: the correction of a script base must come from the face that
+    // drew its nucleus; \mathit digits keep their upright face, so 1^2 must not shift.
+    public const string ItalicCorrectionStyles = @"1\mathit{2}^3 x_\ell \mathrm{P}^2 \mathbf{f}_1";
+    // Ruled arrays must honour the column alignment spec: cells sit at shared
+    // offsets, then r/c/l shifts are applied within the full column width.
+    public const string RuledArrayAlignment = @"\begin{array}{|r|c|} 1 & 2 \\ 1000 & x \end{array}";
 
     public const string KetSum = @"\frac{1}{\sqrt{2^n}} \sum_{i=0}^{2^n-1} \Ket{i}";
 
diff --git a/CSharpMath.Rendering.Tests/TextCenter/DisplayMath.png b/CSharpMath.Rendering.Tests/TextCenter/DisplayMath.png
index 4b4c8826..da242bca 100644
Binary files a/CSharpMath.Rendering.Tests/TextCenter/DisplayMath.png and b/CSharpMath.Rendering.Tests/TextCenter/DisplayMath.png differ
diff --git a/CSharpMath.Rendering.Tests/TextCenter/FontStyles.png b/CSharpMath.Rendering.Tests/TextCenter/FontStyles.png
index 56dbb5b9..e9b61b58 100644
Binary files a/CSharpMath.Rendering.Tests/TextCenter/FontStyles.png and b/CSharpMath.Rendering.Tests/TextCenter/FontStyles.png differ
diff --git a/CSharpMath.Rendering.Tests/TextCenter/IntegrationByParts.png b/CSharpMath.Rendering.Tests/TextCenter/IntegrationByParts.png
index 73d4b270..bffba7aa 100644
Binary files a/CSharpMath.Rendering.Tests/TextCenter/IntegrationByParts.png and b/CSharpMath.Rendering.Tests/TextCenter/IntegrationByParts.png differ
diff --git a/CSharpMath.Rendering.Tests/TextCenter/WideDisplayMaths.png b/CSharpMath.Rendering.Tests/TextCenter/WideDisplayMaths.png
index d0cb9f91..51dc133b 100644
Binary files a/CSharpMath.Rendering.Tests/TextCenter/WideDisplayMaths.png and b/CSharpMath.Rendering.Tests/TextCenter/WideDisplayMaths.png differ
diff --git a/CSharpMath.Rendering.Tests/TextCenterInfiniteWidth/FontStyles.png b/CSharpMath.Rendering.Tests/TextCenterInfiniteWidth/FontStyles.png
index 56dbb5b9..e9b61b58 100644
Binary files a/CSharpMath.Rendering.Tests/TextCenterInfiniteWidth/FontStyles.png and b/CSharpMath.Rendering.Tests/TextCenterInfiniteWidth/FontStyles.png differ
diff --git a/CSharpMath.Rendering.Tests/TextCenterInfiniteWidth/IntegrationByParts.png b/CSharpMath.Rendering.Tests/TextCenterInfiniteWidth/IntegrationByParts.png
index 61fe8c47..04fc6e7f 100644
Binary files a/CSharpMath.Rendering.Tests/TextCenterInfiniteWidth/IntegrationByParts.png and b/CSharpMath.Rendering.Tests/TextCenterInfiniteWidth/IntegrationByParts.png differ
diff --git a/CSharpMath.Rendering.Tests/TextLeft/DisplayMath.png b/CSharpMath.Rendering.Tests/TextLeft/DisplayMath.png
index 4b4c8826..da242bca 100644
Binary files a/CSharpMath.Rendering.Tests/TextLeft/DisplayMath.png and b/CSharpMath.Rendering.Tests/TextLeft/DisplayMath.png differ
diff --git a/CSharpMath.Rendering.Tests/TextLeft/FontStyles.png b/CSharpMath.Rendering.Tests/TextLeft/FontStyles.png
index 961cce8c..7b4a3f81 100644
Binary files a/CSharpMath.Rendering.Tests/TextLeft/FontStyles.png and b/CSharpMath.Rendering.Tests/TextLeft/FontStyles.png differ
diff --git a/CSharpMath.Rendering.Tests/TextLeft/IntegrationByParts.png b/CSharpMath.Rendering.Tests/TextLeft/IntegrationByParts.png
index cf4a67d8..91c3a05a 100644
Binary files a/CSharpMath.Rendering.Tests/TextLeft/IntegrationByParts.png and b/CSharpMath.Rendering.Tests/TextLeft/IntegrationByParts.png differ
diff --git a/CSharpMath.Rendering.Tests/TextLeft/WideDisplayMaths.png b/CSharpMath.Rendering.Tests/TextLeft/WideDisplayMaths.png
index b1cd7d5e..e45c829b 100644
Binary files a/CSharpMath.Rendering.Tests/TextLeft/WideDisplayMaths.png and b/CSharpMath.Rendering.Tests/TextLeft/WideDisplayMaths.png differ
diff --git a/CSharpMath.Rendering.Tests/TextLeftInfiniteWidth/FontStyles.png b/CSharpMath.Rendering.Tests/TextLeftInfiniteWidth/FontStyles.png
index 961cce8c..7b4a3f81 100644
Binary files a/CSharpMath.Rendering.Tests/TextLeftInfiniteWidth/FontStyles.png and b/CSharpMath.Rendering.Tests/TextLeftInfiniteWidth/FontStyles.png differ
diff --git a/CSharpMath.Rendering.Tests/TextLeftInfiniteWidth/IntegrationByParts.png b/CSharpMath.Rendering.Tests/TextLeftInfiniteWidth/IntegrationByParts.png
index e5068285..f86b39c5 100644
Binary files a/CSharpMath.Rendering.Tests/TextLeftInfiniteWidth/IntegrationByParts.png and b/CSharpMath.Rendering.Tests/TextLeftInfiniteWidth/IntegrationByParts.png differ
diff --git a/CSharpMath.Rendering.Tests/TextPainterSettings/Baseline.png b/CSharpMath.Rendering.Tests/TextPainterSettings/Baseline.png
index 9fdcf5d7..4537eaea 100644
Binary files a/CSharpMath.Rendering.Tests/TextPainterSettings/Baseline.png and b/CSharpMath.Rendering.Tests/TextPainterSettings/Baseline.png differ
diff --git a/CSharpMath.Rendering.Tests/TextPainterSettings/GlyphBoxColor.png b/CSharpMath.Rendering.Tests/TextPainterSettings/GlyphBoxColor.png
index 766306cb..552f8e1e 100644
Binary files a/CSharpMath.Rendering.Tests/TextPainterSettings/GlyphBoxColor.png and b/CSharpMath.Rendering.Tests/TextPainterSettings/GlyphBoxColor.png differ
diff --git a/CSharpMath.Rendering.Tests/TextPainterSettings/Magnification.png b/CSharpMath.Rendering.Tests/TextPainterSettings/Magnification.png
index ce3bf8ee..46757ad7 100644
Binary files a/CSharpMath.Rendering.Tests/TextPainterSettings/Magnification.png and b/CSharpMath.Rendering.Tests/TextPainterSettings/Magnification.png differ
diff --git a/CSharpMath.Rendering.Tests/TextPainterSettings/ScriptLineStyle.png b/CSharpMath.Rendering.Tests/TextPainterSettings/ScriptLineStyle.png
index 9fdcf5d7..4537eaea 100644
Binary files a/CSharpMath.Rendering.Tests/TextPainterSettings/ScriptLineStyle.png and b/CSharpMath.Rendering.Tests/TextPainterSettings/ScriptLineStyle.png differ
diff --git a/CSharpMath.Rendering.Tests/TextPainterSettings/ScriptScriptLineStyle.png b/CSharpMath.Rendering.Tests/TextPainterSettings/ScriptScriptLineStyle.png
index 9fdcf5d7..4537eaea 100644
Binary files a/CSharpMath.Rendering.Tests/TextPainterSettings/ScriptScriptLineStyle.png and b/CSharpMath.Rendering.Tests/TextPainterSettings/ScriptScriptLineStyle.png differ
diff --git a/CSharpMath.Rendering.Tests/TextPainterSettings/Stroke.png b/CSharpMath.Rendering.Tests/TextPainterSettings/Stroke.png
index abcee642..25c3a4cb 100644
Binary files a/CSharpMath.Rendering.Tests/TextPainterSettings/Stroke.png and b/CSharpMath.Rendering.Tests/TextPainterSettings/Stroke.png differ
diff --git a/CSharpMath.Rendering.Tests/TextPainterSettings/TextColor.png b/CSharpMath.Rendering.Tests/TextPainterSettings/TextColor.png
index 79cf5b6a..50b03603 100644
Binary files a/CSharpMath.Rendering.Tests/TextPainterSettings/TextColor.png and b/CSharpMath.Rendering.Tests/TextPainterSettings/TextColor.png differ
diff --git a/CSharpMath.Rendering.Tests/TextPainterSettings/TextLineStyle.png b/CSharpMath.Rendering.Tests/TextPainterSettings/TextLineStyle.png
index 9fdcf5d7..4537eaea 100644
Binary files a/CSharpMath.Rendering.Tests/TextPainterSettings/TextLineStyle.png and b/CSharpMath.Rendering.Tests/TextPainterSettings/TextLineStyle.png differ
diff --git a/CSharpMath.Rendering.Tests/TextRight/DisplayMath.png b/CSharpMath.Rendering.Tests/TextRight/DisplayMath.png
index 4b4c8826..da242bca 100644
Binary files a/CSharpMath.Rendering.Tests/TextRight/DisplayMath.png and b/CSharpMath.Rendering.Tests/TextRight/DisplayMath.png differ
diff --git a/CSharpMath.Rendering.Tests/TextRight/FontStyles.png b/CSharpMath.Rendering.Tests/TextRight/FontStyles.png
index 961cce8c..7b4a3f81 100644
Binary files a/CSharpMath.Rendering.Tests/TextRight/FontStyles.png and b/CSharpMath.Rendering.Tests/TextRight/FontStyles.png differ
diff --git a/CSharpMath.Rendering.Tests/TextRight/IntegrationByParts.png b/CSharpMath.Rendering.Tests/TextRight/IntegrationByParts.png
index 7cd82d7d..73b7022a 100644
Binary files a/CSharpMath.Rendering.Tests/TextRight/IntegrationByParts.png and b/CSharpMath.Rendering.Tests/TextRight/IntegrationByParts.png differ
diff --git a/CSharpMath.Rendering.Tests/TextRight/WideDisplayMaths.png b/CSharpMath.Rendering.Tests/TextRight/WideDisplayMaths.png
index 20f3de93..e9100a27 100644
Binary files a/CSharpMath.Rendering.Tests/TextRight/WideDisplayMaths.png and b/CSharpMath.Rendering.Tests/TextRight/WideDisplayMaths.png differ
diff --git a/CSharpMath.Rendering.Tests/TextRightInfiniteWidth/FontStyles.png b/CSharpMath.Rendering.Tests/TextRightInfiniteWidth/FontStyles.png
index 961cce8c..7b4a3f81 100644
Binary files a/CSharpMath.Rendering.Tests/TextRightInfiniteWidth/FontStyles.png and b/CSharpMath.Rendering.Tests/TextRightInfiniteWidth/FontStyles.png differ
diff --git a/CSharpMath.Rendering.Tests/TextRightInfiniteWidth/IntegrationByParts.png b/CSharpMath.Rendering.Tests/TextRightInfiniteWidth/IntegrationByParts.png
index c7b297cc..38437491 100644
Binary files a/CSharpMath.Rendering.Tests/TextRightInfiniteWidth/IntegrationByParts.png and b/CSharpMath.Rendering.Tests/TextRightInfiniteWidth/IntegrationByParts.png differ
diff --git a/CSharpMath.Rendering.Tests/TextRightInfiniteWidth/WideDisplayMaths.png b/CSharpMath.Rendering.Tests/TextRightInfiniteWidth/WideDisplayMaths.png
index 20f3de93..63db0063 100644
Binary files a/CSharpMath.Rendering.Tests/TextRightInfiniteWidth/WideDisplayMaths.png and b/CSharpMath.Rendering.Tests/TextRightInfiniteWidth/WideDisplayMaths.png differ
diff --git a/CSharpMath.Rendering/BackEnd/Fonts.cs b/CSharpMath.Rendering/BackEnd/Fonts.cs
index 40dffef7..795ef463 100644
--- a/CSharpMath.Rendering/BackEnd/Fonts.cs
+++ b/CSharpMath.Rendering/BackEnd/Fonts.cs
@@ -1,11 +1,12 @@
 using System.Collections;
 using System.Collections.Generic;
+using System.Drawing;
 using System.Linq;
 using Typography.OpenFont;
 using Typography.OpenFont.Extensions;
 
 namespace CSharpMath.Rendering.BackEnd {
-  public class Fonts : Display.FrontEnd.IFont<Glyph>, IEnumerable<Typeface> {
+  public class Fonts : Display.FrontEnd.IFont<Glyph>, Display.FrontEnd.IFontGlyphBounds<Glyph>, IEnumerable<Typeface> {
     static Typefaces GetGlobalTypefaces() {
       var reader = new OpenFontReader();
       Typeface LoadFont(string fileName) {
@@ -33,7 +34,15 @@ public Fonts(IEnumerable<Typeface> localTypefaces, float pointSize) {
     public IEnumerable<Typeface> Typefaces { get; }
     public Typeface MathTypeface { get; }
     public Typography.OpenFont.MathGlyphs.MathConstants MathConsts { get; }
+    public IEnumerable<RectangleF> GetBoundingRects(IEnumerable<Glyph> glyphs) {
+      var glyphList = glyphs as IReadOnlyCollection<Glyph> ?? glyphs.ToList();
+      return GlyphBoundsProvider.Instance.GetBoundingRectsForGlyphs(this, glyphList, glyphList.Count);
+    }
+    public IEnumerable<float> GetAdvances(IEnumerable<Glyph> glyphs) {
+      var glyphList = glyphs as IReadOnlyCollection<Glyph> ?? glyphs.ToList();
+      return GlyphBoundsProvider.Instance.GetAdvancesForGlyphs(this, glyphList, glyphList.Count).Advances;
+    }
     public IEnumerator<Typeface> GetEnumerator() => Typefaces.GetEnumerator();
     IEnumerator IEnumerable.GetEnumerator() => Typefaces.GetEnumerator();
   }
-}
\ No newline at end of file
+}
diff --git a/CSharpMath.Rendering/BackEnd/MathTable.cs b/CSharpMath.Rendering/BackEnd/MathTable.cs
index 595c2913..ca35ac47 100644
--- a/CSharpMath.Rendering/BackEnd/MathTable.cs
+++ b/CSharpMath.Rendering/BackEnd/MathTable.cs
@@ -99,6 +99,10 @@ public override float MinConnectorOverlap(Fonts fonts) =>
     public override float SuperscriptShiftUpCramped(Fonts fonts) => ReadRecord(fonts.MathConsts.SuperscriptShiftUpCramped, fonts);
     public override float UpperLimitBaselineRiseMin(Fonts fonts) => ReadRecord(fonts.MathConsts.UpperLimitBaselineRiseMin, fonts);
     public override float UpperLimitGapMin(Fonts fonts) => ReadRecord(fonts.MathConsts.UpperLimitGapMin, fonts);
+    public override float StretchStackTopShiftUp(Fonts fonts) => ReadRecord(fonts.MathConsts.StretchStackTopShiftUp, fonts);
+    public override float StretchStackBottomShiftDown(Fonts fonts) => ReadRecord(fonts.MathConsts.StretchStackBottomShiftDown, fonts);
+    public override float StretchStackGapAboveMin(Fonts fonts) => ReadRecord(fonts.MathConsts.StretchStackGapAboveMin, fonts);
+    public override float StretchStackGapBelowMin(Fonts fonts) => ReadRecord(fonts.MathConsts.StretchStackGapBelowMin, fonts);
     public override float UnderbarVerticalGap(Fonts fonts) => ReadRecord(fonts.MathConsts.UnderbarVerticalGap, fonts);
     public override float AccentBaseHeight(Fonts fonts) => ReadRecord(fonts.MathConsts.AccentBaseHeight, fonts);
     public override float GetTopAccentAdjustment(Fonts fonts, Glyph glyph) =>
diff --git a/CSharpMath.Rendering/FrontEnd/MathPainter.cs b/CSharpMath.Rendering/FrontEnd/MathPainter.cs
index 4f33f970..d47bebe7 100644
--- a/CSharpMath.Rendering/FrontEnd/MathPainter.cs
+++ b/CSharpMath.Rendering/FrontEnd/MathPainter.cs
@@ -25,7 +25,7 @@ protected override void UpdateDisplayCore(float unused) {
     public override void Draw(TCanvas canvas, TextAlignment alignment = TextAlignment.Center, Thickness padding = default, float offsetX = 0, float offsetY = 0) {
       var c = WrapCanvas(canvas);
       UpdateDisplay(float.NaN);
-      DrawCore(c, Display, Display == null ? new PointF?() : IPainterExtensions.GetDisplayPosition(Display.Width, Display.Ascent, Display.Descent, FontSize, c.Width, c.Height, alignment, padding, offsetX, offsetY));
+      DrawCore(c, Display, Display == null ? new PointF?() : IPainterExtensions.GetDisplayPosition(Display.InkWidth(), Display.Ascent, Display.Descent, FontSize, c.Width, c.Height, alignment, padding, offsetX, offsetY));
     }
     public void Draw(TCanvas canvas, float x, float y) {
       var c = WrapCanvas(canvas);
@@ -56,4 +56,4 @@ public void DrawDisplay(IDisplay<Fonts, Glyph>? display, TCanvas canvas,
     }
     public new MathPainter<TCanvas, TColor> ShallowClone() => (MathPainter<TCanvas, TColor>)MemberwiseClone();
   }
-}
\ No newline at end of file
+}
diff --git a/CSharpMath.Rendering/FrontEnd/Painter.cs b/CSharpMath.Rendering/FrontEnd/Painter.cs
index 02acaa6f..d8fcf1d3 100644
--- a/CSharpMath.Rendering/FrontEnd/Painter.cs
+++ b/CSharpMath.Rendering/FrontEnd/Painter.cs
@@ -63,7 +63,9 @@ public Painter() {
     public virtual RectangleF Measure(float textPainterCanvasWidth) {
       UpdateDisplay(textPainterCanvasWidth);
       if (Display != null)
-        return new RectangleF(0, -Display.Ascent, Display.Width, Display.Ascent + Display.Descent);
+        // ICanvas exposes no device/backing scale, so pixel-grid rounding from
+        // iosMath's UIView/NSView implementation is intentionally not applicable here.
+        return new RectangleF(0, -Display.Ascent, Display.InkWidth(), Display.Ascent + Display.Descent);
       else return RectangleF.Empty;
     }
     protected abstract void UpdateDisplayCore(float textPainterCanvasWidth);
@@ -132,4 +134,4 @@ GlyphBoxColor is var (glyph, textRun) ? Nullable((WrapColor(glyph), WrapColor(te
     public Painter<TCanvas, TContent, TColor> ShallowClone() => (Painter<TCanvas, TContent, TColor>)MemberwiseClone();
     #endregion Methods
   }
-}
\ No newline at end of file
+}
diff --git a/CSharpMath.Rendering/FrontEnd/TextPainter.cs b/CSharpMath.Rendering/FrontEnd/TextPainter.cs
index 91e4164f..84d9bea7 100644
--- a/CSharpMath.Rendering/FrontEnd/TextPainter.cs
+++ b/CSharpMath.Rendering/FrontEnd/TextPainter.cs
@@ -52,16 +52,16 @@ private void DrawCore(TCanvas canvas, float? width, TextAlignment alignment,
       if (ErrorMessage == null) {
         _relativeXCoordDisplay.Position =
           _relativeXCoordDisplay.Position.Plus(IPainterExtensions.GetDisplayPosition(
-            System.Math.Max(_relativeXCoordDisplay.Width, _absoluteXCoordDisplay.Width),
+            System.Math.Max(_relativeXCoordDisplay.InkWidth(), _absoluteXCoordDisplay.InkWidth()),
             System.Math.Max(_relativeXCoordDisplay.Ascent, _absoluteXCoordDisplay.Ascent),
             System.Math.Max(_relativeXCoordDisplay.Descent, _absoluteXCoordDisplay.Descent),
             FontSize, width ?? c.Width,
             c.Height, alignment, padding, offsetX, offsetY
           ));
         var adjustedCanvasWidth =
-          float.IsInfinity(c.Width) || float.IsNaN(c.Width)
-          ? System.Math.Max(_relativeXCoordDisplay.Displays.CollectionWidth(),
-            _absoluteXCoordDisplay.Displays.IsNonEmpty() ? _absoluteXCoordDisplay.Displays.Max(d => d.Width) : 0)
+            float.IsInfinity(c.Width) || float.IsNaN(c.Width)
+          ? System.Math.Max(_relativeXCoordDisplay.InkWidth(),
+            _absoluteXCoordDisplay.Displays.IsNonEmpty() ? _absoluteXCoordDisplay.Displays.Max(d => d.InkWidth()) : 0)
           : c.Width;
         // https://github.com/verybadcat/CSharpMath/issues/123
         // Take into account padding, offset etc. on both sides
@@ -73,7 +73,7 @@ private void DrawCore(TCanvas canvas, float? width, TextAlignment alignment,
           foreach (var relDisplay in _relativeXCoordDisplay.Displays.Reverse()) {
             if (relDisplay.Position.Y > y) {
               y = relDisplay.Position.Y;
-              var rightSpace = adjustedCanvasWidth - (relDisplay.Position.X + relDisplay.Width);
+              var rightSpace = adjustedCanvasWidth - (relDisplay.Position.X + relDisplay.InkWidth());
               Δx = leftRightFlags switch {
                 TextAlignment.Center => rightSpace / 2,
                 TextAlignment.Right => rightSpace,
@@ -120,4 +120,4 @@ public void DrawOneLine(TCanvas canvas, float x, float y) {
     }
     public new TextPainter<TCanvas, TColor> ShallowClone() => (TextPainter<TCanvas, TColor>)MemberwiseClone();
   }
-}
\ No newline at end of file
+}
diff --git a/CSharpMath.Rendering/PublicAPI/DebugApi/PublicAPI.Unshipped.txt b/CSharpMath.Rendering/PublicAPI/DebugApi/PublicAPI.Unshipped.txt
index e69de29b..b8ff83ef 100644
--- a/CSharpMath.Rendering/PublicAPI/DebugApi/PublicAPI.Unshipped.txt
+++ b/CSharpMath.Rendering/PublicAPI/DebugApi/PublicAPI.Unshipped.txt
@@ -0,0 +1,7 @@
+#nullable enable
+CSharpMath.Rendering.BackEnd.Fonts.GetAdvances(System.Collections.Generic.IEnumerable<CSharpMath.Rendering.BackEnd.Glyph>! glyphs) -> System.Collections.Generic.IEnumerable<float>!
+CSharpMath.Rendering.BackEnd.Fonts.GetBoundingRects(System.Collections.Generic.IEnumerable<CSharpMath.Rendering.BackEnd.Glyph>! glyphs) -> System.Collections.Generic.IEnumerable<System.Drawing.RectangleF>!
+override CSharpMath.Rendering.BackEnd.MathTable.StretchStackBottomShiftDown(CSharpMath.Rendering.BackEnd.Fonts! fonts) -> float
+override CSharpMath.Rendering.BackEnd.MathTable.StretchStackGapAboveMin(CSharpMath.Rendering.BackEnd.Fonts! fonts) -> float
+override CSharpMath.Rendering.BackEnd.MathTable.StretchStackGapBelowMin(CSharpMath.Rendering.BackEnd.Fonts! fonts) -> float
+override CSharpMath.Rendering.BackEnd.MathTable.StretchStackTopShiftUp(CSharpMath.Rendering.BackEnd.Fonts! fonts) -> float
diff --git a/CSharpMath.Rendering/PublicAPI/ReleaseApi/PublicAPI.Unshipped.txt b/CSharpMath.Rendering/PublicAPI/ReleaseApi/PublicAPI.Unshipped.txt
index e69de29b..6b9e5167 100644
--- a/CSharpMath.Rendering/PublicAPI/ReleaseApi/PublicAPI.Unshipped.txt
+++ b/CSharpMath.Rendering/PublicAPI/ReleaseApi/PublicAPI.Unshipped.txt
@@ -0,0 +1,7 @@
+#nullable enable
+CSharpMath.Rendering.BackEnd.Fonts.GetAdvances(System.Collections.Generic.IEnumerable<CSharpMath.Rendering.BackEnd.Glyph>! glyphs) -> System.Collections.Generic.IEnumerable<float>!
+CSharpMath.Rendering.BackEnd.Fonts.GetBoundingRects(System.Collections.Generic.IEnumerable<CSharpMath.Rendering.BackEnd.Glyph>! glyphs) -> System.Collections.Generic.IEnumerable<System.Drawing.RectangleF>!
+override CSharpMath.Rendering.BackEnd.MathTable.StretchStackTopShiftUp(CSharpMath.Rendering.BackEnd.Fonts! fonts) -> float
+override CSharpMath.Rendering.BackEnd.MathTable.StretchStackBottomShiftDown(CSharpMath.Rendering.BackEnd.Fonts! fonts) -> float
+override CSharpMath.Rendering.BackEnd.MathTable.StretchStackGapAboveMin(CSharpMath.Rendering.BackEnd.Fonts! fonts) -> float
+override CSharpMath.Rendering.BackEnd.MathTable.StretchStackGapBelowMin(CSharpMath.Rendering.BackEnd.Fonts! fonts) -> float
diff --git a/CSharpMath.Uno.Example/CSharpMath.Uno.Example.csproj b/CSharpMath.Uno.Example/CSharpMath.Uno.Example.csproj
index 7dbadf9b..b93db06c 100644
--- a/CSharpMath.Uno.Example/CSharpMath.Uno.Example.csproj
+++ b/CSharpMath.Uno.Example/CSharpMath.Uno.Example.csproj
@@ -27,7 +27,19 @@
       https://aka.platform.uno/singleproject-features
     -->
     <UnoFeatures>SkiaRenderer</UnoFeatures>
+
+    <!--
+      Override vulnerable transitive dependencies pulled in by the Uno.Sdk
+      (NU1903 high-severity audit findings fail `dotnet format`'s msbuild restore).
+      System.Security.Cryptography.Xml 10.0.10 is the patched version Uno itself
+      bumped to (unoplatform/uno#23830).
+    -->
+    <NuGetAuditLevel>high</NuGetAuditLevel>
   </PropertyGroup>
+	<ItemGroup>
+		<PackageReference Include="System.Security.Cryptography.Xml" Version="10.0.10" />
+		<PackageReference Include="Tmds.DBus.Protocol" Version="0.21.3" />
+	</ItemGroup>
 	<ItemGroup>
 		<Compile Include="..\CSharpMath.Rendering.Tests\TestRenderingMathData.cs" Link="Examples\TestRenderingMathData.cs" />
 		<Compile Include="..\CSharpMath.Rendering.Tests\TestRenderingSharedData.cs" Link="Examples\TestRenderingSharedData.cs" />
diff --git a/CSharpMath/Atom/Atoms/Box.cs b/CSharpMath/Atom/Atoms/Box.cs
new file mode 100644
index 00000000..1f4b157e
--- /dev/null
+++ b/CSharpMath/Atom/Atoms/Box.cs
@@ -0,0 +1,43 @@
+namespace CSharpMath.Atom.Atoms {
+  /// <summary>Horizontal alignment of a box's child relative to the box origin
+  /// (drives the lap draw offset).</summary>
+  public enum BoxHAlign { Left, Center, Right }
+  /// <summary>Overlay strike drawn across an otherwise-unchanged box:
+  /// the cancel/sout family.</summary>
+  public enum StrikeStyle { None, Forward, Backward, Cross, Horizontal }
+
+  /// <summary>A box atom: the phantom/smash/lap family plus the cancel family.
+  /// The content lives in <see cref="InnerList"/>; the flags below select the variant.</summary>
+  public sealed class Box : MathAtom, IMathListContainer {
+    public MathList InnerList { get; set; } = new MathList();
+    /// <summary>Report the child's width (true) or zero width (false).</summary>
+    public bool KeepWidth { get; set; } = true;
+    /// <summary>Report the child's ascent (true) or zero ascent (false).</summary>
+    public bool KeepHeight { get; set; } = true;
+    /// <summary>Report the child's descent (true) or zero descent (false).</summary>
+    public bool KeepDepth { get; set; } = true;
+    /// <summary>Draw the measured child (true) or suppress drawing entirely (false, phantom).</summary>
+    public bool DrawChild { get; set; } = true;
+    /// <summary>Horizontal draw offset applied when KeepWidth == false (laps).</summary>
+    public BoxHAlign HAlign { get; set; }
+    /// <summary>Overlay strike drawn across the box; None (default) = no strike.</summary>
+    public StrikeStyle StrikeStyle { get; set; }
+    public override bool ScriptsAllowed => true;
+    System.Collections.Generic.IEnumerable<MathList> IMathListContainer.InnerLists =>
+      new[] { InnerList };
+    public new Box Clone(bool finalize) => (Box)base.Clone(finalize);
+    protected override MathAtom CloneInside(bool finalize) => new Box {
+      InnerList = InnerList.Clone(finalize),
+      KeepWidth = KeepWidth,
+      KeepHeight = KeepHeight,
+      KeepDepth = KeepDepth,
+      DrawChild = DrawChild,
+      HAlign = HAlign,
+      StrikeStyle = StrikeStyle
+    };
+    public override string DebugString =>
+      new System.Text.StringBuilder(@"\box")
+        .AppendInBracesOrEmptyBraces(InnerList.DebugString)
+        .AppendDebugStringOfScripts(this).ToString();
+  }
+}
diff --git a/CSharpMath/Atom/Atoms/Fraction.cs b/CSharpMath/Atom/Atoms/Fraction.cs
index e1083a37..072a10aa 100644
--- a/CSharpMath/Atom/Atoms/Fraction.cs
+++ b/CSharpMath/Atom/Atoms/Fraction.cs
@@ -1,6 +1,9 @@
 using System.Text;
 
 namespace CSharpMath.Atom.Atoms {
+  public enum FractionStyle { Auto, Display, Text }
+  public enum FractionAlignment { Center, Left, Right }
+
   public sealed class Fraction : MathAtom, IMathListContainer {
     public MathList Numerator { get; }
     public MathList Denominator { get; }
@@ -10,6 +13,14 @@ public sealed class Fraction : MathAtom, IMathListContainer {
     public Boundary RightDelimiter { get; set; }
     /// <summary>In this context, a "rule" is a fraction line.</summary>
     public bool HasRule { get; }
+    /// <summary>Explicit style override: \dfrac/\dbinom/\cfrac force display,
+    /// \tfrac/\tbinom force text. Auto honors the surrounding style (Rule 15a).</summary>
+    public FractionStyle StyleOverride { get; set; } = FractionStyle.Auto;
+    /// <summary>True for \cfrac: operands are typeset in display style with struts
+    /// and the whole fraction is wrapped in surrounding 3mu thin space.</summary>
+    public bool IsContinuedFraction { get; set; }
+    /// <summary>Numerator alignment within max(numWidth, denWidth). Only \cfrac[l]/[r] sets a non-default value.</summary>
+    public FractionAlignment NumeratorAlignment { get; set; } = FractionAlignment.Center;
     public Fraction(MathList numerator, MathList denominator, bool hasRule = true) =>
       (Numerator, Denominator, HasRule) = (numerator, denominator, hasRule);
     public override bool ScriptsAllowed => true;
@@ -17,7 +28,10 @@ public Fraction(MathList numerator, MathList denominator, bool hasRule = true) =
     protected override MathAtom CloneInside(bool finalize) =>
       new Fraction(Numerator.Clone(finalize), Denominator.Clone(finalize), HasRule) {
         LeftDelimiter = LeftDelimiter,
-        RightDelimiter = RightDelimiter
+        RightDelimiter = RightDelimiter,
+        StyleOverride = StyleOverride,
+        IsContinuedFraction = IsContinuedFraction,
+        NumeratorAlignment = NumeratorAlignment
       };
     public override string DebugString =>
       new StringBuilder(HasRule ? @"\frac" : @"\atop")
diff --git a/CSharpMath/Atom/Atoms/Group.cs b/CSharpMath/Atom/Atoms/Group.cs
new file mode 100644
index 00000000..ad1f0e32
--- /dev/null
+++ b/CSharpMath/Atom/Atoms/Group.cs
@@ -0,0 +1,30 @@
+namespace CSharpMath.Atom.Atoms {
+  /// <summary>A brace group `{…}` in math mode — an Ord subformula. Script-capable;
+  /// spaced as Ordinary. The grouped content lives in <see cref="InnerList"/>, and the
+  /// sub/superscript fields drive scripting of the whole group.</summary>
+  public sealed class Group : MathAtom, IMathListContainer {
+    public MathList InnerList { get; set; } = new MathList();
+    public override bool ScriptsAllowed => true;
+    System.Collections.Generic.IEnumerable<MathList> IMathListContainer.InnerLists =>
+      new[] { InnerList };
+    public new Group Clone(bool finalize) => (Group)base.Clone(finalize);
+    protected override MathAtom CloneInside(bool finalize) => new Group {
+      InnerList = InnerList.Clone(finalize)
+    };
+    /// <summary>Offsets every atom range of the inner list so group contents carry
+    /// global indices starting at <paramref name="startIndex"/> (finalization only).</summary>
+    internal void OffsetInnerRanges(int startIndex) {
+      foreach (var atom in InnerList)
+        if (atom.IndexRange != Range.Zero && atom.IndexRange.Location < startIndex)
+          atom.IndexRange = new Range(atom.IndexRange.Location + startIndex, atom.IndexRange.Length);
+      // Recurse into nested containers.
+      foreach (var atom in InnerList)
+        if (atom is Group nested) nested.OffsetInnerRanges(startIndex);
+    }
+    public override string DebugString =>
+      new System.Text.StringBuilder()
+        .AppendInBracesOrEmptyBraces(InnerList.DebugString)
+        .AppendDebugStringOfScripts(this).ToString();
+  }
+}
+
diff --git a/CSharpMath/Atom/Atoms/LargeDelimiter.cs b/CSharpMath/Atom/Atoms/LargeDelimiter.cs
new file mode 100644
index 00000000..bb9c33eb
--- /dev/null
+++ b/CSharpMath/Atom/Atoms/LargeDelimiter.cs
@@ -0,0 +1,18 @@
+namespace CSharpMath.Atom.Atoms {
+  /// <summary>One of TeX's explicitly sized delimiters (\big, \Big, etc.).</summary>
+  public sealed class LargeDelimiter : MathAtom {
+    public enum DelimiterSize { Size1 = 1, Size2, Size3, Size4 }
+    public DelimiterSize Size { get; }
+    public LargeDelimiter(string nucleus, DelimiterSize size, System.Type mathClass) : base(nucleus) {
+      if (size < DelimiterSize.Size1 || size > DelimiterSize.Size4) throw new System.ArgumentOutOfRangeException(nameof(size));
+      if (mathClass != typeof(Ordinary) && mathClass != typeof(Open) && mathClass != typeof(Close) && mathClass != typeof(Relation))
+        throw new System.ArgumentException("Large delimiter must be ordinary, open, close, or relation", nameof(mathClass));
+      Size = size;
+      MathClass = mathClass;
+    }
+    public System.Type MathClass { get; }
+    public override bool ScriptsAllowed => true;
+    protected override MathAtom CloneInside(bool finalize) => new LargeDelimiter(Nucleus, Size, MathClass);
+    public new LargeDelimiter Clone(bool finalize) => (LargeDelimiter)base.Clone(finalize);
+  }
+}
diff --git a/CSharpMath/Atom/Atoms/Macro.cs b/CSharpMath/Atom/Atoms/Macro.cs
new file mode 100644
index 00000000..d1f5df45
--- /dev/null
+++ b/CSharpMath/Atom/Atoms/Macro.cs
@@ -0,0 +1,36 @@
+using System.Collections.Generic;
+namespace CSharpMath.Atom.Atoms {
+  public sealed class Macro : MathAtom {
+    public string Command { get; }
+    public IReadOnlyList<string> Arguments { get; }
+    internal MathList RawExpansion { get; }
+    public override bool ScriptsAllowed => true;
+    internal Macro(string command, IReadOnlyList<string> arguments, MathList rawExpansion) : base(string.Empty) {
+      Command = command; Arguments = new System.Collections.ObjectModel.ReadOnlyCollection<string>(new List<string>(arguments)); RawExpansion = rawExpansion.Clone(false);
+    }
+    public new Macro Clone(bool finalize) => (Macro)base.Clone(finalize);
+    protected override MathAtom CloneInside(bool finalize) => new Macro(Command, Arguments, RawExpansion);
+    public override string DebugString => new System.Text.StringBuilder(@"\").Append(Command).AppendDebugStringOfScripts(this).ToString();
+    public MathList Expansion() {
+      var output = new MathList();
+      foreach (var atom in RawExpansion)
+        if (atom is Macro nested) output.Append(nested.Expansion()); else output.Add(atom.Clone(false));
+      TransferScriptsTo(output); return output;
+    }
+    private void TransferScriptsTo(MathList expansion) {
+      if (Superscript.IsEmpty() && Subscript.IsEmpty()) return;
+      MathAtom? target = null;
+      for (var i = expansion.Count - 1; i >= 0; i--) if (expansion[i].ScriptsAllowed) { target = expansion[i]; break; }
+      if (target == null || Superscript.IsNonEmpty() && target.Superscript.IsNonEmpty() || Subscript.IsNonEmpty() && target.Subscript.IsNonEmpty()) {
+        target = new Ordinary(string.Empty); expansion.Add(target);
+      }
+      if (Superscript.IsNonEmpty()) target.Superscript.Append(Superscript.Clone(false));
+      if (Subscript.IsNonEmpty()) target.Subscript.Append(Subscript.Clone(false));
+    }
+    internal static MathList ExpandMacros(MathList list) {
+      var expanded = new MathList();
+      foreach (var atom in list) if (atom is Macro macro) expanded.Append(macro.Expansion()); else expanded.Add(atom);
+      return expanded;
+    }
+  }
+}
diff --git a/CSharpMath/Atom/Atoms/Stack.cs b/CSharpMath/Atom/Atoms/Stack.cs
new file mode 100644
index 00000000..9171dc6b
--- /dev/null
+++ b/CSharpMath/Atom/Atoms/Stack.cs
@@ -0,0 +1,49 @@
+namespace CSharpMath.Atom.Atoms {
+  /// <summary>Describes how one row (over or under) of a <see cref="Stack"/> is produced.</summary>
+  public abstract class StackConstruction {
+    /// <summary>A single stretchy cap glyph (e.g. → for \overrightarrow, ⏞ for \overbrace).</summary>
+    public sealed class Extensible : StackConstruction {
+      public string Glyph { get; }
+      public Extensible(string glyph) => Glyph = glyph;
+    }
+    /// <summary>A math list typeset at a specified style (for \overset / \underset / …).</summary>
+    public sealed class MathListRow : StackConstruction {
+      public Atom.MathList List { get; }
+      public LineStyle Style { get; }
+      public bool Cramped { get; }
+      public MathListRow(Atom.MathList list, LineStyle style, bool cramped) =>
+        (List, Style, Cramped) = (list, style, cramped);
+    }
+    internal StackConstruction() { }
+
+    public StackConstruction Clone(bool finalize) {
+      if (this is Extensible e) return new Extensible(e.Glyph);
+      if (this is MathListRow m) return new MathListRow(m.List.Clone(finalize), m.Style, m.Cramped);
+      throw new InvalidCodePathException("Unknown stack construction kind");
+    }
+  }
+
+  /// <summary>A generic over/under stack atom: \overrightarrow, \overbrace,
+  /// \underset and relatives. The display class controls inter-element spacing
+  /// (default Ordinary; \stackrel forces Relation, \stackbin BinaryOperator).</summary>
+  public sealed class Stack : MathAtom, IMathListContainer {
+    public MathList InnerList { get; set; } = new MathList();
+    public StackConstruction? Over { get; set; }
+    public StackConstruction? Under { get; set; }
+    public System.Type DisplayClassType { get; set; } = typeof(Ordinary);
+    public override bool ScriptsAllowed => true;
+    System.Collections.Generic.IEnumerable<MathList> IMathListContainer.InnerLists =>
+      new[] { InnerList };
+    public new Stack Clone(bool finalize) => (Stack)base.Clone(finalize);
+    protected override MathAtom CloneInside(bool finalize) => new Stack {
+      InnerList = InnerList.Clone(finalize),
+      Over = Over?.Clone(finalize),
+      Under = Under?.Clone(finalize),
+      DisplayClassType = DisplayClassType
+    };
+    public override string DebugString =>
+      new System.Text.StringBuilder(@"\stack")
+        .AppendInBracesOrEmptyBraces(InnerList.DebugString)
+        .AppendDebugStringOfScripts(this).ToString();
+  }
+}
diff --git a/CSharpMath/Atom/Atoms/Style.cs b/CSharpMath/Atom/Atoms/Style.cs
index a1b5ac53..8cc59e14 100644
--- a/CSharpMath/Atom/Atoms/Style.cs
+++ b/CSharpMath/Atom/Atoms/Style.cs
@@ -2,6 +2,20 @@ namespace CSharpMath.Atom.Atoms {
   ///<summary>Style changes during rendering</summary>
   public sealed class Style : MathAtom {
     public Style(LineStyle style) : base(string.Empty) => LineStyle = style;
+    public override string Nucleus {
+      get => base.Nucleus;
+      set {
+        if (!string.IsNullOrEmpty(value)) throw new System.InvalidOperationException("Style atoms cannot have a nucleus.");
+        base.Nucleus = value;
+      }
+    }
+    public override FontStyle FontStyle {
+      get => base.FontStyle;
+      set {
+        if (value != FontStyle.Default) throw new System.InvalidOperationException("Style atoms cannot have a font style.");
+        base.FontStyle = value;
+      }
+    }
     public LineStyle LineStyle { get; }
     public override bool ScriptsAllowed => false;
     public new Style Clone(bool finalize) => (Style)base.Clone(finalize);
@@ -16,4 +30,4 @@ public bool EqualsStyle(Style otherStyle) =>
     public override int GetHashCode() =>
       unchecked(base.GetHashCode() + 107 * LineStyle.GetHashCode());
   }
-}
\ No newline at end of file
+}
diff --git a/CSharpMath/Atom/Atoms/Table.cs b/CSharpMath/Atom/Atoms/Table.cs
index f78d3137..19ad0274 100644
--- a/CSharpMath/Atom/Atoms/Table.cs
+++ b/CSharpMath/Atom/Atoms/Table.cs
@@ -13,6 +13,9 @@ public Table() : this(null) { }
       InterColumnSpacing = InterColumnSpacing,
       InterRowAdditionalSpacing = InterRowAdditionalSpacing,
       Environment = Environment,
+      CellStyle = CellStyle,
+      VerticalLines = VerticalLines.ToList(),
+      HorizontalLines = HorizontalLines.ToList(),
       Alignments = Alignments.ToList(),
       Cells = new List<List<MathList>>(Cells.Select(list =>
         new List<MathList>(list.Select(sublist => sublist.Clone(finalize)))))
@@ -29,6 +32,17 @@ public Table() : this(null) { }
     /// Additional spacing between rows in jots (one jot is 0.3 times font size).
     /// </summary>
     public float InterRowAdditionalSpacing { get; set; }
+    /// <summary>The line style every cell of this table renders in, or null to
+    /// inherit the surrounding style (aligned/gather/eqnarray/alignedat).</summary>
+    public LineStyle? CellStyle { get; set; }
+    /// <summary>The number of `|` vertical rules at each column boundary (array
+    /// environment). Length NColumns+1: index 0 = before column 0 … NColumns = after the
+    /// last column. Empty for every non-array environment.</summary>
+    public List<int> VerticalLines { get; set; } = new List<int>();
+    /// <summary>The number of `\hline` horizontal rules at each row boundary (array
+    /// environment). Length NRows+1: index 0 = above row 0 … NRows = below the last
+    /// row. Empty for every non-array environment.</summary>
+    public List<int> HorizontalLines { get; set; } = new List<int>();
     /// <summary>The name of the environment that this table denotes</summary>
     public string? Environment { get; set; }
     /// <summary>Number of rows</summary>
diff --git a/CSharpMath/Atom/LaTeXParser.cs b/CSharpMath/Atom/LaTeXParser.cs
index 1250d8e7..b295bd7f 100644
--- a/CSharpMath/Atom/LaTeXParser.cs
+++ b/CSharpMath/Atom/LaTeXParser.cs
@@ -20,6 +20,11 @@ public class TableEnvironment : IEnvironment {
       public string? Name { get; set; }
       public bool Ended { get; set; }
       public int NRows { get; set; }
+      /// <summary>The raw {…} argument of environments that take one
+      /// (alignedat's {n}, array's column spec).</summary>
+      public string? Argument { get; set; }
+      /// <summary>Per-row-boundary \hline counts (array only), length rows+1.</summary>
+      public List<int> HorizontalLines { get; } = new List<int>();
       public string? ArrayAlignments { get; set; }
     }
     public class InnerEnvironment : IEnvironment {
@@ -31,11 +36,59 @@ public class InnerEnvironment : IEnvironment {
     public bool TextMode { get; set; } //_spacesAllowed in iosMath
     public FontStyle CurrentFontStyle { get; set; }
     public Stack<IEnvironment> Environments { get; } = new Stack<IEnvironment>();
+    /// <summary>Maximum recursion depth for BuildInternal: comfortably deeper than any
+    /// realistic human-authored expression yet far below the frames needed to overflow the stack.</summary>
+    internal const int MaxRecursionDepth = 150;
+    private int _recursionDepth;
+    internal int MacroExpansionDepth { get; set; }
+    /// <summary>Set by a TeX group-transformation command (\over, \atop, …) that fired
+    /// inside a `{…}` group; the group must then NOT be wrapped as a Group atom because
+    /// the resulting fraction replaces it. Read-and-clear: the `{` handler consumes it,
+    /// so an inner transform never leaks into an enclosing group's decision.</summary>
+    private bool _groupWasTransformedByStopCommand;
+    /// <summary>When true (built-in macro templates only), `#N` reads a macro parameter
+    /// instead of being an invalid character.</summary>
+
+    /// <summary>Whether a group-transformation command (\over/\atop/…) fired inside the
+    /// group currently being read. Read-and-clear.</summary>
+    internal bool GroupWasTransformedByStopCommand {
+      get {
+        var value = _groupWasTransformedByStopCommand;
+        _groupWasTransformedByStopCommand = false;
+        return value;
+      }
+      set => _groupWasTransformedByStopCommand = value;
+    }
+
+    /// <summary>Returns the character at the read position without consuming it.</summary>
+    public char PeekChar() => Chars[NextChar];
+
+    /// <summary>Reads a `\`-command name (letters only) or a single non-letter character
+    /// after the backslash. The backslash must already be consumed.</summary>
+    public string ReadCommandName() {
+      if (!HasCharacters) return string.Empty;
+      var ch = ReadChar();
+      static bool IsAsciiLetter(char c) =>
+        (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
+      if (!IsAsciiLetter(ch)) {
+        // Single non-letter character command (e.g. \,, \;)
+        return ch.ToStringInvariant();
+      }
+      var builder = new StringBuilder().Append(ch);
+      while (HasCharacters && IsAsciiLetter(Chars[NextChar])) {
+        builder.Append(ReadChar());
+      }
+      return builder.ToString();
+    }
+
     public LaTeXParser(string str) {
       Chars = str;
       CurrentFontStyle = FontStyle.Default;
     }
-    public Result<MathList> Build() => BuildInternal(false);
+    public Result<MathList> Build() {
+      _recursionDepth = 0;
+      return BuildInternal(false);
+    }
     public char ReadChar() => Chars[NextChar++];
     public void UndoReadChar() =>
       _ = NextChar == 0
@@ -43,6 +96,40 @@ public void UndoReadChar() =>
       : NextChar--;
     public bool HasCharacters => NextChar < Chars.Length;
     public Result<MathList> ReadArgument(MathList? appendTo = null) => BuildInternal(true, r: appendTo);
+    /// <summary>Reads one macro argument as source text. Braces are retained and
+    /// escaped braces do not affect nesting; this is intentionally not a parsed AST.</summary>
+    internal Result<string> ReadRawArgument() {
+      SkipSpaces();
+      if (!HasCharacters) return Result.Err("Missing required argument at end of input");
+      if (Chars[NextChar] is '}' or '^' or '_' or '&')
+        return Result.Err($"Missing required argument before '{Chars[NextChar]}'");
+      var first = ReadChar();
+      if (first == '\\') {
+        if (!HasCharacters) return Result.Err("Trailing \\ in a macro argument");
+        return Result.Ok("\\" + ReadCommandName());
+      }
+      if (first != '{') {
+        if (char.IsHighSurrogate(first) && HasCharacters && char.IsLowSurrogate(Chars[NextChar]))
+          return Result.Ok(new string(new[] { first, ReadChar() }));
+        return Result.Ok(first.ToString());
+      }
+      var body = new System.Text.StringBuilder();
+      var depth = 0;
+      while (HasCharacters) {
+        var c = ReadChar();
+        if (c == '\\') {
+          if (!HasCharacters) return Result.Err("Trailing \\ in a macro argument");
+          body.Append(c).Append(ReadChar());
+          continue;
+        }
+        if (c == '}') {
+          if (depth == 0) return Result.Ok(body.ToString());
+          depth--;
+        } else if (c == '{') depth++;
+        body.Append(c);
+      }
+      return Result.Err("Unmatched { in a macro argument");
+    }
     public Result<MathList?> ReadArgumentOptional(MathList? appendTo = null) =>
       ReadCharIfAvailable('[')
       ? BuildInternal(false, ']', r: appendTo).Bind(mathList => (MathList?)mathList)
@@ -53,10 +140,39 @@ public Result<MathList> ReadUntil(char stopChar, MathList? appendTo = null) =>
     //https://phabricator.wikimedia.org/T99369
     //https://phab.wmfusercontent.org/file/data/xsimlcnvo42siudvwuzk/PHID-FILE-bdcqexocj5b57tj2oezn/math_rendering.png
     //dt, \text{d}t, \partial t, \nabla\psi \\ \underline\overline{dy/dx, \text{d}y/\text{d}x, \frac{dy}{dx}, \frac{\text{d}y}{\text{d}x}, \frac{\partial^2}{\partial x_1\partial x_2}y} \\ \prime,
+    /// <summary>True while the innermost BuildInternal call is filling a single-character
+    /// / single-field slot (^{…}, _{…}, \frac{…}, command arguments): a brace there *is*
+    /// the field, so it must be flattened rather than wrapped as a Group.</summary>
+    public bool IsReadingOneCharField { get; private set; }
+    /// <summary>True while the innermost BuildInternal call is reading up to a stop char
+    /// (a `}` field or an environment ender): braces there are fields too.</summary>
+    public bool IsReadingStopCharField { get; private set; }
+
     private Result<MathList> BuildInternal(bool oneCharOnly, char stopChar = '\0', MathList? r = null) {
       if (oneCharOnly && stopChar > '\0') {
         throw new InvalidCodePathException("Cannot set both oneCharOnly and stopChar");
       }
+      if (_recursionDepth >= MaxRecursionDepth) {
+        return "LaTeX nesting too deep";
+      }
+      _recursionDepth++;
+      var outerOneChar = IsReadingOneCharField;
+      var outerStopChar = IsReadingStopCharField;
+      // Only a one-char field (^{…}, _{…}, \frac{…}, command arguments) makes braces
+      // inside it fields. A stopChar read (a `{…}` group body, an environment body)
+      // is NOT a field: nested braces there are genuine groups (iosMath 086d345).
+      IsReadingOneCharField = oneCharOnly;
+      IsReadingStopCharField = false;
+      try {
+        return BuildInternalInner(oneCharOnly, stopChar, r);
+      } finally {
+        IsReadingOneCharField = outerOneChar;
+        IsReadingStopCharField = outerStopChar;
+        _recursionDepth--;
+      }
+    }
+
+    private Result<MathList> BuildInternalInner(bool oneCharOnly, char stopChar, MathList? r) {
       r ??= new MathList();
       MathAtom? prevAtom = null;
       while (HasCharacters) {
@@ -65,6 +181,42 @@ private Result<MathList> BuildInternal(bool oneCharOnly, char stopChar = '\0', M
           NextChar++;
           return r;
         }
+        if (Chars[NextChar] == '\\') {
+          // Macros first: one Macro atom then flows through the shared tail below.
+          var saveChar = NextChar;
+          NextChar++; // consume the backslash
+          var commandName = ReadCommandName();
+          if (LaTeXSettings.IsBuiltinMacro(commandName)) {
+            var macroResult = LaTeXSettings.MacroAtomForCommand(this, commandName);
+            if (macroResult.Error is string macroError) return macroError;
+            if (macroResult._value.Atom is { } theMacro) {
+              theMacro.FontStyle = CurrentFontStyle;
+              r.Add(theMacro);
+              if (oneCharOnly) return r;
+              continue;
+            }
+          }
+          // Not a macro: rewind and continue with normal command dispatch.
+          UndoTo(saveChar);
+          // Explicit fixed-size delimiters are single atoms; unlike \left/\right,
+          // they never pair and retain their TeX math class for spacing.
+          NextChar++;
+          var largeName = ReadCommandName();
+          if (TryLargeDelimiter(largeName, out var largeSize, out var largeClass)) {
+            var (boundary, boundaryError) = ReadDelimiter(largeName);
+            if (boundaryError != null) return boundaryError;
+            var largeNucleus = boundary.Nucleus switch {
+              "\u2329" => "\u27E8",
+              "\u232A" => "\u27E9",
+              _ => boundary.Nucleus ?? string.Empty
+            };
+            var large = new Atoms.LargeDelimiter(largeNucleus, largeSize, largeClass);
+            r.Add(large);
+            if (oneCharOnly) return r;
+            continue;
+          }
+          UndoTo(saveChar);
+        }
         var ((handler, splitIndex), error) = LaTeXSettings.Commands.TryLookup(Chars.AsSpan(NextChar));
         if (error != null) {
           NextChar++; // Point to the start of the erroneous command
@@ -105,6 +257,27 @@ private Result<MathList> BuildInternal(bool oneCharOnly, char stopChar = '\0', M
       };
     }
 
+    private static bool TryLargeDelimiter(string name, out Atoms.LargeDelimiter.DelimiterSize size,
+      out System.Type mathClass) {
+      var suffix = name.Length > 0 && name[name.Length - 1] is 'l' or 'r' or 'm'
+        ? name[name.Length - 1] : '\0';
+      var prefix = suffix == '\0' ? name : name.Substring(0, name.Length - 1);
+      size = prefix switch {
+        "big" => Atoms.LargeDelimiter.DelimiterSize.Size1,
+        "Big" => Atoms.LargeDelimiter.DelimiterSize.Size2,
+        "bigg" => Atoms.LargeDelimiter.DelimiterSize.Size3,
+        "Bigg" => Atoms.LargeDelimiter.DelimiterSize.Size4,
+        _ => default
+      };
+      mathClass = suffix switch {
+        'l' => typeof(Atoms.Open),
+        'r' => typeof(Atoms.Close),
+        'm' => typeof(Atoms.Relation),
+        _ => typeof(Atoms.Ordinary)
+      };
+      return prefix is "big" or "Big" or "bigg" or "Bigg";
+    }
+
     public string ReadString() {
       var builder = new StringBuilder();
       while (HasCharacters) {
@@ -124,29 +297,35 @@ public Result<Color> ReadColor() {
         return "Missing {";
       }
       SkipSpaces();
+      // Read the entire token up to the closing brace so invalid inputs produce a
+      // clear "Invalid color" error instead of a confusing "Missing }".
       var index = NextChar;
       var length = 0;
       while (HasCharacters) {
         var ch = ReadChar();
-        if (char.IsLetterOrDigit(ch) || ch == '#') {
-          length++;
-        } else {
-          // we went too far
+        if (ch == '}') {
           UndoReadChar();
           break;
         }
+        length++;
       }
       var str = Chars.Substring(index, length);
-      if (LaTeXSettings.ParseColor(str) is Color color) {
-        SkipSpaces();
-        if (!ReadCharIfAvailable('}'))
-          return "Missing }";
-        return color;
-      } else {
+      if (ParseColorStrict(str) is not Color color) {
         return "Invalid color: " + str;
       }
+      SkipSpaces();
+      if (!ReadCharIfAvailable('}')) {
+        return "Missing }";
+      }
+      return color;
     }
 
+    /// <summary>Validates a color token: '#' followed by exactly 3, 6 or 8 hex digits
+    /// (#RGB expands like CSS), or one of the predefined named colors. Everything
+    /// else is an error rather than a silent no-op.</summary>
+    static Color? ParseColorStrict(string str) =>
+      LaTeXSettings.ParseColor(str);
+
     public void SkipSpaces() {
       while (HasCharacters) {
         var ch = ReadChar();
@@ -184,6 +363,9 @@ public bool ReadCharIfAvailable(char ch) {
       return false;
     }
 
+    /// <summary>Restores the read position, so the caller can dispatch without consuming.</summary>
+    public void UndoTo(int position) => NextChar = position;
+
     public Result<string> ReadEnvironment() {
       if (!ReadCharIfAvailable('{')) {
         return Err("Missing {");
@@ -217,8 +399,260 @@ public Result<string> ReadEnvironment() {
       for (int i = 0; i < 2 && HasCharacters; i++) {
         unit[i] = ReadChar();
       }
+      if (!HasCharacters && unit[1] == default) {
+        // The input ended inside the two-character unit.
+        return "Expected two-character length unit";
+      }
       return Atom.Length.Create(length, new string(unit), TextMode);
     }
+
+    /// <summary>The fraction macro table: command name → (hasRule, styleOverride,
+    /// delimiters, continued, acceptsAlign). Shared by \frac \binom \dfrac \tfrac
+    /// \dbinom \tbinom \cfrac.</summary>
+    private static readonly Dictionary<string,
+      (bool hasRule, Atoms.FractionStyle style, string? leftDelim, string? rightDelim,
+       bool continued, bool acceptsAlign)> FractionMacros =
+      new[] {
+        ("frac",   (true,  Atoms.FractionStyle.Auto,    (string?)null, null, false, false)),
+        ("binom",  (false, Atoms.FractionStyle.Auto,    "(",           ")",  false, false)),
+        ("dfrac",  (true,  Atoms.FractionStyle.Display, (string?)null, null, false, false)),
+        ("tfrac",  (true,  Atoms.FractionStyle.Text,    (string?)null, null, false, false)),
+        ("dbinom", (false, Atoms.FractionStyle.Display, "(",           ")",  false, false)),
+        ("tbinom", (false, Atoms.FractionStyle.Text,    "(",           ")",  false, false)),
+        ("cfrac",  (true,  Atoms.FractionStyle.Display, (string?)null, null, true,  true)),
+      }.ToDictionary(t => t.Item1, t => t.Item2);
+
+    internal static Result<(MathAtom?, MathList?)> FractionMacro(LaTeXParser parser, string command) {
+      var spec = FractionMacros[command];
+      var fraction = new Atoms.Fraction(new MathList(), new MathList(), spec.hasRule) {
+        StyleOverride = spec.style
+      };
+      if (spec.acceptsAlign && parser.HasCharacters) {
+        // Optional [l|c|r] alignment argument for \cfrac.
+        var saveChar = parser.NextChar;
+        if (parser.ReadCharIfAvailable('[')) {
+          if (!parser.HasCharacters) {
+            return @"Unterminated optional alignment for \cfrac";
+          }
+          var letter = parser.ReadChar();
+          switch (letter) {
+            case 'l':
+              fraction.NumeratorAlignment = Atoms.FractionAlignment.Left;
+              break;
+            case 'c':
+              fraction.NumeratorAlignment = Atoms.FractionAlignment.Center;
+              break;
+            case 'r':
+              fraction.NumeratorAlignment = Atoms.FractionAlignment.Right;
+              break;
+            default:
+              return $@"Invalid alignment for \cfrac: '{letter}' (expected l, c, or r)";
+          }
+          if (!parser.ReadCharIfAvailable(']')) {
+            return @"Unterminated optional alignment for \cfrac";
+          }
+        } else {
+          parser.UndoTo(saveChar);
+        }
+      }
+      if (spec.continued) {
+        fraction.IsContinuedFraction = true;
+      }
+      var (numerator, error) = parser.ReadArgument();
+      if (error != null) return error;
+      var (denominator, error2) = parser.ReadArgument();
+      if (error2 != null) return error2;
+      fraction.Numerator.Clear();
+      fraction.Numerator.Append(numerator);
+      fraction.Denominator.Clear();
+      fraction.Denominator.Append(denominator);
+      if (spec.leftDelim != null) {
+        fraction.LeftDelimiter = new Boundary(spec.leftDelim);
+        fraction.RightDelimiter = new Boundary(spec.rightDelim!);
+      }
+      return LaTeXSettings.Ok(fraction);
+    }
+
+    /// <summary>The over/under stack commands: static extensible rows plus the four
+    /// MathList-row commands. argRoles lists which arguments are read in order.</summary>
+    private enum StackArgRole { Base, Over, Under }
+
+    private sealed class StackCommandSpec {
+      public StackConstruction? OverConstruction;
+      public StackConstruction? UnderConstruction;
+      public System.Type DisplayClassType = typeof(Ordinary);
+      public bool InheritsClass;
+      public StackArgRole[] ArgRoles = { StackArgRole.Base };
+    }
+
+    private static readonly Dictionary<string, StackCommandSpec>
+      StackCommands = BuildStackCommands();
+
+    private static Dictionary<string, StackCommandSpec>
+        BuildStackCommands() {
+      var specs = new System.Collections.Generic.Dictionary<string, StackCommandSpec> {
+        ["overrightarrow"] = new StackCommandSpec {
+          OverConstruction = new StackConstruction.Extensible("→")
+        },
+        ["overleftarrow"] = new StackCommandSpec {
+          OverConstruction = new StackConstruction.Extensible("←")
+        },
+        ["overleftrightarrow"] = new StackCommandSpec {
+          OverConstruction = new StackConstruction.Extensible("↔")
+        },
+        ["underrightarrow"] = new StackCommandSpec {
+          UnderConstruction = new StackConstruction.Extensible("→")
+        },
+        ["underleftarrow"] = new StackCommandSpec {
+          UnderConstruction = new StackConstruction.Extensible("←")
+        },
+        ["underleftrightarrow"] = new StackCommandSpec {
+          UnderConstruction = new StackConstruction.Extensible("↔")
+        },
+        ["overbrace"] = new StackCommandSpec {
+          OverConstruction = new StackConstruction.Extensible("⏞")
+        },
+        // \underbrace keeps its pre-port UnderAnnotation registration (its _
+        // attaches an under-list), so it is deliberately absent here.
+        ["overset"] = new StackCommandSpec {
+          InheritsClass = true,
+          ArgRoles = new[] { StackArgRole.Over, StackArgRole.Base }
+        },
+        ["underset"] = new StackCommandSpec {
+          InheritsClass = true,
+          ArgRoles = new[] { StackArgRole.Under, StackArgRole.Base }
+        },
+        ["stackrel"] = new StackCommandSpec {
+          DisplayClassType = typeof(Relation),
+          ArgRoles = new[] { StackArgRole.Over, StackArgRole.Base }
+        },
+        ["stackbin"] = new StackCommandSpec {
+          DisplayClassType = typeof(BinaryOperator),
+          ArgRoles = new[] { StackArgRole.Over, StackArgRole.Base }
+        },
+      };
+      return specs;
+    }
+
+    /// <summary>\overset/\underset inherit a lone Bin/Rel base atom's intrinsic class
+    /// (read before finalize's Bin→Ord reclassification, matching amsmath \binrel@).</summary>
+    private static System.Type InheritedDisplayClassForBase(MathList baseList) =>
+      baseList.Count == 1 && baseList[0] is var only
+      && (only is BinaryOperator || only is Relation)
+        ? only.GetType()
+        : typeof(Ordinary);
+
+    internal static Result<(MathAtom?, MathList?)> StackAtomForCommand(LaTeXParser parser, string command) {
+      if (!StackCommands.TryGetValue(command, out var spec)) {
+        return LaTeXSettings.Ok(null);
+      }
+      var stack = new Atoms.Stack {
+        Over = spec.OverConstruction?.Clone(false),
+        Under = spec.UnderConstruction?.Clone(false)
+      };
+      foreach (var role in spec.ArgRoles) {
+        var (arg, error) = parser.ReadArgument();
+        if (error != null) return error;
+        switch (role) {
+          case StackArgRole.Base:
+            stack.InnerList = arg;
+            break;
+          case StackArgRole.Over:
+            stack.Over = new StackConstruction.MathListRow(arg, LineStyle.Script, true);
+            break;
+          case StackArgRole.Under:
+            stack.Under = new StackConstruction.MathListRow(arg, LineStyle.Script, true);
+            break;
+        }
+      }
+      stack.DisplayClassType =
+        spec.InheritsClass ? InheritedDisplayClassForBase(stack.InnerList) : spec.DisplayClassType;
+      return LaTeXSettings.Ok(stack);
+    }
+
+    /// <summary>The box commands: phantom/smash/lap plus the cancel family.
+    /// Tuple: keepWidth, keepHeight, keepDepth, drawChild, hAlign, acceptsTB, synthParen.</summary>
+    private static readonly Dictionary<string,
+      (bool kW, bool kH, bool kD, bool draw, BoxHAlign hAlign, bool acceptsTB, bool synthParen)>
+      BoxCommands = new[] {
+        ("phantom",   (true,  true,  true,  false, BoxHAlign.Left,   false, false)),
+        ("hphantom",  (true,  false, false, false, BoxHAlign.Left,   false, false)),
+        ("vphantom",  (false, true,  true,  false, BoxHAlign.Left,   false, false)),
+        ("mathstrut", (false, true,  true,  false, BoxHAlign.Left,   false, true)),
+        ("smash",     (true,  false, false, true,  BoxHAlign.Left,   true,  false)),
+        ("llap",      (false, true,  true,  true,  BoxHAlign.Right,  false, false)),
+        ("rlap",      (false, true,  true,  true,  BoxHAlign.Left,   false, false)),
+        ("clap",      (false, true,  true,  true,  BoxHAlign.Center, false, false)),
+        ("mathllap",  (false, true,  true,  true,  BoxHAlign.Right,  false, false)),
+        ("mathrlap",  (false, true,  true,  true,  BoxHAlign.Left,   false, false)),
+        ("mathclap",  (false, true,  true,  true,  BoxHAlign.Center, false, false)),
+        ("cancel",    (true,  true,  true,  true,  BoxHAlign.Left,   false, false)),
+        ("bcancel",   (true,  true,  true,  true,  BoxHAlign.Left,   false, false)),
+        ("xcancel",   (true,  true,  true,  true,  BoxHAlign.Left,   false, false)),
+        ("sout",      (true,  true,  true,  true,  BoxHAlign.Left,   false, false)),
+      }.ToDictionary(t => t.Item1, t => t.Item2);
+
+    private static readonly Dictionary<string, StrikeStyle>
+      CancelStyles = new Dictionary<string, StrikeStyle> {
+        ["cancel"] = StrikeStyle.Forward,
+        ["bcancel"] = StrikeStyle.Backward,
+        ["xcancel"] = StrikeStyle.Cross,
+        ["sout"] = StrikeStyle.Horizontal,
+      };
+
+    internal static Result<(MathAtom?, MathList?)> BoxAtomForCommand(LaTeXParser parser, string command) {
+      if (!BoxCommands.TryGetValue(command, out var spec)) {
+        return LaTeXSettings.Ok(null);
+      }
+      var box = new Atoms.Box {
+        KeepWidth = spec.kW,
+        KeepHeight = spec.kH,
+        KeepDepth = spec.kD,
+        DrawChild = spec.draw,
+        HAlign = spec.hAlign
+      };
+      if (CancelStyles.TryGetValue(command, out var strike)) {
+        box.StrikeStyle = strike;
+      }
+      if (spec.synthParen) {
+        // \mathstrut: no argument; synthetic inner list with a single open paren.
+        box.InnerList.Add(new Open("("));
+        return LaTeXSettings.Ok(box);
+      }
+      if (spec.acceptsTB && parser.HasCharacters) {
+        // \smash[t]/[b]: optional [t]/[b] before the {X} argument.
+        var saveChar = parser.NextChar;
+        if (parser.ReadCharIfAvailable('[')) {
+          var opt = new StringBuilder();
+          var foundClose = false;
+          while (parser.HasCharacters) {
+            var c = parser.ReadChar();
+            if (c == ']') { foundClose = true; break; }
+            opt.Append(c);
+          }
+          if (!foundClose) {
+            return "Expected character not found: ]";
+          }
+          switch (opt.ToString().Trim()) {
+            case "t":
+              box.KeepHeight = false;
+              box.KeepDepth = true;
+              break;
+            case "b":
+              box.KeepHeight = true;
+              box.KeepDepth = false;
+              break;
+              // any other value: ignore bracket, smash both, no crash
+          }
+        } else {
+          parser.UndoTo(saveChar);
+        }
+      }
+      var (innerList, error) = parser.ReadArgument();
+      if (error != null) return error;
+      box.InnerList.Append(innerList);
+      return LaTeXSettings.Ok(box);
+    }
     public Result<Boundary> ReadDelimiter(string commandName) {
       if (!HasCharacters) {
         return @"Missing delimiter for \" + commandName;
@@ -242,6 +676,13 @@ public Result<Boundary> ReadDelimiter(string commandName) {
         { "vmatrix", ("|", "|") },
         { "Vmatrix", ("‖", "‖") }
       };
+    /// <summary>Environments that take a mandatory raw `{…}` argument after \begin{env}
+    /// (alignedat's {n}, array's column spec).</summary>
+    private static readonly HashSet<string> _environmentsTakingArgument =
+      new HashSet<string> { "alignedat", "array" };
+    /// <summary>Environments that permit \hline row-boundary markers.</summary>
+    private static readonly HashSet<string> _environmentsAllowingHorizontalLines =
+      new HashSet<string> { "array" };
     public Result<MathAtom> ReadTable
       (string? name, MathList? firstList, bool isRow, char stopChar) {
       var environment = new TableEnvironment(name);
@@ -259,34 +700,52 @@ public Result<MathAtom> ReadTable
           currentColumn++;
         }
       }
-      if (environment.Name == "array") {
+      if (environment.Name != null && _environmentsTakingArgument.Contains(environment.Name)) {
+        // Raw {…} argument after \begin{env}: the {n} of alignedat or the column
+        // spec of array. Any character up to the matching } is captured raw.
         if (!ReadCharIfAvailable('{')) {
-          return "Missing array alignment";
+          return environment.Name == "array"
+            ? "Missing array alignment"
+            : $@"{environment.Name} requires a numeric argument, e.g. \begin{{{environment.Name}}}{{2}}";
         }
         var builder = new StringBuilder();
         var done = false;
         while (HasCharacters && !done) {
           var ch = ReadChar();
-          switch (ch) {
-            case 'l':
-            case 'c':
-            case 'r':
-            case '|':
-              builder.Append(ch);
-              break;
-            case '}':
-              environment.ArrayAlignments = builder.ToString();
-              done = true;
-              break;
-            default:
-              return $"Invalid character '{ch}' encountered while parsing array alignments";
-          }
+          if (ch == '}') done = true;
+          else builder.Append(ch);
         }
         if (!done) {
           return "Missing }";
         }
+        environment.ArrayAlignments = builder.ToString();
+      }
+      // Record \hline at the current row boundary. Emits no atom; only valid in array.
+      void RecordHorizontalLine() {
+        while (environment.HorizontalLines.Count <= environment.NRows)
+          environment.HorizontalLines.Add(0);
+        environment.HorizontalLines[environment.NRows]++;
       }
       while (HasCharacters && !environment.Ended) {
+        // \hline may appear at any row/cell boundary (and repeatedly); it emits no
+        // atom and only counts the boundary. Skip whitespace before peeking so
+        // "\hline a" and "\\ \hline b" both work.
+        var saveChar = NextChar;
+        SkipSpaces();
+        if (HasCharacters && Chars[NextChar] == '\\') {
+          NextChar++;
+          var command = ReadCommandName();
+          if (command == "hline") {
+            if (!_environmentsAllowingHorizontalLines.Contains(environment.Name ?? string.Empty)) {
+              return @"\hline is only valid inside an array environment";
+            }
+            RecordHorizontalLine();
+            continue;
+          }
+          UndoTo(saveChar);
+        } else {
+          UndoTo(saveChar);
+        }
         var (list, error) = BuildInternal(false, stopChar);
         if (error != null) return error;
         rows[currentRow].Add(list);
@@ -306,6 +765,7 @@ public Result<MathAtom> ReadTable
       // We have finished parsing the table, now interpret the environment
       name = environment.Name;
       var arrayAlignments = environment.ArrayAlignments;
+      var horizontalLines = environment.HorizontalLines;
       // Table environments with { Name: null } may have been popped by \right
       if (Environments.PeekOrDefault() == environment)
         Environments.Pop();
@@ -321,13 +781,8 @@ public Result<MathAtom> ReadTable
         case var _ when _matrixEnvironments.TryGetValue(name, out var delimiters):
           table.Environment = "matrix"; // TableEnvironment is set to matrix as delimiters are converted to latex outside the table.
           table.InterColumnSpacing = 18;
-
-          var style = new Style(LineStyle.Text);
-          foreach (var row in table.Cells) {
-            foreach (var cell in row) {
-              cell.Insert(0, style);
-            }
-          }
+          // All the cells render in textstyle, stored on the table rather than per-cell.
+          table.CellStyle = LineStyle.Text;
           return delimiters switch {
             (var left, var right) => new Inner(
               new Boundary(left),
@@ -336,21 +791,49 @@ public Result<MathAtom> ReadTable
             ),
             null => table
           };
-        case "array":
-          if (arrayAlignments is null)
-            throw new InvalidCodePathException("arrayAlignments is null despite array environment");
-          table.InterRowAdditionalSpacing = 1;
-          table.InterColumnSpacing = 18;
-          for (int i = 0, j = 0; i < arrayAlignments.Length && j < table.NColumns; i++, j++) {
-            // TODO: vertical lines in array currently unsupported
-            while (arrayAlignments[i] == '|') i++;
-            table.SetAlignment(arrayAlignments[i] switch {
-              'l' => ColumnAlignment.Left,
-              'c' => ColumnAlignment.Center,
-              'r' => ColumnAlignment.Right,
-              _ => throw new InvalidCodePathException("Invalid characters were not filtered")
-            }, j);
+        case "array": {
+            if (arrayAlignments is null)
+              throw new InvalidCodePathException("arrayAlignments is null despite array environment");
+            table.InterRowAdditionalSpacing = 0;
+            table.InterColumnSpacing = 18;
+            // Cells render in textstyle via the table (post-#245).
+            table.CellStyle = LineStyle.Text;
+            // Interpret the column spec: l/c/r append an alignment and open a boundary
+            // slot; | increments the current (rightmost) boundary slot.
+            var vLines = new List<int> { 0 };
+            foreach (var specChar in arrayAlignments) {
+              switch (specChar) {
+                case 'l':
+                  table.SetAlignment(ColumnAlignment.Left, table.Alignments.Count);
+                  vLines.Add(0);
+                  break;
+                case 'c':
+                  table.SetAlignment(ColumnAlignment.Center, table.Alignments.Count);
+                  vLines.Add(0);
+                  break;
+                case 'r':
+                  table.SetAlignment(ColumnAlignment.Right, table.Alignments.Count);
+                  vLines.Add(0);
+                  break;
+                case '|':
+                  vLines[vLines.Count - 1]++;
+                  break;
+              }
+            }
+            // Note: rows may declare fewer/more cells than the spec; extra cells are
+            // dropped and missing ones render empty, matching pre-port behavior.
+            while (vLines.Count < table.NColumns + 1) vLines.Add(0);
+            table.VerticalLines = vLines;
+            while (horizontalLines.Count < table.NRows + 1) horizontalLines.Add(0);
+            table.HorizontalLines = horizontalLines;
+            return table;
           }
+        case "smallmatrix":
+          // Compact inline matrix: script-style cells, no delimiters, center default,
+          // \thickspace = 5mu inter-column gap scaled to the Script cell style at layout.
+          table.InterRowAdditionalSpacing = 0;
+          table.InterColumnSpacing = 5;
+          table.CellStyle = LineStyle.Script;
           return table;
         case "eqalign":
         case "split":
@@ -362,7 +845,7 @@ public Result<MathAtom> ReadTable
             var spacer = new Ordinary(string.Empty);
             foreach (var row in table.Cells) {
               if (row.Count > 1) {
-                row[1].Insert(0, spacer);
+                row[1].Insert(0, spacer.Clone(false));
               }
             }
             table.InterRowAdditionalSpacing = 1;
@@ -370,8 +853,37 @@ public Result<MathAtom> ReadTable
             table.SetAlignment(ColumnAlignment.Left, 1);
             return table;
           }
+        case "alignedat": {
+            // Generalization of aligned to n alignment pairs (2n columns). The raw
+            // argument is the declared pair count; require a positive integer and a
+            // column count that matches it.
+            var argument = arrayAlignments ?? "";
+            bool numeric = argument.Length > 0;
+            foreach (var c in argument) numeric &= c >= '0' && c <= '9';
+            if (!numeric || !int.TryParse(argument, out var pairs) || pairs < 1) {
+              return @"alignedat requires a numeric argument, e.g. \begin{alignedat}{2}";
+            }
+            if (table.NColumns != 2 * pairs) {
+              return $@"alignedat declares {{{pairs}}} ({2 * pairs} columns) but a row has {table.NColumns} columns";
+            }
+            // Relation spacer before each odd column for correct = / relation spacing.
+            var spacer = new Ordinary(string.Empty);
+            foreach (var row in table.Cells) {
+              for (int j = 1; j < row.Count; j += 2) {
+                row[j].Insert(0, spacer.Clone(false));
+              }
+            }
+            table.InterRowAdditionalSpacing = 1;
+            table.InterColumnSpacing = 0;
+            for (int j = 0; j < table.NColumns; j++) {
+              table.SetAlignment(
+                j % 2 == 0 ? ColumnAlignment.Right : ColumnAlignment.Left, j);
+            }
+            return table;
+          }
         case "displaylines":
         case "gather":
+        case "gathered":
           if (table.NColumns != 1) {
             return name + " environment can only have 1 column";
           }
@@ -395,13 +907,17 @@ public Result<MathAtom> ReadTable
             return "cases environment must have 1 to 2 columns";
           } else {
             table.Environment = "array";
+            table.InterRowAdditionalSpacing = 1;
             table.InterColumnSpacing = 18;
+            table.CellStyle = LineStyle.Text;
             table.SetAlignment(ColumnAlignment.Left, 0);
             if (table.NColumns == 2) table.SetAlignment(ColumnAlignment.Left, 1);
-            style = new Style(LineStyle.Text);
+            // The evaluator's piecewise reader keys on per-cell \textstyle atoms, so
+            // cases (unlike matrix) keeps the injected style atom alongside CellStyle.
+            var textStyle = new Style(LineStyle.Text);
             foreach (var row in table.Cells) {
               foreach (var cell in row) {
-                cell.Insert(0, style);
+                cell.Insert(0, textStyle);
               }
             }
             // add delimiters
@@ -465,9 +981,44 @@ public static string EscapeAsLaTeX(string literal) =>
       .ToString();
 
     static string BoundaryToLaTeX(Boundary delimiter) =>
-      LaTeXSettings.BoundaryDelimitersReverse.TryGetValue(delimiter, out var command)
-      ? command
-      : delimiter.Nucleus ?? "";
+      delimiter.Nucleus switch {
+        "\u27E8" => "<",
+        "\u27E9" => ">",
+        _ => LaTeXSettings.BoundaryDelimitersReverse.TryGetValue(delimiter, out var command)
+          ? command : delimiter.Nucleus ?? ""
+      };
+
+    /// <summary>Closest LaTeX command for a box variant (cancel / phantom / lap / smash),
+    /// picked from the flag matrix.</summary>
+    static string BoxCommandName(Atoms.Box box) {
+      if (box.StrikeStyle != Atoms.StrikeStyle.None) {
+        return box.StrikeStyle switch {
+          Atoms.StrikeStyle.Forward => "cancel",
+          Atoms.StrikeStyle.Backward => "bcancel",
+          Atoms.StrikeStyle.Cross => "xcancel",
+          Atoms.StrikeStyle.Horizontal => "sout",
+          _ => throw new InvalidCodePathException("Unknown strike style"),
+        };
+      }
+      if (!box.DrawChild) {
+        // phantom family
+        return
+          box.KeepWidth && box.KeepHeight && box.KeepDepth ? "phantom" :
+          box.KeepWidth ? "hphantom" : "vphantom";
+      }
+      if (!box.KeepWidth) {
+        // lap family
+        return box.HAlign switch {
+          Atoms.BoxHAlign.Right => "llap",
+          Atoms.BoxHAlign.Center => "clap",
+          _ => "rlap"
+        };
+      }
+      // smash family
+      return
+        !box.KeepHeight && !box.KeepDepth ? "smash" :
+        box.KeepDepth ? @"smash[t]" : @"smash[b]";
+    }
 
     private static void MathListToLaTeX
       (MathList mathList, StringBuilder builder, FontStyle outerFontStyle) {
@@ -506,28 +1057,40 @@ static bool MathAtomToLaTeX(MathAtom atom, StringBuilder builder,
           case Comment { Nucleus: var comment }:
             builder.Append('%').Append(comment).Append('\n');
             break;
-          case Fraction fraction:
-            if (fraction.HasRule) {
-              builder.Append(@"\frac{");
-              MathListToLaTeX(fraction.Numerator, builder, currentFontStyle);
-              builder.Append("}{");
-              MathListToLaTeX(fraction.Denominator, builder, currentFontStyle);
-              builder.Append('}');
-            } else {
-              builder.Append('{');
-              MathListToLaTeX(fraction.Numerator, builder, currentFontStyle);
-              builder.Append(@" \").Append(
-                (fraction.LeftDelimiter, fraction.RightDelimiter) switch {
-                  ( { Nucleus: null }, { Nucleus: null }) => "atop",
-                  ( { Nucleus: "(" }, { Nucleus: ")" }) => "choose",
-                  ( { Nucleus: "{" }, { Nucleus: "}" }) => "brace",
-                  ( { Nucleus: "[" }, { Nucleus: "]" }) => "brack",
-                  (var left, var right) => $"atopwithdelims{BoundaryToLaTeX(left)}{BoundaryToLaTeX(right)}",
-                }).Append(' ');
-              MathListToLaTeX(fraction.Denominator, builder, currentFontStyle);
-              builder.Append('}');
+          case Fraction fraction: {
+              // Style overrides serialize as \displaystyle/\textstyle wrapping each
+              // operand rather than emitting \dfrac directly (lossy round trip).
+              static string Wrap(MathList operand, Atoms.FractionStyle style) {
+                var inner = new StringBuilder();
+                MathListToLaTeX(operand, inner, FontStyle.Default);
+                return style switch {
+                  Atoms.FractionStyle.Display => @"\displaystyle{" + inner + "}",
+                  Atoms.FractionStyle.Text => @"\textstyle{" + inner + "}",
+                  _ => inner.ToString()
+                };
+              }
+              if (fraction.HasRule) {
+                builder.Append(@"\frac{")
+                  .Append(Wrap(fraction.Numerator, fraction.StyleOverride))
+                  .Append("}{")
+                  .Append(Wrap(fraction.Denominator, fraction.StyleOverride))
+                  .Append('}');
+              } else {
+                builder.Append('{');
+                MathListToLaTeX(fraction.Numerator, builder, currentFontStyle);
+                builder.Append(@" \").Append(
+                  (fraction.LeftDelimiter, fraction.RightDelimiter) switch {
+                    ( { Nucleus: null }, { Nucleus: null }) => "atop",
+                    ( { Nucleus: "(" }, { Nucleus: ")" }) => "choose",
+                    ( { Nucleus: "{" }, { Nucleus: "}" }) => "brace",
+                    ( { Nucleus: "[" }, { Nucleus: "]" }) => "brack",
+                    (var left, var right) => $"atopwithdelims{BoundaryToLaTeX(left)}{BoundaryToLaTeX(right)}",
+                  }).Append(' ');
+                MathListToLaTeX(fraction.Denominator, builder, currentFontStyle);
+                builder.Append('}');
+              }
+              break;
             }
-            break;
           case Radical radical:
             builder.Append(@"\sqrt");
             if (radical.Degree.IsNonEmpty()) {
@@ -557,22 +1120,119 @@ static bool MathAtomToLaTeX(MathAtom atom, StringBuilder builder,
             MathListToLaTeX(list, builder, currentFontStyle);
             builder.Append(@"\right").Append(BoundaryToLaTeX(right)).Append(' ');
             break;
+          case Atoms.Stack stack: {
+              // MathList-row stacks emit \overset/\underset/\stackrel/\stackbin;
+              // extensible (stretchy) stacks emit their canonical command; a stack
+              // with both MathList rows emits nested \underset{…}{\overset{…}{…}}.
+              static string? StackCommandName(Atoms.Stack s) {
+                bool overML = s.Over is StackConstruction.MathListRow;
+                bool underML = s.Under is StackConstruction.MathListRow;
+                if (overML && underML) return null;
+                if (underML) return "underset";
+                if (overML) return s.DisplayClassType == typeof(Relation) ? "stackrel"
+                  : s.DisplayClassType == typeof(BinaryOperator) ? "stackbin" : "overset";
+                if (s.Over is StackConstruction.Extensible o) return ExtensibleCommand(o.Glyph, over: true);
+                if (s.Under is StackConstruction.Extensible u) return ExtensibleCommand(u.Glyph, over: false);
+                return null;
+              }
+              static string? ExtensibleCommand(string glyph, bool over) => (glyph, over) switch {
+                ("→", true) => "overrightarrow",
+                ("←", true) => "overleftarrow",
+                ("↔", true) => "overleftrightarrow",
+                ("⏞", true) => "overbrace",
+                ("→", false) => "underrightarrow",
+                ("←", false) => "underleftarrow",
+                ("↔", false) => "underleftrightarrow",
+                ("⏟", false) => "underbrace",
+                _ => null
+              };
+              var name = StackCommandName(stack);
+              if (name == null) {
+                // Programmatically-built stack with non-canonical rows: emit only the inner list.
+                MathListToLaTeX(stack.InnerList, builder, currentFontStyle);
+              } else if (stack.Over is StackConstruction.MathListRow overRow) {
+                builder.Append('\\').Append(name).Append('{');
+                MathListToLaTeX(overRow.List, builder, currentFontStyle);
+                builder.Append("}{");
+                MathListToLaTeX(stack.InnerList, builder, currentFontStyle);
+                builder.Append('}');
+              } else if (stack.Under is StackConstruction.MathListRow underRow) {
+                builder.Append('\\').Append(name).Append('{');
+                MathListToLaTeX(underRow.List, builder, currentFontStyle);
+                builder.Append("}{");
+                MathListToLaTeX(stack.InnerList, builder, currentFontStyle);
+                builder.Append('}');
+              } else {
+                builder.Append('\\').Append(name).Append('{');
+                MathListToLaTeX(stack.InnerList, builder, currentFontStyle);
+                builder.Append('}');
+              }
+              break;
+            }
+          case Atoms.Box box: {
+              builder.Append('\\').Append(BoxCommandName(box)).Append('{');
+              MathListToLaTeX(box.InnerList, builder, currentFontStyle);
+              builder.Append('}');
+              break;
+            }
+          case Atoms.Group group:
+            // Always emit the braces: a Group is an Ord subformula, and dropping
+            // them would make serialization non-idempotent (iosMath 086d345).
+            builder.Append('{');
+            MathListToLaTeX(group.InnerList, builder, currentFontStyle);
+            builder.Append('}');
+            break;
+          case Atoms.Macro macro:
+            builder.Append('\\').Append(macro.Command);
+            if (macro.Arguments.Count == 0) {
+              // Nothing would terminate the command name otherwise.
+              builder.Append(' ');
+            }
+            foreach (var argument in macro.Arguments) {
+              builder.Append('{').Append(argument).Append('}');
+            }
+            break;
+          case Atoms.LargeDelimiter large:
+            var prefix = large.Size switch {
+              Atoms.LargeDelimiter.DelimiterSize.Size1 => "big",
+              Atoms.LargeDelimiter.DelimiterSize.Size2 => "Big",
+              Atoms.LargeDelimiter.DelimiterSize.Size3 => "bigg",
+              _ => "Bigg"
+            };
+            var suffix = large.MathClass == typeof(Atoms.Open) ? "l" :
+              large.MathClass == typeof(Atoms.Close) ? "r" :
+              large.MathClass == typeof(Atoms.Relation) ? "m" : "";
+            builder.Append('\\').Append(prefix).Append(suffix)
+              .Append(large.Nucleus.Length == 0 ? "." : BoundaryToLaTeX(new Boundary(large.Nucleus)));
+            break;
           case Table table:
             if (table.Environment != null) {
               builder.Append(@"\begin{" + table.Environment + "}");
-            }
-            if (table.Environment == "array") {
-              builder.Append('{');
-              foreach (var alignment in table.Alignments)
-                builder.Append(alignment switch {
-                  ColumnAlignment.Left => 'l',
-                  ColumnAlignment.Right => 'r',
-                  _ => 'c'
-                });
-              builder.Append('}');
+              if (table.Environment == "alignedat") {
+                builder.Append('{').Append(table.NColumns / 2).Append('}');
+              } else if (table.Environment == "array") {
+                // Reconstruct the column spec: |count then l/c/r per column.
+                builder.Append('{');
+                for (int i = 0; i <= table.NColumns; i++) {
+                  for (int k = i < table.VerticalLines.Count ? table.VerticalLines[i] : 0; k > 0; k--)
+                    builder.Append('|');
+                  if (i < table.NColumns && i < table.Alignments.Count) {
+                    builder.Append(table.Alignments[i] switch {
+                      ColumnAlignment.Left => 'l',
+                      ColumnAlignment.Right => 'r',
+                      _ => 'c'
+                    });
+                  }
+                }
+                builder.Append('}');
+              }
             }
             for (int i = 0; i < table.NRows; i++) {
               var row = table.Cells[i];
+              if (table.Environment == "array" && i < table.HorizontalLines.Count) {
+                for (int k = table.HorizontalLines[i]; k > 0; k--)
+                  builder.Append(@"\hline ");
+              }
               for (int j = 0; j < row.Count; j++) {
                 var cell = row[j];
                 if (table.Environment == "matrix"
@@ -594,15 +1254,34 @@ static bool MathAtomToLaTeX(MathAtom atom, StringBuilder builder,
                   // empty nucleus added for spacing. Remove it.
                   cell = cell.Slice(1, cell.Count - 1);
                 }
+                if (table.Environment == "alignedat"
+                    && j % 2 == 1
+                    && cell.Count >= 1
+                    && cell[0] is Ordinary ordAt
+                    && string.IsNullOrEmpty(ordAt.Nucleus)) {
+                  // empty nucleus added for spacing. Remove it.
+                  cell = cell.Slice(1, cell.Count - 1);
+                }
                 MathListToLaTeX(cell, builder, currentFontStyle);
                 if (j < row.Count - 1) {
                   builder.Append('&');
                 }
               }
-              if (i < table.NRows - 1) {
+              bool lastRow = i == table.NRows - 1;
+              int bottomHLines = table.Environment == "array"
+                && lastRow && i < table.HorizontalLines.Count ? table.HorizontalLines[i] : 0;
+              if (!lastRow) {
+                builder.Append(@"\\ ");
+              } else if (bottomHLines > 0) {
+                // A bottom \hline needs a row terminator before it.
                 builder.Append(@"\\ ");
               }
             }
+            if (table.Environment == "array"
+                && table.NRows < table.HorizontalLines.Count) {
+              for (int k = table.HorizontalLines[table.NRows]; k > 0; k--)
+                builder.Append(@"\hline ");
+            }
             if (table.Environment != null) {
               builder.Append(@"\end{")
                 .Append(table.Environment)
@@ -731,4 +1410,4 @@ public static StringBuilder MathListToLaTeX(MathList mathList, StringBuilder? sb
       return sb;
     }
   }
-}
\ No newline at end of file
+}
diff --git a/CSharpMath/Atom/LaTeXSettings.cs b/CSharpMath/Atom/LaTeXSettings.cs
index 3ef5599a..df755ffb 100644
--- a/CSharpMath/Atom/LaTeXSettings.cs
+++ b/CSharpMath/Atom/LaTeXSettings.cs
@@ -52,8 +52,8 @@ public static class LaTeXSettings {
         { @"\rfloor", new Boundary("⌋") },
         { @"\lceil", new Boundary("⌈") },
         { @"\rceil", new Boundary("⌉") },
-        { @"<", @"\langle", new Boundary("〈") },
-        { @">", @"\rangle", new Boundary("〉") },
+        { @"<", @"\langle", new Boundary("\u2329") },
+        { @">", @"\rangle", new Boundary("\u232A") },
         { @"/", new Boundary("/") },
         { @"\\", @"backslash", new Boundary("\\") },
         { @"|", @"\vert", new Boundary("|") },
@@ -130,19 +130,22 @@ public static class LaTeXSettings {
           return Ok(new Comment(parser.Chars.Substring(index, length)));
         } },
         { @"\frac", (parser, accumulate, stopChar) =>
-          parser.ReadArgument().Bind(numerator =>
-            parser.ReadArgument().Bind(denominator =>
-              Ok(new Fraction(numerator, denominator)))) },
+          LaTeXParser.FractionMacro(parser, "frac") },
         { @"\binom", (parser, accumulate, stopChar) =>
-          parser.ReadArgument().Bind(numerator =>
-            parser.ReadArgument().Bind(denominator =>
-              Ok(new Fraction(numerator, denominator, false) {
-                LeftDelimiter = new Boundary("("),
-                RightDelimiter = new Boundary(")")
-              }))) },
+          LaTeXParser.FractionMacro(parser, "binom") },
+        { @"\dfrac", (parser, accumulate, stopChar) =>
+          LaTeXParser.FractionMacro(parser, "dfrac") },
+        { @"\tfrac", (parser, accumulate, stopChar) =>
+          LaTeXParser.FractionMacro(parser, "tfrac") },
+        { @"\dbinom", (parser, accumulate, stopChar) =>
+          LaTeXParser.FractionMacro(parser, "dbinom") },
+        { @"\tbinom", (parser, accumulate, stopChar) =>
+          LaTeXParser.FractionMacro(parser, "tbinom") },
+        { @"\cfrac", (parser, accumulate, stopChar) =>
+          LaTeXParser.FractionMacro(parser, "cfrac") },
         { @"\sqrt", (parser, accumulate, stopChar) =>
           parser.ReadArgumentOptional().Bind(degree =>
-            parser.ReadArgument().Bind(radicand =>
+            LaTeXSettings.TolerantArgument(parser).Bind(radicand =>
               Ok(new Radical(degree ?? new MathList(), radicand)))) },
         { @"\left", (parser, accumulate, stopChar) =>
           parser.ReadDelimiter("left").Bind(left => {
@@ -156,6 +159,37 @@ public static class LaTeXSettings {
               return Ok(new Inner(left, innerList, right));
             });
           }) },
+        #region Over/under stack commands
+        { @"\overrightarrow", (parser, accumulate, stopChar) => LaTeXParser.StackAtomForCommand(parser, "overrightarrow") },
+        { @"\overleftarrow", (parser, accumulate, stopChar) => LaTeXParser.StackAtomForCommand(parser, "overleftarrow") },
+        { @"\overleftrightarrow", (parser, accumulate, stopChar) => LaTeXParser.StackAtomForCommand(parser, "overleftrightarrow") },
+        { @"\underrightarrow", (parser, accumulate, stopChar) => LaTeXParser.StackAtomForCommand(parser, "underrightarrow") },
+        { @"\underleftarrow", (parser, accumulate, stopChar) => LaTeXParser.StackAtomForCommand(parser, "underleftarrow") },
+        { @"\underleftrightarrow", (parser, accumulate, stopChar) => LaTeXParser.StackAtomForCommand(parser, "underleftrightarrow") },
+        { @"\overbrace", (parser, accumulate, stopChar) => LaTeXParser.StackAtomForCommand(parser, "overbrace") },
+        // \underbrace stays registered as an UnderAnnotation symbol below.
+        { @"\overset", (parser, accumulate, stopChar) => LaTeXParser.StackAtomForCommand(parser, "overset") },
+        { @"\underset", (parser, accumulate, stopChar) => LaTeXParser.StackAtomForCommand(parser, "underset") },
+        { @"\stackrel", (parser, accumulate, stopChar) => LaTeXParser.StackAtomForCommand(parser, "stackrel") },
+        { @"\stackbin", (parser, accumulate, stopChar) => LaTeXParser.StackAtomForCommand(parser, "stackbin") },
+        #endregion
+        #region Box commands: phantom/smash/lap + cancel family
+        { @"\phantom", (parser, accumulate, stopChar) => LaTeXParser.BoxAtomForCommand(parser, "phantom") },
+        { @"\hphantom", (parser, accumulate, stopChar) => LaTeXParser.BoxAtomForCommand(parser, "hphantom") },
+        { @"\vphantom", (parser, accumulate, stopChar) => LaTeXParser.BoxAtomForCommand(parser, "vphantom") },
+        { @"\mathstrut", (parser, accumulate, stopChar) => LaTeXParser.BoxAtomForCommand(parser, "mathstrut") },
+        { @"\smash", (parser, accumulate, stopChar) => LaTeXParser.BoxAtomForCommand(parser, "smash") },
+        { @"\llap", (parser, accumulate, stopChar) => LaTeXParser.BoxAtomForCommand(parser, "llap") },
+        { @"\rlap", (parser, accumulate, stopChar) => LaTeXParser.BoxAtomForCommand(parser, "rlap") },
+        { @"\clap", (parser, accumulate, stopChar) => LaTeXParser.BoxAtomForCommand(parser, "clap") },
+        { @"\mathllap", (parser, accumulate, stopChar) => LaTeXParser.BoxAtomForCommand(parser, "mathllap") },
+        { @"\mathrlap", (parser, accumulate, stopChar) => LaTeXParser.BoxAtomForCommand(parser, "mathrlap") },
+        { @"\mathclap", (parser, accumulate, stopChar) => LaTeXParser.BoxAtomForCommand(parser, "mathclap") },
+        { @"\cancel", (parser, accumulate, stopChar) => LaTeXParser.BoxAtomForCommand(parser, "cancel") },
+        { @"\bcancel", (parser, accumulate, stopChar) => LaTeXParser.BoxAtomForCommand(parser, "bcancel") },
+        { @"\xcancel", (parser, accumulate, stopChar) => LaTeXParser.BoxAtomForCommand(parser, "xcancel") },
+        { @"\sout", (parser, accumulate, stopChar) => LaTeXParser.BoxAtomForCommand(parser, "sout") },
+        #endregion
         { @"\overline", (parser, accumulate, stopChar) =>
           parser.ReadArgument().Bind(mathList => Ok(new Overline(mathList))) },
         { @"\underline", (parser, accumulate, stopChar) =>
@@ -166,25 +200,39 @@ public static class LaTeXSettings {
         { @"\begin", (parser, accumulate, stopChar) =>
           parser.ReadEnvironment().Bind(env =>
             parser.ReadTable(env, null, false, stopChar)).Bind(Ok) },
+        // \color and its 2-argument alias \textcolor
         { @"\color", (parser, accumulate, stopChar) =>
           parser.ReadColor().Bind(
             color => parser.ReadArgument().Bind(
             colored => Ok(new Colored(color, colored)))) },
+        { @"\textcolor", (parser, accumulate, stopChar) =>
+          parser.ReadColor().Bind(
+            color => parser.ReadArgument().Bind(
+            colored => Ok(new Colored(color, colored)))) },
         { @"\colorbox", (parser, accumulate, stopChar) =>
           parser.ReadColor().Bind(
             color => parser.ReadArgument().Bind(
             colored => Ok(new ColorBox(color, colored)))) },
         { @"\prime", (parser, accumulate, stopChar) =>
           Err(@"\prime won't be supported as Unicode has no matching character. Use ' instead.") },
+        #region Spacing commands: kern/hspace/skip family
         { @"\kern", (parser, accumulate, stopChar) =>
-          parser.TextMode ? parser.ReadSpace().Bind(kern => Ok(new Space(kern))) : @"\kern is not allowed in math mode" },
+          parser.ReadSpace().Bind(kern => Ok(new Space(kern))) },
         { @"\hskip", (parser, accumulate, stopChar) =>
 //TODO \hskip and \mskip: Implement plus and minus for expansion
-          parser.TextMode ? parser.ReadSpace().Bind(skip => Ok(new Space(skip))) : @"\hskip is not allowed in math mode" },
+          parser.ReadSpace().Bind(skip => Ok(new Space(skip))) },
+        { @"\hspace", (parser, accumulate, stopChar) => {
+          if (!parser.ReadCharIfAvailable('{')) return "Expected {";
+          return parser.ReadSpace().Bind(space => {
+            if (!parser.ReadCharIfAvailable('}')) return "Expected }";
+            return Ok(new Space(space));
+          });
+        } },
         { @"\mkern", (parser, accumulate, stopChar) =>
           !parser.TextMode ? parser.ReadSpace().Bind(kern => Ok(new Space(kern))) : @"\mkern is not allowed in text mode" },
         { @"\mskip", (parser, accumulate, stopChar) =>
           !parser.TextMode ? parser.ReadSpace().Bind(skip => Ok(new Space(skip))) : @"\mskip is not allowed in text mode" },
+        #endregion
         { @"\raisebox", (parser, accumulate, stopChar) => {
           if (!parser.ReadCharIfAvailable('{')) return "Expected {";
           return parser.ReadSpace().Bind(raise => {
@@ -255,15 +303,39 @@ public static class LaTeXSettings {
           return parser.ReadArgument(prevAtom.Subscript).Bind(_ => Ok(null));
         } },
         { @"{", (parser, accumulate, stopChar) => {
+            System.Func<MathList, Result<(MathAtom?, MathList?)>> wrapOrFlatten = sublist => {
+              if (parser.Environments.PeekOrDefault() is LaTeXParser.TableEnvironment { Name: null }) {
+                // \\ or \cr which do not have a corresponding \end
+                var oldEnv = parser.Environments.Pop();
+                parser.Environments.Push(oldEnv);
+                return LaTeXSettings.OkStyled(sublist);
+              }
+              if (parser.GroupWasTransformedByStopCommand) {
+                // A group-transformation command (\over/\atop/…) fired inside this
+                // group: the fraction replaces the group (TeX behavior), no wrapping.
+                // (The getter reads-and-clears, so an inner transform never leaks
+                // into an enclosing group's decision.)
+                return LaTeXSettings.OkStyled(sublist);
+              }
+              if (parser.IsReadingOneCharField || parser.IsReadingStopCharField) {
+                // Field brace (^{…}, _{…}, \frac{…}, command argument): the {…} *is*
+                // the field. Flatten and return it as the field.
+                return LaTeXSettings.OkStyled(sublist);
+              }
+              // Grouping brace in the main list: wrap as an Ord subformula so style
+              // nodes are scoped, scripts target the whole group, and Bin/Ord
+              // reclassification stops at the brace boundary.
+              return Ok(new Group { InnerList = sublist });
+            };
             if (parser.Environments.PeekOrDefault() is LaTeXParser.TableEnvironment { Name: null }) {
               // \\ or \cr which do not have a corresponding \end
               var oldEnv = parser.Environments.Pop();
               return parser.ReadUntil('}').Bind(sublist => {
                 parser.Environments.Push(oldEnv);
-                return OkStyled(sublist);
+                return wrapOrFlatten(sublist);
               });
             } else {
-              return parser.ReadUntil('}').Bind(OkStyled);
+              return parser.ReadUntil('}').Bind(wrapOrFlatten);
             }
         } },
         { @"}", (parser, accumulate, stopChar) => "Missing opening brace" },
@@ -285,26 +357,54 @@ public static class LaTeXSettings {
           parser.Environments.PeekOrDefault() is LaTeXParser.TableEnvironment
           ? OkStop(accumulate)
           : parser.ReadTable(null, accumulate, false, stopChar).Bind(table => OkStop(new MathList(table))) },
-        { @"\over", (parser, accumulate, stopChar) =>
-          parser.ReadUntil(stopChar).Bind(denominator =>
-            OkStop(new MathList(new Fraction(accumulate, denominator)))) },
-        { @"\atop", (parser, accumulate, stopChar) =>
-          parser.ReadUntil(stopChar).Bind(denominator =>
-            OkStop(new MathList(new Fraction(accumulate, denominator, false)))) },
-        { @"\choose", (parser, accumulate, stopChar) =>
-          parser.ReadUntil(stopChar).Bind(denominator =>
-            OkStop(new MathList(new Fraction(accumulate, denominator, false) { LeftDelimiter = new Boundary("("), RightDelimiter = new Boundary(")") }))) },
-        { @"\brack", (parser, accumulate, stopChar) =>
-          parser.ReadUntil(stopChar).Bind(denominator =>
-            OkStop(new MathList(new Fraction(accumulate, denominator, false) { LeftDelimiter = new Boundary("["), RightDelimiter = new Boundary("]") }))) },
-        { @"\brace", (parser, accumulate, stopChar) =>
-          parser.ReadUntil(stopChar).Bind(denominator =>
-            OkStop(new MathList(new Fraction(accumulate, denominator, false) { LeftDelimiter = new Boundary("{"), RightDelimiter = new Boundary("}") }))) },
-        { @"\atopwithdelims", (parser, accumulate, stopChar) =>
-          parser.ReadDelimiter(@"atopwithdelims").Bind(left =>
-            parser.ReadDelimiter(@"atopwithdelims").Bind(right =>
-              parser.ReadUntil(stopChar).Bind(denominator =>
-                OkStop(new MathList(new Fraction(accumulate, denominator, false) { LeftDelimiter = left, RightDelimiter = right }))))) },
+        { @"\over", (parser, accumulate, stopChar) => {
+            // iosMath 801af6f: \over/\atop/\choose/\brack/\brace are illegal in a
+            // one-character argument slot (e.g. x^\over y); TeX rejects it too.
+            if (parser.IsReadingOneCharField)
+              return $@"\over cannot be used in a one-character argument; wrap it in braces, e.g. x^{{a \over b}}";
+            parser.GroupWasTransformedByStopCommand = true;
+            return parser.ReadUntil(stopChar).Bind(denominator =>
+              OkStop(new MathList(new Fraction(accumulate, denominator))));
+          } },
+        { @"\atop", (parser, accumulate, stopChar) => {
+            if (parser.IsReadingOneCharField)
+              return $@"\atop cannot be used in a one-character argument; wrap it in braces, e.g. x^{{a \atop b}}";
+            parser.GroupWasTransformedByStopCommand = true;
+            return parser.ReadUntil(stopChar).Bind(denominator =>
+              OkStop(new MathList(new Fraction(accumulate, denominator, false))));
+          } },
+        { @"\choose", (parser, accumulate, stopChar) => {
+            if (parser.IsReadingOneCharField)
+              return $@"\choose cannot be used in a one-character argument; wrap it in braces, e.g. x^{{a \choose b}}";
+            parser.GroupWasTransformedByStopCommand = true;
+            return parser.ReadUntil(stopChar).Bind(denominator =>
+              OkStop(new MathList(new Fraction(accumulate, denominator, false)
+                { LeftDelimiter = new Boundary("("), RightDelimiter = new Boundary(")") })));
+          } },
+        { @"\brack", (parser, accumulate, stopChar) => {
+            if (parser.IsReadingOneCharField)
+              return $@"\brack cannot be used in a one-character argument; wrap it in braces, e.g. x^{{a \brack b}}";
+            parser.GroupWasTransformedByStopCommand = true;
+            return parser.ReadUntil(stopChar).Bind(denominator =>
+              OkStop(new MathList(new Fraction(accumulate, denominator, false)
+                { LeftDelimiter = new Boundary("["), RightDelimiter = new Boundary("]") })));
+          } },
+        { @"\brace", (parser, accumulate, stopChar) => {
+            if (parser.IsReadingOneCharField)
+              return $@"\brace cannot be used in a one-character argument; wrap it in braces, e.g. x^{{a \brace b}}";
+            parser.GroupWasTransformedByStopCommand = true;
+            return parser.ReadUntil(stopChar).Bind(denominator =>
+              OkStop(new MathList(new Fraction(accumulate, denominator, false)
+                { LeftDelimiter = new Boundary("{"), RightDelimiter = new Boundary("}") })));
+          } },
+        { @"\atopwithdelims", (parser, accumulate, stopChar) => {
+            parser.GroupWasTransformedByStopCommand = true;
+            return parser.ReadDelimiter(@"atopwithdelims").Bind(left =>
+              parser.ReadDelimiter(@"atopwithdelims").Bind(right =>
+                parser.ReadUntil(stopChar).Bind(denominator =>
+                  OkStop(new MathList(new Fraction(accumulate, denominator, false)
+                    { LeftDelimiter = left, RightDelimiter = right })))));
+          } },
         { @"\right", (parser, accumulate, stopChar) => {
           while (parser.Environments.PeekOrDefault() is LaTeXParser.TableEnvironment table)
             if (table.Name is null) {
@@ -346,6 +446,138 @@ public static class LaTeXSettings {
       };
     public static MathAtom Times => new BinaryOperator("×");
     public static MathAtom Divide => new BinaryOperator("÷");
+
+    /// <summary>Built-in macros: command name → (argument count, LaTeX template with
+    /// #N placeholders). Each entry is amsmath's inline expansion. Populated once at
+    /// startup; <see cref="AddMacro"/> mutates it and must not race a live parse.</summary>
+    private static readonly Dictionary<string, (int argc, string template)>
+      MacroDefinitions = new Dictionary<string, (int, string)> {
+        // amsmath's exact inline expansion. Not reproduced is the \if@display switch
+        // to an 18mu leading gap, because a macro expands at parse time before the
+        // render style is known.
+        ["pmod"] = (1, @"\mkern8mu(\mathrm{mod}\mkern6mu#1)"),
+        ["mod"] = (1, @"\mkern12mu\mathrm{mod}\mkern6mu#1"),
+        ["pod"] = (1, @"\mkern8mu(#1)"),
+        // amsmath pads all three with \; on both sides; a bare arrow alias renders tighter.
+        ["implies"] = (0, @"\;\Longrightarrow\;"),
+        ["impliedby"] = (0, @"\;\Longleftarrow\;"),
+        ["iff"] = (0, @"\;\Longleftrightarrow\;"),
+        ["idotsint"] = (0, @"\int\cdots\int"),
+        // amsmath builds these out of \mathop which we have no command for; the symbol
+        // is right but scripts land to the side instead of centred underneath.
+        ["varliminf"] = (0, @"\underline{\lim}"),
+        ["varlimsup"] = (0, @"\overline{\lim}"),
+        ["varinjlim"] = (0, @"\underrightarrow{\lim}"),
+        ["varprojlim"] = (0, @"\underleftarrow{\lim}"),
+      };
+    private static readonly object MacroRegistryLock = new object();
+
+    /// <summary>Defines a macro: a command that expands to <paramref name="template"/>
+    /// with <c>#1</c>…<c>#9</c> replaced by the arguments it is invoked with. Macros are
+    /// looked up before every other command table, so registering a name that already
+    /// exists — a macro or a built-in command — shadows it. Re-registering the same
+    /// name replaces the definition. Carries the same setup-time contract as the
+    /// symbol tables: do not call this while parsing on another thread.</summary>
+    public static void AddMacro(string name, int argumentCount, string template) {
+      if (name == null) throw new ArgumentNullException(nameof(name));
+      if (template == null) throw new ArgumentNullException(nameof(template));
+      if (argumentCount < 0 || argumentCount > 9)
+        throw new ArgumentException($@"\{name} declares {argumentCount} arguments; a macro can take at most 9", nameof(argumentCount));
+      if (!TemplateReferencesOnlyArgumentsUpTo(template, argumentCount))
+        throw new ArgumentException(
+          $@"Template for \{name} references an argument beyond its {argumentCount} declared argument(s): {template}",
+          nameof(template));
+      lock (MacroRegistryLock) MacroDefinitions[name] = (argumentCount, template);
+    }
+
+    /// <summary>Whether every #N reference in the template names an argument within the declared arity.</summary>
+    static bool TemplateReferencesOnlyArgumentsUpTo(string templateString, int argumentCount) {
+      for (int i = 0; i < templateString.Length; i++) {
+        if (templateString[i] != '#') continue;
+        if (i + 1 >= templateString.Length) return false;
+        char digit = templateString[i + 1];
+        if (digit == '#') { i++; continue; }
+        if (digit < '1' || digit > '9' || digit - '0' > argumentCount) return false;
+        i++;
+      }
+      return true;
+    }
+    private static string SpliceTemplate(string template, IReadOnlyList<string> arguments) {
+      var output = new StringBuilder();
+      for (var i = 0; i < template.Length; i++) {
+        if (template[i] != '#') { output.Append(template[i]); continue; }
+        var next = template[++i];
+        if (next == '#') output.Append('#');
+        else output.Append(arguments[next - '1']);
+      }
+      return output.ToString();
+    }
+
+    internal static Result<(MathAtom? Atom, MathList? Return)> MacroAtomForCommand(
+      LaTeXParser parser, string command) {
+      (int argc, string template) def;
+      lock (MacroRegistryLock) {
+        if (!MacroDefinitions.TryGetValue(command, out def)) return Ok(null);
+      }
+      if (def.template == null) {
+        return Ok(null);
+      }
+      var rawArguments = new List<string>();
+      for (int i = 0; i < def.argc; i++) {
+        var (raw, rawError) = parser.ReadRawArgument();
+        if (rawError != null) return rawError;
+        rawArguments.Add(raw);
+      }
+      var expansionParser = new LaTeXParser(SpliceTemplate(def.template, rawArguments));
+      expansionParser.CurrentFontStyle = parser.CurrentFontStyle;
+      expansionParser.MacroExpansionDepth = parser.MacroExpansionDepth + 1;
+      if (expansionParser.MacroExpansionDepth > 32) return Err($@"Macro expansion depth exceeded while expanding \{command}");
+      var (rawExpansion, expansionError) = expansionParser.Build();
+      if (expansionError != null || rawExpansion == null)
+        return Err($@"Expansion of \{command} failed to parse: {expansionError}");
+      return Ok(new Atoms.Macro(command, rawArguments, rawExpansion));
+    }
+    internal static bool IsBuiltinMacro(string command) {
+      lock (MacroRegistryLock) return MacroDefinitions.ContainsKey(command);
+    }
+
+    /// <summary>Reads a macro argument, erroring on EOF or a `}`/`^`/`_`/`&`/stop-command
+    /// where the argument should be. An empty `{}` is a valid empty argument.</summary>
+    private static Result<MathList> RequiredArgument(LaTeXParser parser) {
+      parser.SkipSpaces();
+      if (!parser.HasCharacters) {
+        return "Missing required argument at end of input";
+      }
+      switch (parser.PeekChar()) {
+        case '}' or '^' or '_' or '&':
+          return $@"Missing required argument before '{parser.PeekChar()}'";
+        case '\\':
+          var saveChar = parser.NextChar;
+          var command = parser.ReadCommandName();
+          parser.UndoTo(saveChar);
+          if (StopCommands.Contains(command)) {
+            return $@"Missing required argument before \{command}";
+          }
+          break;
+      }
+      return parser.ReadArgument();
+    }
+
+    /// <summary>Reads an atom's argument, tolerating EOF or an immediate closing brace
+    /// by yielding an empty list (iosMath da9abdd: a lone \sqrt must not crash).</summary>
+    internal static Result<MathList> TolerantArgument(LaTeXParser parser) {
+      parser.SkipSpaces();
+      if (!parser.HasCharacters || parser.PeekChar() == '}') {
+        return new Result<MathList>(new MathList());
+      }
+      return parser.ReadArgument();
+    }
+
+    /// <summary>Every command that ends the enclosing list rather than producing an atom.
+    /// None can begin a macro argument.</summary>
+    private static readonly HashSet<string> StopCommands =
+      new HashSet<string> { "right", "over", "atop", "choose", "brack", "brace", @"\\", "cr", "end" };
+
     public static bool PlaceholderBlinks { get; set; }
     public static Color? PlaceholderRestingColor { get; set; }
     public static Color? PlaceholderActiveColor { get; set; }
@@ -389,6 +621,13 @@ public static class LaTeXSettings {
       if (hexOrName == null) return null;
       if (hexOrName.StartsWith("#", StringComparison.Ordinal)) {
         var hex = hexOrName.Substring(1);
+        // Expand the CSS 3-digit shorthand #RGB to #RRGGBB (e.g. "f00" to "ff0000").
+        if (hex.Length == 3) {
+          hex = string.Concat(
+            hex[0].ToStringInvariant(), hex[0],
+            hex[1].ToStringInvariant(), hex[1],
+            hex[2].ToStringInvariant(), hex[2]);
+        }
         return
           (hex.Length, int.TryParse(hex, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var i)) switch {
             (8, true) => Color.FromArgb(i),
@@ -464,6 +703,10 @@ atom is Accent accent
         { @"\diameter", new Ordinary("\u2300") },
         { @"\npreccurlyeq", new Relation("⋠") },
         { @"\nsucccurlyeq", new Relation("⋡") },
+        // Aliases from the amssymb batch (iosMath 48f6fca)
+        { @"\restriction", new Relation("↾") }, // alias of \upharpoonright
+        { @"\dotsc", new Punctuation("…") }, // alias of \ldots
+        { @"\dotsm", new Ordinary("⋯") }, // alias of \cdots
         { @"\iint", new LargeOperator("∬", false) },
         { @"\iiint", new LargeOperator("∭", false) },
         { @"\iiiint", new LargeOperator("⨌", false) },
@@ -520,8 +763,8 @@ atom is Accent accent
         { @"\rceil", new Close("⌉") },
         { @"\lfloor", new Open("⌊") },
         { @"\rfloor", new Close("⌋") },
-        { @"\langle", new Open("〈") },
-        { @"\rangle", new Close("〉") },
+        { @"\langle", new Open("\u2329") },
+        { @"\rangle", new Close("\u232A") },
         { @"\lgroup", new Open("⟮") },
         { @"\rgroup", new Close("⟯") },
         { @"\ulcorner", new Open("⌜") },
@@ -542,6 +785,13 @@ atom is Accent accent
         { @"\enspace", new Space(Length.EmWidth / 2) },
         { @"\quad", new Space(Length.EmWidth) },
         { @"\qquad", new Space(Length.EmWidth * 2) },
+        // amsmath's named spacing forms (the stretch components are dropped).
+        { @"\thinspace", new Space(Length.ShortSpace) },
+        { @"\medspace", new Space(Length.MediumSpace) },
+        { @"\thickspace", new Space(Length.LongSpace) },
+        { @"\negthinspace", new Space(-Length.ShortSpace) },
+        { @"\negmedspace", new Space(-Length.MediumSpace) },
+        { @"\negthickspace", new Space(-Length.LongSpace) },
         { @"\displaystyle", new Style(LineStyle.Display) },
         { @"\textstyle", new Style(LineStyle.Text) },
         { @"\scriptstyle", new Style(LineStyle.Script) },
@@ -776,8 +1026,8 @@ atom is Accent accent
         { @"=", new Relation("=") },
         { @"\vdash", new Relation("⊢") },
         { @"\dashv", new Relation("⊣") },
-        { @"<", new Relation("<") },
-        { @">", new Relation(">") },
+        { @"<", @"\lt", new Relation("<") },
+        { @">", @"\gt", new Relation(">") },
         { @":", new Relation("∶") }, // Colon is a ratio. Regular colon is \colon
         
         // Table 9: Punctuation Symbols
@@ -934,14 +1184,12 @@ atom is Accent accent
         // Table 17: Some Other Constructions
         { @"\widehat", new Accent("\u0302") },
         { @"\widetilde", new Accent("\u0303") },
-        { @"\underbrace", new UnderAnnotation("\u23df", new MathList())},
-        // TODO: implement \overleftarrow, \overrightarrow, \overbrace, \underbrace
+        { @"\underbrace", new UnderAnnotation("\u23df", new MathList())}, // _ attaches an under-list (pre-port behavior)
+        // \overbrace and the other over/under commands are handled by the Stack atom
+        // handlers above (iosMath 43626a4).
+        // TODO: implement \overleftarrow, \overrightarrow
         // \overleftarrow{}
         // \overrightarrow{}
-        // \overline{}
-        // \underline{}
-        // \overbrace{}
-        // \underbrace{}
         // \sqrt{}
         // \sqrt[]{}
         { @"'", new Ordinary("′") },
@@ -1189,4 +1437,4 @@ atom is Accent accent
         // \varsupsetneqq -> ⫌ + U+FE00 (Variation Selector 1) Not dealing with variation selectors, thank you very much
       };
   }
-}
\ No newline at end of file
+}
diff --git a/CSharpMath/Atom/Length.cs b/CSharpMath/Atom/Length.cs
index 58ca7fd2..2967475c 100644
--- a/CSharpMath/Atom/Length.cs
+++ b/CSharpMath/Atom/Length.cs
@@ -24,14 +24,15 @@ public static Result<Length> Create(string length, string unit, bool useTextUnit
         System.Globalization.CultureInfo.InvariantCulture.NumberFormat,
         out var value)
       ? "Invalid length value"
-      : useTextUnits
-      ? unit switch {
-        "mu" => "The length unit mu is not allowed in text mode",
+      // em is allowed in both modes (iosMath f644371: \kern1em == 18mu in math mode);
+      // mu stays text-mode-only because a math unit has no meaning in text.
+      : useTextUnits && unit == "mu"
+      ? "The length unit mu is not allowed in text mode"
+      : unit switch {
+        "mu" => MathUnit * value,
         var _ when PredefinedLengthUnits.TryGetValue(unit, out var space) => space * value,
         _ => $"Unsupported length unit {unit}",
-      } : unit != "mu"
-      ? "Only the length unit mu is allowed in math mode"
-      : (Result<Length>)(MathUnit * value);
+      };
     private static bool UnifyIsMu(Length left, Length right) =>
       left.IsMu && right.IsMu
       || (left.IsMu || right.IsMu
diff --git a/CSharpMath/Atom/MathAtom.cs b/CSharpMath/Atom/MathAtom.cs
index 4b060e15..1496ef33 100644
--- a/CSharpMath/Atom/MathAtom.cs
+++ b/CSharpMath/Atom/MathAtom.cs
@@ -16,10 +16,10 @@ public string TypeName {
     }
     public virtual string DebugString =>
       new StringBuilder(Nucleus).AppendDebugStringOfScripts(this).ToString();
-    public string Nucleus { get; set; }
+    public virtual string Nucleus { get; set; }
     public MathList Superscript { get; private set; }
     public MathList Subscript { get; private set; }
-    public FontStyle FontStyle { get; set; }
+    public virtual FontStyle FontStyle { get; set; }
     /// <summary>Defaults to zero, only has a value after finalization</summary>
     public Range IndexRange { get; set; }
 
@@ -90,4 +90,4 @@ public bool EqualsAtom(MathAtom otherAtom) =>
     bool IEquatable<MathAtom>.Equals(MathAtom otherAtom) => EqualsAtom(otherAtom);
     public override int GetHashCode() => (Superscript, Subscript, Nucleus).GetHashCode();
   }
-}
\ No newline at end of file
+}
diff --git a/CSharpMath/Atom/MathList.cs b/CSharpMath/Atom/MathList.cs
index d3869673..d9d40674 100644
--- a/CSharpMath/Atom/MathList.cs
+++ b/CSharpMath/Atom/MathList.cs
@@ -1,9 +1,11 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace CSharpMath.Atom {
   using Atoms;
+  using MacroAtom = Atoms.Macro;
 #pragma warning disable CA1710 // Identifiers should have correct suffix
   // WTF CA1710, you want types inheriting IList to have the Collection suffix?
   class DisabledMathList : MathList {
@@ -14,6 +16,9 @@ internal DisabledMathList() { }
   public class MathList : IMathObject, IList<MathAtom>, IReadOnlyList<MathAtom>, IEquatable<MathList> {
 #pragma warning restore CA1710 // Identifiers should have correct suffix
     public List<MathAtom> Atoms { get; private set; }
+    /// <summary>A new list with every top-level macro replaced by its raw expansion.
+    /// Non-macro atoms are carried over by reference.</summary>
+    internal MathList MacroExpand() => MacroAtom.ExpandMacros(this);
     public MathList() => Atoms = new List<MathAtom>();
     public MathList(IEnumerable<MathAtom> atoms) => Atoms = new List<MathAtom>(atoms);
     public MathList(params MathAtom[] atoms) => Atoms = new List<MathAtom>(atoms);
@@ -53,12 +58,43 @@ public MathList Clone(bool finalize) {
         foreach (var atom in Atoms)
           newList.Add(atom.Clone(finalize));
       } else {
+        // Macros are expanded first, so the reclassifying pass sees the flat stream
+        // a macro stands for rather than the macro atom itself.
+        if (Atoms.Any(a => a is MacroAtom))
+          return MacroExpand().Clone(true);
         MathAtom? prevNode = null;
         int prevDisplayedIndex = -1;
         foreach (var atom in Atoms) {
           var newNode = atom.Clone(finalize);
-          if (newNode.IndexRange == Range.Zero)
-            newNode.IndexRange = new Range(prevNode is { } prev ? prev.IndexRange.Location + prev.IndexRange.Length : 0, 1);
+          // A Group wrapping a single atom — or a single parenthesized Inner — is
+          // pure grouping: dissolve it and hoist the group's scripts onto the atom.
+          // This keeps AngouriMath's braced output ({\sin x}^{1}) rendering and
+          // serializing identically to the pre-grouping parser. Multi-atom groups
+          // stay, preserving TeX ordgroup semantics (iosMath 086d345).
+          if (newNode is Group wrapper
+            && wrapper.InnerList.Count == 1
+            && wrapper.InnerList[0] is { } only
+            && only.Superscript.IsEmpty() && only.Subscript.IsEmpty()) {
+            only.Superscript.Append(wrapper.Superscript.Clone(false));
+            only.Subscript.Append(wrapper.Subscript.Clone(false));
+            newNode = only.Clone(true);
+          }
+          var location = newNode.IndexRange == Range.Zero
+            ? (prevNode is { } prev ? prev.IndexRange.Location + prev.IndexRange.Length : 0)
+            : newNode.IndexRange.Location;
+          if (newNode.IndexRange == Range.Zero) {
+            // A brace group spans its contents, so its length is the number of atoms
+            // inside; every other atom occupies exactly one index slot.
+            int length = 1;
+            if (newNode is Group g) {
+              // Renumber the group contents to their global indices, then the group
+              // spans from its location to the end of the last inner atom.
+              g.OffsetInnerRanges(location);
+              length = g.InnerList.LastOrDefault()?.IndexRange.End - location ?? 1;
+              if (length < 1) length = 1;
+            }
+            newNode.IndexRange = new Range(location, length);
+          }
           switch (prevDisplayedIndex == -1 ? null : newList[prevDisplayedIndex], newNode) {
             // NOTE: The left pattern does not include UnaryOperator. Just try "1+++2" and "1++++2" in any LaTeX rendering engine.
             case (null or BinaryOperator or Relation or Open or Punctuation or LargeOperator, BinaryOperator b):
@@ -68,7 +104,10 @@ public MathList Clone(bool finalize) {
               newList[prevDisplayedIndex] = b.ToUnaryOperator();
               break;
           }
-          if ((prevNode, newNode) is (Number { Superscript.Count: 0, Subscript.Count: 0 } n, Number)) {
+          // Combine numbers together, but never across a font-style change: Fuse
+          // keeps the first atom's FontStyle and would corrupt the other's.
+          if ((prevNode, newNode) is (Number { Superscript.Count: 0, Subscript.Count: 0 } n, Number)
+            && n.FontStyle == newNode.FontStyle) {
             n.Fuse(newNode);
             continue; // do not add the new node; we fused it instead.
           }
diff --git a/CSharpMath/Display/Displays/BoxDisplay.cs b/CSharpMath/Display/Displays/BoxDisplay.cs
new file mode 100644
index 00000000..c083de1a
--- /dev/null
+++ b/CSharpMath/Display/Displays/BoxDisplay.cs
@@ -0,0 +1,97 @@
+using System.Collections.Generic;
+using System.Drawing;
+using CSharpMath.Atom;
+using CSharpMath.Atom.Atoms;
+
+namespace CSharpMath.Display.Displays {
+  using FrontEnd;
+  /// <summary>Display for the box family (phantom/smash/lap/cancel). Reports geometry
+  /// selected by the keep* flags, either draws or suppresses its measured child, and
+  /// draws an optional strike overlay.</summary>
+  public class BoxDisplay<TFont, TGlyph> : IDisplay<TFont, TGlyph>
+    where TFont : IFont<TGlyph> {
+    public ListDisplay<TFont, TGlyph> Child { get; }
+    public bool KeepWidth { get; }
+    public bool DrawChild { get; }
+    public BoxHAlign HAlign { get; }
+    public StrikeStyle StrikeStyle { get; }
+    /// <summary>The stroke thickness for the strike overlay.</summary>
+    public float StrikeThickness { get; }
+    /// <summary>y-offset above the baseline for the \sout horizontal strike.</summary>
+    public float StrikeVerticalOffset { get; }
+    public Range Range { get; }
+
+    public BoxDisplay(ListDisplay<TFont, TGlyph> child,
+      bool keepWidth, bool keepHeight, bool keepDepth, bool drawChild,
+      BoxHAlign hAlign, StrikeStyle strikeStyle,
+      float strikeThickness, float strikeVerticalOffset, Range range) {
+      Child = child;
+      DrawChild = drawChild;
+      KeepWidth = keepWidth;
+      HAlign = hAlign;
+      StrikeStyle = strikeStyle;
+      StrikeThickness = strikeThickness;
+      StrikeVerticalOffset = strikeVerticalOffset;
+      Range = range;
+      Width = keepWidth ? child.Width : 0;
+      Ascent = keepHeight ? child.Ascent : 0;
+      Descent = keepDepth ? child.Descent : 0;
+    }
+
+    public float Width { get; set; }
+    public float Ascent { get; set; }
+    public float Descent { get; set; }
+    public PointF Position { get; set; }
+    public bool HasScript { get; set; }
+    public Color? TextColor { get; set; }
+    public void SetTextColorRecursive(Color? textColor) {
+      TextColor ??= textColor;
+      Child.SetTextColorRecursive(textColor);
+    }
+    public Color? BackColor { get; set; }
+
+    private void UpdateChildPosition() {
+      // Push an absolute position down to the child so draw never has to mutate
+      // child state or juggle the coordinate transform.
+      float offset = 0;
+      if (!KeepWidth) {
+        offset = HAlign switch {
+          BoxHAlign.Right => -Child.Width,
+          BoxHAlign.Center => -Child.Width / 2,
+          _ => 0
+        };
+      }
+      Child.Position = new PointF(Position.X + offset, Position.Y);
+    }
+
+    public void Draw(IGraphicsContext<TFont, TGlyph> context) {
+      this.DrawBackground(context);
+      if (!DrawChild) return; // phantom: geometry already flowed up at measure time
+      UpdateChildPosition();
+      Child.Draw(context);
+      if (StrikeStyle != StrikeStyle.None) {
+        // Overlay stroke in the inherited text color.
+        float x = Position.X, y = Position.Y;
+        float w = Child.Width, top = y + Ascent, bot = y - Descent;
+        switch (StrikeStyle) {
+          case StrikeStyle.Forward:
+            context.DrawLine(x, bot, x + w, top, StrikeThickness, TextColor);
+            break;
+          case StrikeStyle.Backward:
+            context.DrawLine(x, top, x + w, bot, StrikeThickness, TextColor);
+            break;
+          case StrikeStyle.Cross:
+            context.DrawLine(x, bot, x + w, top, StrikeThickness, TextColor);
+            context.DrawLine(x, top, x + w, bot, StrikeThickness, TextColor);
+            break;
+          case StrikeStyle.Horizontal: {
+              float m = y + StrikeVerticalOffset;
+              context.DrawLine(x, m, x + w, m, StrikeThickness, TextColor);
+              break;
+            }
+        }
+      }
+    }
+    public override string ToString() => @"\box";
+  }
+}
diff --git a/CSharpMath/Display/Displays/FractionDisplay.cs b/CSharpMath/Display/Displays/FractionDisplay.cs
index 9d13f795..56b97240 100644
--- a/CSharpMath/Display/Displays/FractionDisplay.cs
+++ b/CSharpMath/Display/Displays/FractionDisplay.cs
@@ -18,6 +18,9 @@ public class FractionDisplay<TFont, TGlyph> : IDisplay<TFont, TGlyph>
     public float DenominatorDown { get; set; }
     public float LineThickness { get; set; }
     public float LinePosition { get; set; }
+    /// <summary>Horizontal alignment of the numerator within the fraction column.
+    /// Only \cfrac[l]/[r] sets a non-center value.</summary>
+    public Atom.Atoms.FractionAlignment NumeratorAlignment { get; set; }
 
     public Range Range { get; }
 
@@ -36,8 +39,13 @@ public FractionDisplay(ListDisplay<TFont, TGlyph> numeratorDisplay, ListDisplay<
     public float Width => Math.Max(Numerator.Width, Denominator.Width);
 
     public void UpdateNumeratorAndDenominatorPositions() {
+      float offset = NumeratorAlignment switch {
+        Atom.Atoms.FractionAlignment.Left => 0,
+        Atom.Atoms.FractionAlignment.Right => Width - Numerator.Width,
+        _ => (Width - Numerator.Width) / 2
+      };
       Numerator.Position =
-        new PointF(Position.X + (Width - Numerator.Width) / 2, Position.Y + NumeratorUp);
+        new PointF(Position.X + offset, Position.Y + NumeratorUp);
       Denominator.Position =
         new PointF(Position.X + (Width - Denominator.Width) / 2, Position.Y - DenominatorDown);
     }
diff --git a/CSharpMath/Display/Displays/GlyphConstructionDisplay.cs b/CSharpMath/Display/Displays/GlyphConstructionDisplay.cs
index 0b3666d5..8cfa729b 100644
--- a/CSharpMath/Display/Displays/GlyphConstructionDisplay.cs
+++ b/CSharpMath/Display/Displays/GlyphConstructionDisplay.cs
@@ -5,7 +5,7 @@
 
 namespace CSharpMath.Display.Displays {
   using FrontEnd;
-  public class GlyphConstructionDisplay<TFont, TGlyph> : IGlyphDisplay<TFont, TGlyph> where TFont : IFont<TGlyph> {
+  public class GlyphConstructionDisplay<TFont, TGlyph> : IGlyphDisplay<TFont, TGlyph>, IInkDisplay where TFont : IFont<TGlyph> {
     private readonly IReadOnlyList<TGlyph> _glyphs;
     private readonly IEnumerable<PointF> _glyphPositions;
 
@@ -17,6 +17,7 @@ public class GlyphConstructionDisplay<TFont, TGlyph> : IGlyphDisplay<TFont, TGly
     public float Descent => _descent + ShiftDown;
 
     public float Width { get; }
+    public float InkWidth { get; }
 
     public Range Range { get; set; }
 
@@ -30,11 +31,20 @@ public GlyphConstructionDisplay(
       IReadOnlyList<TGlyph> glyphs, IEnumerable<float> offsets, TFont font,
       float ascent, float descent, float width) {
       _glyphs = glyphs;
-      _glyphPositions = offsets.Select(x => new PointF(0, x));
       Font = font;
       _ascent = ascent;
       _descent = descent;
       Width = width;
+      var offsetList = offsets.ToList();
+      _glyphPositions = offsetList.Select(x => new PointF(0, x));
+      InkWidth = GetInkWidth(glyphs, offsetList, font, width);
+    }
+    static float GetInkWidth(IReadOnlyList<TGlyph> glyphs, IReadOnlyList<float> offsets, TFont font, float width) {
+      if (font is not IFontGlyphBounds<TGlyph> bounds) return width;
+      var rects = bounds.GetBoundingRects(glyphs).ToList();
+      var result = width;
+      for (var i = 0; i < rects.Count && i < offsets.Count; i++) result = System.Math.Max(result, rects[i].Right);
+      return result;
     }
 
     public void Draw(IGraphicsContext<TFont, TGlyph> context) {
@@ -52,4 +62,4 @@ public void Draw(IGraphicsContext<TFont, TGlyph> context) {
     public void SetTextColorRecursive(Color? textColor) => TextColor ??= textColor;
     public Color? BackColor { get; set; }
   }
-}
\ No newline at end of file
+}
diff --git a/CSharpMath/Display/Displays/GlyphDisplay.cs b/CSharpMath/Display/Displays/GlyphDisplay.cs
index 4d3203f8..f39badcc 100644
--- a/CSharpMath/Display/Displays/GlyphDisplay.cs
+++ b/CSharpMath/Display/Displays/GlyphDisplay.cs
@@ -1,9 +1,10 @@
 using System.Drawing;
+using System.Linq;
 using CSharpMath.Atom;
 
 namespace CSharpMath.Display.Displays {
   using FrontEnd;
-  public class GlyphDisplay<TFont, TGlyph> : IGlyphDisplay<TFont, TGlyph>
+  public class GlyphDisplay<TFont, TGlyph> : IGlyphDisplay<TFont, TGlyph>, IInkDisplay
     where TFont : IFont<TGlyph> {
 
     readonly float _ascent;
@@ -11,6 +12,7 @@ public class GlyphDisplay<TFont, TGlyph> : IGlyphDisplay<TFont, TGlyph>
     public float Ascent => _ascent - ShiftDown;
     public float Descent => _descent + ShiftDown;
     public float Width { get; }
+    public float InkWidth { get; }
     public Range Range { get; }
     public PointF Position { get; set; }
     public bool HasScript { get; set; }
@@ -25,6 +27,12 @@ public GlyphDisplay(TGlyph glyph, Range range, TFont font,
       _ascent = ascent;
       _descent = descent;
       Width = width;
+      InkWidth = GetInkWidth(glyph, font, width);
+    }
+    static float GetInkWidth(TGlyph glyph, TFont font, float width) {
+      if (font is IFontGlyphBounds<TGlyph> bounds)
+        return System.Math.Max(width, bounds.GetBoundingRects(new[] { glyph }).FirstOrDefault().Right);
+      return width;
     }
     public void Draw(IGraphicsContext<TFont, TGlyph> context) {
       this.DrawBackground(context);
@@ -41,4 +49,4 @@ public void Draw(IGraphicsContext<TFont, TGlyph> context) {
     public Color? BackColor { get; set; }
     public override string ToString() => Glyph?.ToString() ?? "<null>";
   }
-}
\ No newline at end of file
+}
diff --git a/CSharpMath/Display/Displays/HorizontalGlyphConstructionDisplay.cs b/CSharpMath/Display/Displays/HorizontalGlyphConstructionDisplay.cs
index 99ebf2c4..64fdebcd 100644
--- a/CSharpMath/Display/Displays/HorizontalGlyphConstructionDisplay.cs
+++ b/CSharpMath/Display/Displays/HorizontalGlyphConstructionDisplay.cs
@@ -5,7 +5,7 @@
 
 namespace CSharpMath.Display.Displays {
   using FrontEnd;
-  public class HorizontalGlyphConstructionDisplay<TFont, TGlyph> : IGlyphDisplay<TFont, TGlyph> where TFont : IFont<TGlyph> {
+  public class HorizontalGlyphConstructionDisplay<TFont, TGlyph> : IGlyphDisplay<TFont, TGlyph>, IInkDisplay where TFont : IFont<TGlyph> {
     private readonly IReadOnlyList<TGlyph> _glyphs;
     private readonly IEnumerable<PointF> _glyphPositions;
 
@@ -17,6 +17,7 @@ public class HorizontalGlyphConstructionDisplay<TFont, TGlyph> : IGlyphDisplay<T
     public float Descent => _descent + ShiftDown;
 
     public float Width { get; }
+    public float InkWidth { get; }
 
     public Range Range { get; set; }
 
@@ -30,11 +31,18 @@ public HorizontalGlyphConstructionDisplay(
       IReadOnlyList<TGlyph> glyphs, IEnumerable<float> offsets, TFont font,
       float ascent, float descent, float width) {
       _glyphs = glyphs;
-      _glyphPositions = offsets.Select(x => new PointF(x, 0));
+      var offsetList = offsets.ToList();
+      _glyphPositions = offsetList.Select(x => new PointF(x, 0));
       Font = font;
       _ascent = ascent;
       _descent = descent;
       Width = width;
+      InkWidth = width;
+      if (font is IFontGlyphBounds<TGlyph> bounds) {
+        var rects = bounds.GetBoundingRects(glyphs).ToList();
+        for (var i = 0; i < rects.Count && i < offsetList.Count; i++)
+          InkWidth = System.Math.Max(InkWidth, offsetList[i] + rects[i].Right);
+      }
     }
 
     public void Draw(IGraphicsContext<TFont, TGlyph> context) {
@@ -52,4 +60,4 @@ public void Draw(IGraphicsContext<TFont, TGlyph> context) {
     public void SetTextColorRecursive(Color? textColor) => TextColor ??= textColor;
     public Color? BackColor { get; set; }
   }
-}
\ No newline at end of file
+}
diff --git a/CSharpMath/Display/Displays/ListDisplay.cs b/CSharpMath/Display/Displays/ListDisplay.cs
index c8b2cef1..09ed7410 100644
--- a/CSharpMath/Display/Displays/ListDisplay.cs
+++ b/CSharpMath/Display/Displays/ListDisplay.cs
@@ -26,16 +26,31 @@ public ListDisplay(IReadOnlyList<IDisplay<TFont, TGlyph>> displays) {
       LinePosition = LinePosition.Regular;
       IndexInParent = int.MinValue;
     }
-    public float Ascent => Displays.CollectionAscent();
-    public float Descent => Displays.CollectionDescent();
+    public float Ascent => _ascentOverride ?? Displays.CollectionAscent();
+    public float Descent => _descentOverride ?? Displays.CollectionDescent();
     public PointF Position { get; set; }
+    private float? _ascentOverride;
+    private float? _descentOverride;
+    private float? _widthOverride;
+    /// <summary>Overrides the metrics computed from the child displays (used by the
+    /// \cfrac thinspace wrapper, whose padding is not part of any child).</summary>
+    public void SetOverrideMetrics(float ascent, float descent, float width) {
+      _ascentOverride = ascent;
+      _descentOverride = descent;
+      _widthOverride = width;
+    }
 
     public Range Range =>
-      Range.Combine(
+      _rangeOverride
+      ?? Range.Combine(
         Displays
         .Where(d => !(d is ListDisplay<TFont, TGlyph> ld && ld.LinePosition != LinePosition.Regular))
         .Select(d => d.Range));
-    public float Width => Displays.CollectionWidth();
+    private Range? _rangeOverride;
+    /// <summary>Overrides the combined range of the child displays (used for ruled rows,
+    /// where the row range must exclude script-positioned children).</summary>
+    public void SetRangeOverride(Range range) => _rangeOverride = range;
+    public float Width => _widthOverride ?? Displays.CollectionWidth();
     public void Draw(IGraphicsContext<TFont, TGlyph> context) {
       this.DrawBackground(context);
       context.SaveState();
diff --git a/CSharpMath/Display/Displays/RuleDisplay.cs b/CSharpMath/Display/Displays/RuleDisplay.cs
new file mode 100644
index 00000000..19a8c4e6
--- /dev/null
+++ b/CSharpMath/Display/Displays/RuleDisplay.cs
@@ -0,0 +1,59 @@
+using System.Drawing;
+using CSharpMath.Atom;
+
+namespace CSharpMath.Display.Displays {
+  using FrontEnd;
+  /// <summary>A standalone straight rule (horizontal or vertical) used to draw array
+  /// `|` and \hline. A positioned leaf like GlyphDisplay: it carries its own
+  /// position/width/ascent/descent so it folds into the enclosing table's bounds.
+  /// `start` is a point on the stroke's centre-line; the stroke straddles it by
+  /// thickness/2 on the thickness axis.</summary>
+  public class RuleDisplay<TFont, TGlyph> : IDisplay<TFont, TGlyph>
+    where TFont : IFont<TGlyph> {
+    private readonly float _length;
+    private readonly float _thickness;
+    private readonly bool _vertical;
+
+    public RuleDisplay(PointF centreLineStart, float length, float thickness,
+      bool vertical, Range range) {
+      _length = length;
+      _thickness = thickness;
+      _vertical = vertical;
+      Range = range;
+      // Record Position as the box's lower-left origin so the display's bounds
+      // exactly cover the drawn stroke.
+      if (vertical) {
+        Position = new PointF(centreLineStart.X - thickness / 2, centreLineStart.Y);
+        Width = thickness;
+        Ascent = length;
+        Descent = 0;
+      } else {
+        Position = new PointF(centreLineStart.X, centreLineStart.Y - thickness / 2);
+        Width = length;
+        Ascent = thickness;
+        Descent = 0;
+      }
+    }
+
+    public Range Range { get; }
+    public float Width { get; set; }
+    public float Ascent { get; set; }
+    public float Descent { get; set; }
+    public PointF Position { get; set; }
+    public bool HasScript { get; set; }
+    public Color? TextColor { get; set; }
+    public void SetTextColorRecursive(Color? textColor) => TextColor ??= textColor;
+    public Color? BackColor { get; set; }
+
+    public void Draw(IGraphicsContext<TFont, TGlyph> context) {
+      this.DrawBackground(context);
+      // Re-derive the centre-line from the box origin.
+      float beginX = _vertical ? Position.X + _thickness / 2 : Position.X;
+      float beginY = _vertical ? Position.Y : Position.Y + _thickness / 2;
+      float endX = _vertical ? beginX : beginX + _length;
+      float endY = _vertical ? beginY + _length : beginY;
+      context.DrawLine(beginX, beginY, endX, endY, _thickness, TextColor);
+    }
+    public override string ToString() => "rule";
+  }
+}
diff --git a/CSharpMath/Display/Displays/StackDisplay.cs b/CSharpMath/Display/Displays/StackDisplay.cs
new file mode 100644
index 00000000..3df55a70
--- /dev/null
+++ b/CSharpMath/Display/Displays/StackDisplay.cs
@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+using System.Drawing;
+using CSharpMath.Atom;
+
+namespace CSharpMath.Display.Displays {
+  using FrontEnd;
+  /// <summary>Rendering of a generic over/under stack produced by the typesetter for
+  /// Stack atoms (\overrightarrow, \overbrace, \overset, and similar commands). The
+  /// base display is positioned at the stack's baseline; over and under are
+  /// pre-positioned above and below it by the typesetter.</summary>
+  public class StackDisplay<TFont, TGlyph> : IDisplay<TFont, TGlyph>
+    where TFont : IFont<TGlyph> {
+    /// <summary>The base (inner-list) display. Its baseline is the stack's baseline.</summary>
+    public ListDisplay<TFont, TGlyph> Base { get; }
+    /// <summary>The over-row display, or null if there is no over row.</summary>
+    public IDisplay<TFont, TGlyph>? Over { get; }
+    /// <summary>The under-row display, or null if there is no under row.</summary>
+    public IDisplay<TFont, TGlyph>? Under { get; }
+    public Range Range { get; }
+    public float Width { get; set; }
+    public float Ascent { get; set; }
+    public float Descent { get; set; }
+    public PointF Position { get; set; }
+    public bool HasScript { get; set; }
+    public Color? TextColor { get; set; }
+    public void SetTextColorRecursive(Color? textColor) {
+      TextColor ??= textColor;
+      Base.SetTextColorRecursive(textColor);
+      Over?.SetTextColorRecursive(textColor);
+      Under?.SetTextColorRecursive(textColor);
+    }
+    public Color? BackColor { get; set; }
+    public StackDisplay(ListDisplay<TFont, TGlyph> baseDisplay,
+      IDisplay<TFont, TGlyph>? over, IDisplay<TFont, TGlyph>? under, Range range) =>
+      (Base, Over, Under, Range) = (baseDisplay, over, under, range);
+    public void Draw(IGraphicsContext<TFont, TGlyph> context) {
+      this.DrawBackground(context);
+      Base.Draw(context);
+      Over?.Draw(context);
+      Under?.Draw(context);
+    }
+    public override string ToString() => $@"\stack {Base}";
+  }
+}
diff --git a/CSharpMath/Display/Displays/TextRunDisplay.cs b/CSharpMath/Display/Displays/TextRunDisplay.cs
index c44bf059..eaa4db4b 100644
--- a/CSharpMath/Display/Displays/TextRunDisplay.cs
+++ b/CSharpMath/Display/Displays/TextRunDisplay.cs
@@ -5,7 +5,7 @@
 namespace CSharpMath.Display.Displays {
   using FrontEnd;
   /// <summary>Corresponds to MTCTLineDisplay in iOSMath.</summary> 
-  public class TextRunDisplay<TFont, TGlyph> : IDisplay<TFont, TGlyph> where TFont : IFont<TGlyph> {
+  public class TextRunDisplay<TFont, TGlyph> : IDisplay<TFont, TGlyph>, IInkDisplay where TFont : IFont<TGlyph> {
     public TextRunDisplay(
       AttributedGlyphRun<TFont, TGlyph> run,
       Range range,
@@ -19,11 +19,22 @@ public TextRunDisplay(
         context.GlyphBoundsProvider.GetBoundingRectsForGlyphs(font, Run.Glyphs, Run.GlyphInfos.Count);
       Ascent = rects.IsEmpty() ? 0 : rects.Max(rect => rect.Bottom); // Convert to non-flipped naming here, 
       Descent = rects.IsEmpty() ? 0 : rects.Max(rect => -rect.Y);
+      InkWidth = Width;
+      if (font is IFontGlyphBounds<TGlyph> bounds) {
+        var x = 0f;
+        var glyphRects = bounds.GetBoundingRects(run.Glyphs).ToList();
+        var advances = bounds.GetAdvances(run.Glyphs).ToList();
+        for (var i = 0; i < glyphRects.Count; i++) {
+          InkWidth = System.Math.Max(InkWidth, x + glyphRects[i].Right);
+          x += (i < advances.Count ? advances[i] : 0) + (i < run.GlyphInfos.Count ? run.GlyphInfos[i].KernAfterGlyph : 0);
+        }
+      }
     }
     public AttributedGlyphRun<TFont, TGlyph> Run { get; }
 
     public Range Range { get; }
     public float Width { get; }
+    public float InkWidth { get; }
     public float Ascent { get; }
     public float Descent { get; }
     public PointF Position { get; set; }
@@ -39,4 +50,4 @@ public void Draw(IGraphicsContext<TFont, TGlyph> context) {
     public Color? BackColor { get; set; }
     public override string ToString() => Run.Text.ToString();
   }
-}
\ No newline at end of file
+}
diff --git a/CSharpMath/Display/FrontEnd/FontMathTable.cs b/CSharpMath/Display/FrontEnd/FontMathTable.cs
index 79a7e510..490b6ec9 100644
--- a/CSharpMath/Display/FrontEnd/FontMathTable.cs
+++ b/CSharpMath/Display/FrontEnd/FontMathTable.cs
@@ -78,6 +78,12 @@ public virtual float FractionDelimiterDisplayStyleSize(TFont font) =>
     public abstract float UpperLimitBaselineRiseMin(TFont font);
     public abstract float LowerLimitGapMin(TFont font);
     public abstract float LowerLimitBaselineDropMin(TFont font);
+    #region stretch stack (\overbrace / \underbrace and relatives)
+    public abstract float StretchStackTopShiftUp(TFont font);
+    public abstract float StretchStackBottomShiftDown(TFont font);
+    public abstract float StretchStackGapAboveMin(TFont font);
+    public abstract float StretchStackGapBelowMin(TFont font);
+    #endregion
     public abstract float UnderbarVerticalGap(TFont font);
     public abstract float UnderbarRuleThickness(TFont font);
     public abstract float OverbarVerticalGap(TFont font);
diff --git a/CSharpMath/Display/FrontEnd/IFont.cs b/CSharpMath/Display/FrontEnd/IFont.cs
index 597e319b..503fd2f5 100644
--- a/CSharpMath/Display/FrontEnd/IFont.cs
+++ b/CSharpMath/Display/FrontEnd/IFont.cs
@@ -1 +1,13 @@
-namespace CSharpMath.Display.FrontEnd { public interface IFont<TGlyph> { float PointSize { get; } } }
\ No newline at end of file
+using System.Collections.Generic;
+using System.Drawing;
+
+namespace CSharpMath.Display.FrontEnd {
+  public interface IFont<TGlyph> { float PointSize { get; } }
+
+  /// <summary>Optional font capability used to determine painted (ink) extents.
+  /// Layout continues to work for fonts which only provide advances.</summary>
+  public interface IFontGlyphBounds<TGlyph> {
+    IEnumerable<RectangleF> GetBoundingRects(IEnumerable<TGlyph> glyphs);
+    IEnumerable<float> GetAdvances(IEnumerable<TGlyph> glyphs);
+  }
+}
diff --git a/CSharpMath/Display/IDisplay.cs b/CSharpMath/Display/IDisplay.cs
index 0e0a1bf9..b3ebe43b 100644
--- a/CSharpMath/Display/IDisplay.cs
+++ b/CSharpMath/Display/IDisplay.cs
@@ -20,6 +20,10 @@ public interface IDisplay<TFont, TGlyph> where TFont : IFont<TGlyph> {
     Color? BackColor { get; set; }
     bool HasScript { get; set; }
   }
+
+  /// <summary>Optional painted-ink capability. It is deliberately separate from
+  /// IDisplay so existing display implementations remain source and binary compatible.</summary>
+  public interface IInkDisplay { float InkWidth { get; } }
 }
 namespace CSharpMath {
   using Display;
@@ -46,4 +50,4 @@ public static void DrawBackground<TFont, TGlyph>
       }
     }
   }
-}
\ No newline at end of file
+}
diff --git a/CSharpMath/Display/InkExtensions.cs b/CSharpMath/Display/InkExtensions.cs
new file mode 100644
index 00000000..9f55f153
--- /dev/null
+++ b/CSharpMath/Display/InkExtensions.cs
@@ -0,0 +1,64 @@
+using System;
+using System.Drawing;
+using CSharpMath.Atom.Atoms;
+using CSharpMath.Display.Displays;
+using CSharpMath.Display.FrontEnd;
+
+namespace CSharpMath {
+  using Display;
+
+  /// <summary>Computes the horizontal painted extent without changing advance metrics.
+  /// Positions in composite displays are normalized back to that display's origin.</summary>
+  public static partial class Extensions {
+    public static float InkWidth<TFont, TGlyph>(this IDisplay<TFont, TGlyph> display)
+      where TFont : IFont<TGlyph> {
+      if (display is IInkDisplay ink) return Math.Max(display.Width, ink.InkWidth);
+      if (display is ListDisplay<TFont, TGlyph> list) {
+        var result = list.Width;
+        foreach (var child in list.Displays) result = Math.Max(result, child.Position.X + child.InkWidth());
+        return result;
+      }
+      if (display is TextLineDisplay<TFont, TGlyph> line) {
+        var result = line.Width;
+        foreach (var run in line.Runs) result = Math.Max(result, run.Position.X + run.InkWidth);
+        return result;
+      }
+      float resultComposite = display.Width;
+      void Add(IDisplay<TFont, TGlyph>? child) {
+        if (child is not null)
+          resultComposite = Math.Max(resultComposite, child.Position.X - display.Position.X + child.InkWidth());
+      }
+      switch (display) {
+        case FractionDisplay<TFont, TGlyph> fraction:
+          Add(fraction.Numerator); Add(fraction.Denominator); break;
+        case RadicalDisplay<TFont, TGlyph> radical:
+          Add(radical.Radicand); Add(radical.Degree); break;
+        case AccentDisplay<TFont, TGlyph> accent:
+          Add(accent.Accentee); Add(accent.Accent); break;
+        case InnerDisplay<TFont, TGlyph> inner:
+          Add(inner.Left); Add(inner.Inner); Add(inner.Right); break;
+        case LargeOpLimitsDisplay<TFont, TGlyph> limits:
+          Add(limits.NucleusDisplay); Add(limits.UpperLimit); Add(limits.LowerLimit); break;
+        case StackDisplay<TFont, TGlyph> stack:
+          Add(stack.Base); Add(stack.Over); Add(stack.Under); break;
+        case OverOrUnderlineDisplay<TFont, TGlyph> bar:
+          Add(bar.Inner); break;
+        case UnderAnnotationDisplay<TFont, TGlyph> annotation:
+          Add(annotation.Inner); Add(annotation.UnderList); Add(annotation.AnnotationGlyph); break;
+        case BoxDisplay<TFont, TGlyph> box:
+          if (box.DrawChild) {
+            // BoxDisplay updates Child.Position lazily in Draw. Measurement must
+            // reproduce that offset instead of observing the stale position.
+            var offset = box.KeepWidth ? 0 : box.HAlign switch {
+              BoxHAlign.Right => -box.Child.Width,
+              BoxHAlign.Center => -box.Child.Width / 2,
+              _ => 0
+            };
+            resultComposite = Math.Max(resultComposite, offset + box.Child.InkWidth());
+          }
+          break;
+      }
+      return resultComposite;
+    }
+  }
+}
diff --git a/CSharpMath/Display/Typesetter.cs b/CSharpMath/Display/Typesetter.cs
index 8c58f6bf..3aacd161 100644
--- a/CSharpMath/Display/Typesetter.cs
+++ b/CSharpMath/Display/Typesetter.cs
@@ -19,6 +19,12 @@ public static ListDisplay<TFont, TGlyph> CreateLine<TFont, TGlyph>
       2 when char.IsHighSurrogate(str[0]) && char.IsLowSurrogate(str[1]) => true,
       _ => false
     };
+    internal static MathAtom SpacingAtom(MathAtom atom) => atom is LargeDelimiter large
+      ? large.MathClass == typeof(Open) ? new Open(large.Nucleus) :
+        large.MathClass == typeof(Close) ? new Close(large.Nucleus) :
+        large.MathClass == typeof(Relation) ? new Relation(large.Nucleus) :
+        new Ordinary(large.Nucleus)
+      : atom;
     private static TGlyph FindVariantGlyph<TFont, TGlyph>(FontMathTable<TFont, TGlyph> mathTable,
       IGlyphBoundsProvider<TFont, TGlyph> boundsProvider, TFont styleFont, TGlyph rawGlyph,
       float targetWidth, out float glyphAscent, out float glyphDescent, out float glyphWidth)
@@ -143,9 +149,10 @@ List<MathAtom> _PreprocessMathList() {
             UnaryOperator u => u.ToOrdinary(),
             _ => atom
           };
-          // This is Rule 14 to merge ordinary characters.
-          // combine ordinary atoms together
-          if (newAtom is Ordinary && prevAtom is Ordinary o && o.Superscript.IsEmpty() && o.Subscript.IsEmpty()) {
+          // This is Rule 14 to merge ordinary characters, but only within one font
+          // style: the fused run is stamped with a single face (iosMath 76fd773).
+          if (newAtom is Ordinary && prevAtom is Ordinary o && o.Superscript.IsEmpty() && o.Subscript.IsEmpty()
+            && o.FontStyle == newAtom.FontStyle) {
             prevAtom.Fuse(newAtom);
             // skip the current node as we fused it
             continue;
@@ -201,6 +208,55 @@ private void CreateDisplayAtoms(List<MathAtom> preprocessedAtoms) {
             _currentPosition.X += colorDisplay.Width;
             _displayAtoms.Add(colorDisplay);
             break;
+          case Group group:
+            AddDisplayLine(false);
+            // Spaced as Ordinary; lay out the sub-mlist with a fresh recursion so any
+            // interior style node is scoped to the group. The child displays are
+            // spliced straight into the parent so braces stay transparent for hit
+            // testing (TeX ordgroup semantics).
+            AddInterElementSpace(prevAtom, group);
+            var groupInnerDisplay =
+              CreateLine(group.InnerList, _font, _context, _style, _cramped);
+            foreach (var splicedDisplay in groupInnerDisplay.Displays) {
+              splicedDisplay.Position = splicedDisplay.Position.Plus(_currentPosition);
+              _displayAtoms.Add(splicedDisplay);
+            }
+            _currentPosition.X += groupInnerDisplay.Width;
+            if (atom.Subscript.IsNonEmpty() || atom.Superscript.IsNonEmpty()) {
+              // Scripts attach after the whole group.
+              AddDisplayLine(true);
+              var line = _displayAtoms[_displayAtoms.Count - 1];
+              MakeScripts(atom, line, atom.IndexRange.Location, 0);
+            }
+            break;
+          case Box box:
+            AddDisplayLine(false);
+            // Box spacing class is Ordinary.
+            AddInterElementSpace(prevAtom, box);
+            var boxChildDisplay = CreateLine(box.InnerList, _font, _context, _style, false);
+            var boxDisplay = new BoxDisplay<TFont, TGlyph>(boxChildDisplay, box.KeepWidth,
+              box.KeepHeight, box.KeepDepth, box.DrawChild, box.HAlign, box.StrikeStyle,
+              _mathTable.FractionRuleThickness(_styleFont),
+              0.55f * _mathTable.AccentBaseHeight(_styleFont),
+              atom.IndexRange) {
+              Position = _currentPosition
+            };
+            _displayAtoms.Add(boxDisplay);
+            _currentPosition.X += boxDisplay.Width;
+            if (atom.Subscript.IsNonEmpty() || atom.Superscript.IsNonEmpty()) {
+              MakeScripts(atom, boxDisplay, atom.IndexRange.Location, 0);
+            }
+            break;
+          case Stack stack:
+            AddDisplayLine(false);
+            AddInterElementSpace(prevAtom, stack);
+            var stackDisplay = MakeStack(stack, atom.IndexRange);
+            _displayAtoms.Add(stackDisplay);
+            _currentPosition.X += stackDisplay.Width;
+            if (atom.Subscript.IsNonEmpty() || atom.Superscript.IsNonEmpty()) {
+              MakeScripts(atom, stackDisplay, atom.IndexRange.Location, 0);
+            }
+            break;
           case Radical rad:
             AddDisplayLine(false);
             AddInterElementSpace(prevAtom, rad);
@@ -327,6 +383,30 @@ private void CreateDisplayAtoms(List<MathAtom> preprocessedAtoms) {
             _currentPosition.X += raisedDisplay.Width;
             _displayAtoms.Add(raisedDisplay);
             break;
+          case LargeDelimiter large:
+            AddDisplayLine(false);
+            AddInterElementSpace(prevAtom, Typesetter.SpacingAtom(large));
+            if (large.Nucleus.Length == 0) {
+              var emptyDisplay = new GlyphDisplay<TFont, TGlyph>(default!, large.IndexRange,
+                _styleFont, 0, 0, 0) { Position = _currentPosition };
+              _displayAtoms.Add(emptyDisplay);
+              if (large.Subscript.IsNonEmpty() || large.Superscript.IsNonEmpty())
+                MakeScripts(large, emptyDisplay, large.IndexRange.Location, 0);
+            } else {
+              var height = (large.Size switch {
+                LargeDelimiter.DelimiterSize.Size1 => 1.2f,
+                LargeDelimiter.DelimiterSize.Size2 => 1.623f,
+                LargeDelimiter.DelimiterSize.Size3 => 2.047f,
+                _ => 2.470f
+              }) * _styleFont.PointSize;
+              var display = FindGlyphForBoundary(large.Nucleus, height);
+              display.Position = _currentPosition;
+              _currentPosition.X += display.Width;
+              _displayAtoms.Add(display);
+              if (large.Subscript.IsNonEmpty() || large.Superscript.IsNonEmpty())
+                MakeScripts(large, display, large.IndexRange.Location, 0);
+            }
+            break;
           case Ordinary _:
           case BinaryOperator _:
           case Relation _:
@@ -336,7 +416,7 @@ private void CreateDisplayAtoms(List<MathAtom> preprocessedAtoms) {
           case Punctuation _: {
               if (prevAtom != null) {
                 float interElementSpace =
-                  InterElementSpaces.Get(prevAtom, atom, _style, _styleFont, _mathTable);
+                  InterElementSpaces.Get(Typesetter.SpacingAtom(prevAtom), Typesetter.SpacingAtom(atom), _style, _styleFont, _mathTable);
                 if (_currentLine.Length > 0) {
                   if (interElementSpace > 0) {
                     _currentLine.Runs.Last().GlyphInfos.Last().KernAfterGlyph = interElementSpace;
@@ -516,8 +596,8 @@ private void MakeScripts(MathAtom atom, IDisplay<TFont, TGlyph> display, int ind
 
     private void AddInterElementSpace(MathAtom? prev, MathAtom current) =>
       _currentPosition.X +=
-        prev != null ? InterElementSpaces.Get(prev, current, _style, _styleFont, _mathTable)
-        : _spaced ? InterElementSpaces.Get(new Open(""), current, _style, _styleFont, _mathTable)
+        prev != null ? InterElementSpaces.Get(Typesetter.SpacingAtom(prev), Typesetter.SpacingAtom(current), _style, _styleFont, _mathTable)
+        : _spaced ? InterElementSpaces.Get(new Open(""), Typesetter.SpacingAtom(current), _style, _styleFont, _mathTable)
         : 0;
     internal TextLineDisplay<TFont, TGlyph>? AddDisplayLine(bool evenIfLengthIsZero) {
       if (evenIfLengthIsZero || (_currentLine != null && _currentLine.Length > 0)) {
@@ -589,6 +669,24 @@ IGlyphDisplay<TFont, TGlyph> _GetRadicalGlyph(float radicalHeight) {
     }
 
     private IDisplay<TFont, TGlyph> MakeFraction(Fraction fraction) {
+      // Style override: temporarily swap _style for \dfrac/\tfrac/\cfrac.
+      var savedStyle = _style;
+      bool didOverrideStyle = false;
+      if (fraction.StyleOverride != FractionStyle.Auto) {
+        var overrideStyle = fraction.StyleOverride switch {
+          FractionStyle.Display => LineStyle.Display,
+          FractionStyle.Text => LineStyle.Text,
+          _ => _style
+        };
+        if (overrideStyle != _style) {
+          _style = overrideStyle;
+          _styleFont = _context.MathFontCloner.Invoke(_font, _mathTable.GetStyleSize(_style, _font));
+          didOverrideStyle = true;
+        }
+      }
+
+      // AMSMath \cfrac: numerator and denominator are always typeset in display
+      // style (not one step down like \frac), and the denominator is not cramped.
       float _NumeratorShiftUp(bool hasRule) =>
         (hasRule, _style) switch {
           (true, LineStyle.Display) => _mathTable.FractionNumeratorDisplayStyleShiftUp(_styleFont),
@@ -621,10 +719,29 @@ float _FractionDelimiterHeight() =>
           ? _mathTable.FractionDelimiterDisplayStyleSize(_styleFont)
           : _mathTable.FractionDelimiterSize(_styleFont);
 
+      var fractionStyle =
+        fraction.IsContinuedFraction ? LineStyle.Display : _fractionStyle;
       var numeratorDisplay =
-          CreateLine(fraction.Numerator, _font, _context, _fractionStyle, false);
+          CreateLine(fraction.Numerator, _font, _context, fractionStyle, false);
       var denominatorDisplay =
-        CreateLine(fraction.Denominator, _font, _context, _fractionStyle, true);
+        CreateLine(fraction.Denominator, _font, _context, fractionStyle,
+          !fraction.IsContinuedFraction);
+
+      float numeratorStrutAscent = 0, numeratorStrutDescent = 0;
+      float denominatorStrutAscent = 0, denominatorStrutDescent = 0;
+      if (fraction.IsContinuedFraction) {
+        // Apply cfrac strut floors to the operand boxes *before* numeratorShiftUp
+        // and denominatorShiftDown are computed. AMSMath's strut is a floor on
+        // the operand box, not on the shift. ListDisplay metrics are computed from
+        // the children, so the floors are folded into NumeratorUp/DenominatorDown
+        // instead of mutating the read-only display properties.
+        float strutHeight = 0.85f * _styleFont.PointSize;
+        float strutDepth = 0.35f * _styleFont.PointSize;
+        numeratorStrutAscent = Math.Max(0, strutHeight - numeratorDisplay.Ascent);
+        numeratorStrutDescent = Math.Max(0, strutDepth - numeratorDisplay.Descent);
+        denominatorStrutAscent = Math.Max(0, strutHeight - denominatorDisplay.Ascent);
+        denominatorStrutDescent = Math.Max(0, strutDepth - denominatorDisplay.Descent);
+      }
 
       var numeratorShiftUp = _NumeratorShiftUp(fraction.HasRule);
       var denominatorShiftDown = _DenominatorShiftDown(fraction.HasRule);
@@ -635,21 +752,21 @@ float _FractionDelimiterHeight() =>
         // this is the difference between the lowest portion of
         // the numerator and the top edge of the fraction bar.
         var distanceFromNumeratorToBar =
-          numeratorShiftUp - numeratorDisplay.Descent - (barLocation + barThickness / 2);
+          numeratorShiftUp - numeratorDisplay.Descent - numeratorStrutDescent - (barLocation + barThickness / 2);
         // The distance should be at least displayGap
         if (distanceFromNumeratorToBar < _NumeratorGapMin()) {
           numeratorShiftUp += (_NumeratorGapMin() - distanceFromNumeratorToBar);
         }
         // now, do the same for the denominator
         var distanceFromDenominatorToBar =
-          barLocation - barThickness / 2 - (denominatorDisplay.Ascent - denominatorShiftDown);
+          barLocation - barThickness / 2 - (denominatorDisplay.Ascent + denominatorStrutAscent - denominatorShiftDown);
         if (distanceFromDenominatorToBar < _DenominatorGapMin()) {
           denominatorShiftDown += _DenominatorGapMin() - distanceFromDenominatorToBar;
         }
       } else {
         float clearance =
-          numeratorShiftUp - numeratorDisplay.Descent
-          - (denominatorDisplay.Ascent - denominatorShiftDown);
+          numeratorShiftUp - numeratorDisplay.Descent - numeratorStrutDescent
+          - (denominatorDisplay.Ascent + denominatorStrutAscent - denominatorShiftDown);
         float minClearance = _StackGapMin();
         if (clearance < minClearance) {
           numeratorShiftUp += (minClearance - clearance / 2);
@@ -657,42 +774,168 @@ float _FractionDelimiterHeight() =>
         }
       }
 
+      // The strut floors widen the operand extents: fold them into the shifts.
+      numeratorShiftUp += numeratorStrutAscent;
+      denominatorShiftDown += denominatorStrutAscent;
+
       var display = new FractionDisplay<TFont, TGlyph>
         (numeratorDisplay, denominatorDisplay, _currentPosition, fraction.IndexRange) {
         NumeratorUp = numeratorShiftUp,
         DenominatorDown = denominatorShiftDown,
         LineThickness = barThickness,
-        LinePosition = barLocation
+        LinePosition = barLocation,
+        NumeratorAlignment = fraction.NumeratorAlignment
       };
       display.UpdateNumeratorAndDenominatorPositions();
 
+      IDisplay<TFont, TGlyph> result;
       // Add delimiters to fraction display
+      if (fraction.LeftDelimiter == Boundary.Empty && fraction.RightDelimiter == Boundary.Empty) {
+        result = display;
+      } else {
+        var glyphHeight = _FractionDelimiterHeight();
+        var position = new PointF();
+        var innerGlyphs = new List<IDisplay<TFont, TGlyph>>();
+        if (fraction.LeftDelimiter.Nucleus?.Length > 0) {
+          var leftGlyph = FindGlyphForBoundary(fraction.LeftDelimiter.Nucleus, glyphHeight);
+          leftGlyph.Position = position;
+          innerGlyphs.Add(leftGlyph);
+          position.X += leftGlyph.Width;
+        }
+        display.Position = position;
+        position.X += display.Width;
+        innerGlyphs.Add(display);
+        if (fraction.RightDelimiter.Nucleus?.Length > 0) {
+          var rightGlyph = FindGlyphForBoundary(fraction.RightDelimiter.Nucleus, glyphHeight);
+          rightGlyph.Position = position;
+          innerGlyphs.Add(rightGlyph);
+          position.X += rightGlyph.Width;
+        }
+        result = new ListDisplay<TFont, TGlyph>(innerGlyphs) {
+          Position = _currentPosition
+        };
+      }
 
-      if (fraction.LeftDelimiter == Boundary.Empty && fraction.RightDelimiter == Boundary.Empty)
-        return display;
-      var glyphHeight = _FractionDelimiterHeight();
-      var position = new PointF();
-      var innerGlyphs = new List<IDisplay<TFont, TGlyph>>();
-      if (fraction.LeftDelimiter.Nucleus?.Length > 0) {
-        var leftGlyph = FindGlyphForBoundary(fraction.LeftDelimiter.Nucleus, glyphHeight);
-        leftGlyph.Position = position;
-        innerGlyphs.Add(leftGlyph);
-        position.X += leftGlyph.Width;
+      if (fraction.IsContinuedFraction) {
+        // Wrap with a 3mu thinspace on both sides (amsmath \cfrac). The wrapper is a
+        // plain positioned container; its metrics are the child's plus the padding.
+        float thinspace = 3 * _mathTable.MuUnit(_styleFont);
+        var wrapped = new ListDisplay<TFont, TGlyph>(new[] { result });
+        result.Position = new PointF(thinspace, 0);
+        wrapped.Position = _currentPosition;
+        wrapped.SetOverrideMetrics(result.Ascent, result.Descent, result.Width + 2 * thinspace);
+        result = wrapped;
       }
-      display.Position = position;
-      position.X += display.Width;
-      innerGlyphs.Add(display);
-      if (fraction.RightDelimiter.Nucleus?.Length > 0) {
-        var rightGlyph = FindGlyphForBoundary(fraction.RightDelimiter.Nucleus, glyphHeight);
-        rightGlyph.Position = position;
-        innerGlyphs.Add(rightGlyph);
-        position.X += rightGlyph.Width;
+
+      if (didOverrideStyle) {
+        _style = savedStyle;
+        _styleFont = _context.MathFontCloner.Invoke(_font, _mathTable.GetStyleSize(_style, _font));
       }
-      return new ListDisplay<TFont, TGlyph>(innerGlyphs) {
-        Position = _currentPosition
+      return result;
+    }
+
+    /// <summary>Lays out a generic over/under stack (\overrightarrow, \overbrace,
+    /// \overset, …). The base is centered; over/under rows are centered above/below
+    /// it using stretch-stack gaps for extensible rows and operator-limit gaps for
+    /// MathList rows.</summary>
+    private IDisplay<TFont, TGlyph> MakeStack(Stack stack, Range range) {
+      var baseDisplay = CreateLine(stack.InnerList, _font, _context, _style, _cramped);
+      float targetWidth = baseDisplay.Width;
+
+      IDisplay<TFont, TGlyph>? BuildRow(StackConstruction? construction) {
+        if (construction == null) return null;
+        if (construction is StackConstruction.Extensible extensible) {
+          return BuildHorizontalExtensibleDisplay(extensible.Glyph, targetWidth, range);
+        }
+        if (construction is StackConstruction.MathListRow mathList) {
+          return CreateLine(mathList.List, _font, _context, _scriptStyle, mathList.Cramped);
+        }
+        throw new InvalidCodePathException("Unknown stack construction kind");
+      }
+
+      var overDisplay = BuildRow(stack.Over);
+      var underDisplay = BuildRow(stack.Under);
+
+      // MathList rows use the operator-limit gap; stretchy rows use stretch-stack gaps.
+      float overGap =
+        stack.Over is StackConstruction.MathListRow && overDisplay != null
+        ? Math.Max(_mathTable.UpperLimitGapMin(_styleFont),
+                   _mathTable.UpperLimitBaselineRiseMin(_styleFont) - overDisplay.Descent)
+        : _mathTable.StretchStackTopShiftUp(_styleFont);
+      float underGap =
+        stack.Under is StackConstruction.MathListRow && underDisplay != null
+        ? Math.Max(_mathTable.LowerLimitGapMin(_styleFont),
+                   _mathTable.LowerLimitBaselineDropMin(_styleFont) - underDisplay.Ascent)
+        : _mathTable.StretchStackBottomShiftDown(_styleFont);
+
+      float totalWidth = Math.Max(baseDisplay.Width,
+        Math.Max(overDisplay?.Width ?? 0, underDisplay?.Width ?? 0));
+
+      baseDisplay.Position = new PointF((totalWidth - baseDisplay.Width) / 2, 0);
+      if (overDisplay != null) {
+        overDisplay.Position = new PointF(
+          (totalWidth - overDisplay.Width) / 2,
+          baseDisplay.Ascent + overGap + overDisplay.Descent);
+      }
+      if (underDisplay != null) {
+        underDisplay.Position = new PointF(
+          (totalWidth - underDisplay.Width) / 2,
+          -(baseDisplay.Descent + underGap + underDisplay.Ascent));
+      }
+
+      return new StackDisplay<TFont, TGlyph>(baseDisplay, overDisplay, underDisplay, range) {
+        Position = _currentPosition,
+        Width = totalWidth,
+        Ascent = baseDisplay.Ascent +
+          (overDisplay != null ? overGap + overDisplay.Ascent + overDisplay.Descent : 0),
+        Descent = baseDisplay.Descent +
+          (underDisplay != null ? underGap + underDisplay.Ascent + underDisplay.Descent : 0)
       };
     }
 
+    /// <summary>Finds the smallest horizontal variant whose width covers minWidth, or the
+    /// largest available; falls back to the horizontal glyph assembly.</summary>
+    private IDisplay<TFont, TGlyph>? BuildHorizontalExtensibleDisplay(
+      string capGlyphText, float targetWidth, Range range) {
+      var capGlyph = _context.GlyphFinder.FindGlyphForCharacterAtIndex(_font, 0, capGlyphText);
+      if (_context.GlyphFinder.GlyphIsEmpty(capGlyph)) return null;
+      var (variantsEnumerable, nVariants) = _mathTable.GetHorizontalVariantsForGlyph(capGlyph);
+      var variants = variantsEnumerable.ToArray();
+      if (nVariants == 0) {
+        // Assembly-only glyph: no preset variants, go straight to the assembly.
+        if (ConstructHorizontalGlyph(capGlyph, targetWidth, 0, 0) is IGlyphDisplay<TFont, TGlyph> assembledOnly) {
+          return assembledOnly;
+        }
+        // No assembly either; render the bare glyph.
+        using var fallbackArray = new RentedArray<TGlyph>(capGlyph);
+        var fallbackBox = _context.GlyphBoundsProvider.GetBoundingRectsForGlyphs(_styleFont, fallbackArray.Result, 1).Single();
+        var (fallbackAdvances, fallbackTotal) = _context.GlyphBoundsProvider.GetAdvancesForGlyphs(_styleFont, fallbackArray.Result, 1);
+        fallbackBox.GetAscentDescentWidth(out float fa, out float fd, out _);
+        return new GlyphDisplay<TFont, TGlyph>(capGlyph, range, _styleFont, fa, fd, fallbackTotal);
+      }
+      var boundingBoxes = _context.GlyphBoundsProvider.GetBoundingRectsForGlyphs(_styleFont, variants, nVariants).ToArray();
+      var (advancesEnumerable, _) = _context.GlyphBoundsProvider.GetAdvancesForGlyphs(_styleFont, variants, nVariants);
+      var advances = advancesEnumerable.ToArray();
+      TGlyph bestGlyph = default!;
+      float bestAscent = 0, bestDescent = 0, bestWidth = float.NegativeInfinity;
+      for (int i = 0; i < nVariants; i++) {
+        boundingBoxes[i].GetAscentDescentWidth(out bestAscent, out bestDescent, out _);
+        bestGlyph = variants[i];
+        bestWidth = advances[i];
+        if (bestWidth >= targetWidth) break;
+      }
+      if (bestWidth >= targetWidth) {
+        return new GlyphDisplay<TFont, TGlyph>(bestGlyph, range, _styleFont, bestAscent, bestDescent, bestWidth);
+      }
+      // No variant covers the width; try the font-supplied horizontal assembly.
+      if (ConstructHorizontalGlyph(bestGlyph, targetWidth, bestAscent, bestDescent)
+          is IGlyphDisplay<TFont, TGlyph> assembled) {
+        return assembled;
+      }
+      // Saturation: use the largest available variant.
+      return new GlyphDisplay<TFont, TGlyph>(bestGlyph, range, _styleFont, bestAscent, bestDescent, bestWidth);
+    }
+
     private InnerDisplay<TFont, TGlyph> MakeInner(Inner inner, Range range) {
       if (inner.LeftBoundary == Boundary.Empty && inner.RightBoundary == Boundary.Empty) {
         throw new InvalidCodePathException("Inner should have a boundary to call this function.");
@@ -920,6 +1163,12 @@ private TGlyph FindGlyph(TGlyph rawGlyph, float height,
       // in iosMath.
       glyphAscent = glyphDescent = glyphWidth = float.NaN;
       var (variants, nVariants) = _mathTable.GetVerticalVariantsForGlyph(rawGlyph);
+      if (nVariants == 0) {
+        // No sized variants (assembly-only glyph): the glyph itself is its only
+        // variant so callers can rely on a non-empty result; the assembly path
+        // below then produces the actual construction.
+        return rawGlyph;
+      }
       var rects =
         _context.GlyphBoundsProvider.GetBoundingRectsForGlyphs(_styleFont, variants, nVariants);
       var advances =
@@ -941,6 +1190,11 @@ private TGlyph FindHorizontalGlyph(TGlyph rawGlyph, float width,
       // in iosMath.
       glyphAscent = glyphDescent = glyphWidth = float.NaN;
       var (variants, nVariants) = _mathTable.GetHorizontalVariantsForGlyph(rawGlyph);
+      if (nVariants == 0) {
+        // No sized variants (assembly-only glyph): fall through to the horizontal
+        // glyph assembly instead of reading out of bounds.
+        return rawGlyph;
+      }
       var rects =
         _context.GlyphBoundsProvider.GetBoundingRectsForGlyphs(_styleFont, variants, nVariants);
       var advances =
@@ -959,17 +1213,29 @@ private TGlyph FindHorizontalGlyph(TGlyph rawGlyph, float width,
 
     private List<List<ListDisplay<TFont, TGlyph>>> TypesetCells(Table table, float[] columnWidths) {
       var r = new List<List<ListDisplay<TFont, TGlyph>>>();
+      // Cells inherit the surrounding style unless the env pins one (matrix/cases ->
+      // Text, smallmatrix -> Script); see _CellStyleForTable.
+      var cellStyle = _CellStyleForTable(table);
       foreach (var row in table.Cells) {
         var colDispalys = new List<ListDisplay<TFont, TGlyph>>();
         r.Add(colDispalys);
         for (int i = 0; i < row.Count; i++) {
-          var disp = CreateLine(row[i], _font, _context, _style, false);
+          var disp = CreateLine(row[i], _font, _context, cellStyle, false);
           columnWidths[i] = Math.Max(disp.Width, columnWidths[i]);
           colDispalys.Add(disp);
         }
       }
       return r;
     }
+    /// <summary>The line style the cells of this table actually render in. Some envs
+    /// pin every cell to a fixed style via table.CellStyle; the rest leave it null and
+    /// render in the surrounding _style.</summary>
+    private LineStyle _CellStyleForTable(Table table) => table.CellStyle ?? _style;
+
+    /// <summary>The font size of a style relative to this table's base font.</summary>
+    private float CellStyleFontSize(Table table) =>
+      _context.MathTable.GetStyleSize(_CellStyleForTable(table), _font);
+
     private IDisplay<TFont, TGlyph> MakeTable(Table table) {
       int nColumns = table.NColumns;
       if (nColumns == 0 || table.NRows == 0) {
@@ -977,26 +1243,153 @@ private IDisplay<TFont, TGlyph> MakeTable(Table table) {
         var emptyTable = new ListDisplay<TFont, TGlyph>(Array.Empty<IDisplay<TFont, TGlyph>>());
         return emptyTable;
       }
+      bool hasRules =
+        table.VerticalLines.Any(v => v > 0) || table.HorizontalLines.Any(h => h > 0);
+
       var columnWidths = new float[nColumns];
       var displays = TypesetCells(table, columnWidths);
-      var rowDisplays = new List<ListDisplay<TFont, TGlyph>>();
+      float[]? columnOffsets = null;
+      List<List<float>>? verticalRuleXs = null;
+      if (!hasRules) {
+        var rowDisplays = new List<ListDisplay<TFont, TGlyph>>();
+        foreach (var row in displays) {
+          rowDisplays.Add(MakeRowWithColumns(row, table, columnWidths));
+        }
+        // position all the rows
+        PositionRows(rowDisplays, table);
+        return new ListDisplay<TFont, TGlyph>(rowDisplays.ToArray()) {
+          // Range is set here in the objective C code.
+          Position = _currentPosition
+        };
+      }
+
+      // Array with rules: compute per-column start offsets shared by cells and
+      // vertical rules so they cannot drift.
+      const float rulePaddingMultiplier = 0.2f;   // content↔rule clearance
+      const float ruleGapMultiplier = 0.2f;       // ≈ \doublerulesep (2pt at 10pt)
+      float thickness = _mathTable.FractionRuleThickness(_styleFont);
+      float padding = rulePaddingMultiplier * _styleFont.PointSize;
+      float ruleGap = ruleGapMultiplier * _styleFont.PointSize;
+      float cellStyleMuUnit = CellStyleFontSize(table) / 18f;
+
+      columnOffsets = new float[nColumns];
+      verticalRuleXs = new List<List<float>>();
+      float x = 0;
+      for (int boundary = 0; boundary <= nColumns; boundary++) {
+        float gapBase = boundary == 0 || boundary == nColumns
+          ? 0 : table.InterColumnSpacing * cellStyleMuUnit;
+        int count = boundary < table.VerticalLines.Count ? table.VerticalLines[boundary] : 0;
+        var ruleXs = new List<float>();
+        if (count > 0) {
+          // No padding outside the outermost rules so they sit flush at the box edges.
+          float padLeft = boundary == 0 ? 0 : padding;
+          float padRight = boundary == nColumns ? 0 : padding;
+          float ruleAreaStart = x + padLeft + gapBase / 2;
+          for (int k = 0; k < count; k++) {
+            ruleXs.Add(ruleAreaStart + k * (thickness + ruleGap) + thickness / 2);
+          }
+          float ruleBlock = count * thickness + (count - 1) * ruleGap;
+          x += gapBase + padLeft + padRight + ruleBlock;
+        } else {
+          x += gapBase;
+        }
+        verticalRuleXs.Add(ruleXs);
+        if (boundary < nColumns) {
+          columnOffsets[boundary] = x;
+          x += columnWidths[boundary];
+        }
+      }
+      float contentWidth = x;
+
+      var ruledRowDisplays = new List<IDisplay<TFont, TGlyph>>();
       foreach (var row in displays) {
-        var rowDisplay = MakeRowWithColumns(row, table, columnWidths);
-        rowDisplays.Add(rowDisplay);
+        ruledRowDisplays.Add(MakeRuledRowWithColumns(row, table, columnWidths, columnOffsets));
       }
 
       // position all the rows
-      PositionRows(rowDisplays, table);
-      return new ListDisplay<TFont, TGlyph>(rowDisplays.ToArray()) {
-        // Range is set here in the objective C code.
+      PositionRows(ruledRowDisplays.Cast<ListDisplay<TFont, TGlyph>>().ToList(), table);
+
+      // Vertical rules span the shared frame (frameBot..frameTop); horizontals span
+      // the full content width so outer rules meet at the corners by construction.
+      float contentTop = float.NegativeInfinity;
+      float contentBot = float.PositiveInfinity;
+      foreach (var rowDisplay in ruledRowDisplays) {
+        contentTop = Math.Max(contentTop, rowDisplay.Position.Y + rowDisplay.Ascent);
+        contentBot = Math.Min(contentBot, rowDisplay.Position.Y - rowDisplay.Descent);
+      }
+      float frameTop = contentTop + padding;
+      float frameBot = contentBot - padding;
+
+      for (int boundary = 0; boundary < verticalRuleXs.Count; boundary++) {
+        foreach (var ruleX in verticalRuleXs[boundary]) {
+          ruledRowDisplays.Add(new RuleDisplay<TFont, TGlyph>(
+            new PointF(ruleX, frameBot), frameBot < frameTop ? frameTop - frameBot : 0,
+            thickness, vertical: true, table.IndexRange));
+        }
+      }
+      int nRows = table.NRows;
+      for (int b = 0; b < table.HorizontalLines.Count && b <= nRows; b++) {
+        int count = table.HorizontalLines[b];
+        if (count == 0) continue;
+        float y0;
+        if (b == 0) {
+          y0 = frameTop;
+        } else if (b >= nRows) {
+          y0 = frameBot;
+        } else {
+          var above = ruledRowDisplays[b - 1];   // upper row (higher y)
+          var below = ruledRowDisplays[b];       // lower row
+          float gapBot = above.Position.Y - above.Descent;
+          float gapTop = below.Position.Y + below.Ascent;
+          y0 = (gapTop + gapBot) / 2;
+        }
+        for (int k = 0; k < count; k++) {
+          float yk = b switch {
+            0 => y0 - k * (thickness + ruleGap),           // stack downward
+            _ when b >= nRows => y0 + k * (thickness + ruleGap), // stack upward
+            _ => y0 + (k % 2 == 0 ? 1 : -1) * ((k + 1) / 2) * (thickness + ruleGap), // symmetric
+          };
+          ruledRowDisplays.Add(new RuleDisplay<TFont, TGlyph>(
+            new PointF(0, yk), contentWidth, thickness, vertical: false, table.IndexRange));
+        }
+      }
+
+      return new ListDisplay<TFont, TGlyph>(ruledRowDisplays.ToArray()) {
         Position = _currentPosition
       };
     }
 
+    /// <summary>Like MakeRowWithColumns but using precomputed shared column offsets.</summary>
+    private ListDisplay<TFont, TGlyph> MakeRuledRowWithColumns(
+      List<ListDisplay<TFont, TGlyph>> row, Table table, float[] columnWidths, float[] columnOffsets) {
+      Range rowRange = Range.NotFound;
+      for (int i = 0; i < row.Count; i++) {
+        var entry = row[i];
+        var alignment = table.GetAlignment(i);
+        var cellPosition = columnOffsets[i];
+        switch (alignment) {
+          case ColumnAlignment.Right:
+            cellPosition += (columnWidths[i] - entry.Width);
+            break;
+          case ColumnAlignment.Center:
+            cellPosition += (columnWidths[i] - entry.Width) / 2;
+            break;
+        }
+        entry.Position = new PointF(cellPosition, 0);
+        rowRange += entry.Range;
+      }
+      var ruled = new ListDisplay<TFont, TGlyph>(row.ToArray());
+      if (rowRange != Range.NotFound) {
+        ruled.SetRangeOverride(rowRange);
+      }
+      return ruled;
+    }
+
     private ListDisplay<TFont, TGlyph> MakeRowWithColumns
       (List<ListDisplay<TFont, TGlyph>> row, Table table, float[] columnWidths) {
       float columnStart = 0;
       Range rowRange = Range.NotFound;
+      float cellStyleMuUnit = CellStyleFontSize(table) / 18f;
       for (int i = 0; i < row.Count; i++) {
         var entry = row[i];
         float columnWidth = columnWidths[i];
@@ -1012,7 +1405,7 @@ private ListDisplay<TFont, TGlyph> MakeRowWithColumns
         }
         entry.Position = new PointF(cellPosition, 0);
         rowRange += entry.Range;
-        columnStart += (columnWidth + table.InterColumnSpacing * _mathTable.MuUnit(_styleFont));
+        columnStart += (columnWidth + table.InterColumnSpacing * cellStyleMuUnit);
       }
       return new ListDisplay<TFont, TGlyph>(row.ToArray());
     }
@@ -1024,10 +1417,14 @@ private ListDisplay<TFont, TGlyph> MakeRowWithColumns
 
     private void PositionRows(List<ListDisplay<TFont, TGlyph>> rows, Table table) {
       float currPos = 0;
-      float openUp = table.InterRowAdditionalSpacing * jotMultiplier * _styleFont.PointSize;
-      float baselineSkip = openUp + baseLineSkipMultiplier * _styleFont.PointSize;
-      float lineSkip = openUp + lineSkipMultiplier * _styleFont.PointSize;
-      float lineSkipLimit = openUp + lineSkipLimitMultiplier * _styleFont.PointSize;
+      // Row leading tracks the cell-content style, not the surrounding style: a
+      // styled table is a self-contained vbox whose internal baseline grid is fixed
+      // in the cell style before it is placed into a smaller context.
+      float cellStyleFontSize = CellStyleFontSize(table);
+      float openUp = table.InterRowAdditionalSpacing * jotMultiplier * cellStyleFontSize;
+      float baselineSkip = openUp + baseLineSkipMultiplier * cellStyleFontSize;
+      float lineSkip = openUp + lineSkipMultiplier * cellStyleFontSize;
+      float lineSkipLimit = openUp + lineSkipLimitMultiplier * cellStyleFontSize;
       float prevRowDescent = 0;
       float ascent = 0;
       bool first = true;
@@ -1133,4 +1530,4 @@ private IDisplay<TFont, TGlyph> AddLimitsToDisplay(IDisplay<TFont, TGlyph> displ
       return display;
     }
   }
-}
\ No newline at end of file
+}
diff --git a/CSharpMath/Editor/Extensions/ListDisplay.cs b/CSharpMath/Editor/Extensions/ListDisplay.cs
index 1cc855dd..dc18a557 100644
--- a/CSharpMath/Editor/Extensions/ListDisplay.cs
+++ b/CSharpMath/Editor/Extensions/ListDisplay.cs
@@ -71,10 +71,12 @@ partial class Extensions {
 
       var index = displayWithPoint.IndexForPoint(context, translatedPoint);
       if (displayWithPoint is ListDisplay<TFont, TGlyph> closestLine) {
-        if (closestLine.LinePosition is LinePosition.Regular)
-          throw new ArgumentException(nameof(ListDisplay<TFont, TGlyph>) + " with " +
-            nameof(ListDisplay<TFont, TGlyph>.LinePosition) + " " + nameof(LinePosition.Regular) +
-            $" inside a {nameof(ListDisplay<TFont, TGlyph>)} - shouldn't happen", nameof(self));
+        if (closestLine.LinePosition is LinePosition.Regular) {
+          // A brace group renders as a nested regular ListDisplay. Its children carry
+          // global atom indices and the inner call already translated the point by the
+          // group's position, so the result needs no wrapping.
+          return closestLine.IndexForPoint(context, translatedPoint);
+        }
         // This is a subscript or a superscript, return the right type of subindex
         var indexType =
           closestLine.LinePosition is LinePosition.Subscript
@@ -100,7 +102,7 @@ closestLine.LinePosition is LinePosition.Subscript
       if (index is null) return null;
 
       PointF? position;
-      if (index.AtomIndex == self.Range.End) {
+      if (index.AtomIndex == self.Range.End && self.SubDisplayForIndex(index) is null) {
         // Special case the edge of the range
         position = new PointF(self.Width, 0);
       } else if (self.Range.Contains(index.AtomIndex) && self.SubDisplayForIndex(index) is { } display)
@@ -109,6 +111,9 @@ closestLine.LinePosition is LinePosition.Subscript
           null => display.PointForIndex(context, index),
           (_, var subIndex) => display.PointForIndex(context, subIndex) // Recurse
         };
+      else if (SubDisplayForGroup(self, index) is { } groupDisplay)
+        // A brace group renders as a nested regular ListDisplay; descend into it.
+        position = groupDisplay.PointForIndex(context, index);
       else
         // Outside the range
         return null;
@@ -122,6 +127,18 @@ closestLine.LinePosition is LinePosition.Subscript
         return null;
     }
 
+    /// <summary>Finds the nested regular ListDisplay (a brace group) whose range contains
+    /// the index, so PointForIndex can see through group wrappers.</summary>
+    private static ListDisplay<TFont, TGlyph>? SubDisplayForGroup<TFont, TGlyph>
+      (ListDisplay<TFont, TGlyph> self, MathListIndex index) where TFont : IFont<TGlyph> {
+      if (!self.Range.Contains(index.AtomIndex)) return null;
+      foreach (var display in self.Displays)
+        if (display is ListDisplay<TFont, TGlyph> { LinePosition: LinePosition.Regular } nested
+            && nested.Range.Contains(index.AtomIndex))
+          return nested;
+      return null;
+    }
+
     public static void HighlightCharacterAt<TFont, TGlyph>(this ListDisplay<TFont, TGlyph> self,
       MathListIndex index, Color color) where TFont : IFont<TGlyph> {
       if (self.Range.Contains(index.AtomIndex) && self.SubDisplayForIndex(index) is { } display)
diff --git a/CSharpMath/PublicAPI.Unshipped.txt b/CSharpMath/PublicAPI.Unshipped.txt
index e69de29b..4541dfec 100644
--- a/CSharpMath/PublicAPI.Unshipped.txt
+++ b/CSharpMath/PublicAPI.Unshipped.txt
@@ -0,0 +1,207 @@
+#nullable enable
+abstract CSharpMath.Display.FrontEnd.FontMathTable<TFont, TGlyph>.StretchStackBottomShiftDown(TFont font) -> float
+abstract CSharpMath.Display.FrontEnd.FontMathTable<TFont, TGlyph>.StretchStackGapAboveMin(TFont font) -> float
+abstract CSharpMath.Display.FrontEnd.FontMathTable<TFont, TGlyph>.StretchStackGapBelowMin(TFont font) -> float
+abstract CSharpMath.Display.FrontEnd.FontMathTable<TFont, TGlyph>.StretchStackTopShiftUp(TFont font) -> float
+CSharpMath.Atom.Atoms.Box
+CSharpMath.Atom.Atoms.Box.Box() -> void
+CSharpMath.Atom.Atoms.Box.Clone(bool finalize) -> CSharpMath.Atom.Atoms.Box!
+CSharpMath.Atom.Atoms.Box.DrawChild.get -> bool
+CSharpMath.Atom.Atoms.Box.DrawChild.set -> void
+CSharpMath.Atom.Atoms.Box.HAlign.get -> CSharpMath.Atom.Atoms.BoxHAlign
+CSharpMath.Atom.Atoms.Box.HAlign.set -> void
+CSharpMath.Atom.Atoms.Box.InnerList.get -> CSharpMath.Atom.MathList!
+CSharpMath.Atom.Atoms.Box.InnerList.set -> void
+CSharpMath.Atom.Atoms.Box.KeepDepth.get -> bool
+CSharpMath.Atom.Atoms.Box.KeepDepth.set -> void
+CSharpMath.Atom.Atoms.Box.KeepHeight.get -> bool
+CSharpMath.Atom.Atoms.Box.KeepHeight.set -> void
+CSharpMath.Atom.Atoms.Box.KeepWidth.get -> bool
+CSharpMath.Atom.Atoms.Box.KeepWidth.set -> void
+CSharpMath.Atom.Atoms.Box.StrikeStyle.get -> CSharpMath.Atom.Atoms.StrikeStyle
+CSharpMath.Atom.Atoms.Box.StrikeStyle.set -> void
+CSharpMath.Atom.Atoms.BoxHAlign
+CSharpMath.Atom.Atoms.BoxHAlign.Center = 1 -> CSharpMath.Atom.Atoms.BoxHAlign
+CSharpMath.Atom.Atoms.BoxHAlign.Left = 0 -> CSharpMath.Atom.Atoms.BoxHAlign
+CSharpMath.Atom.Atoms.BoxHAlign.Right = 2 -> CSharpMath.Atom.Atoms.BoxHAlign
+CSharpMath.Atom.Atoms.Fraction.IsContinuedFraction.get -> bool
+CSharpMath.Atom.Atoms.Fraction.IsContinuedFraction.set -> void
+CSharpMath.Atom.Atoms.Fraction.NumeratorAlignment.get -> CSharpMath.Atom.Atoms.FractionAlignment
+CSharpMath.Atom.Atoms.Fraction.NumeratorAlignment.set -> void
+CSharpMath.Atom.Atoms.Fraction.StyleOverride.get -> CSharpMath.Atom.Atoms.FractionStyle
+CSharpMath.Atom.Atoms.Fraction.StyleOverride.set -> void
+CSharpMath.Atom.Atoms.FractionAlignment
+CSharpMath.Atom.Atoms.FractionAlignment.Center = 0 -> CSharpMath.Atom.Atoms.FractionAlignment
+CSharpMath.Atom.Atoms.FractionAlignment.Left = 1 -> CSharpMath.Atom.Atoms.FractionAlignment
+CSharpMath.Atom.Atoms.FractionAlignment.Right = 2 -> CSharpMath.Atom.Atoms.FractionAlignment
+CSharpMath.Atom.Atoms.FractionStyle
+CSharpMath.Atom.Atoms.FractionStyle.Auto = 0 -> CSharpMath.Atom.Atoms.FractionStyle
+CSharpMath.Atom.Atoms.FractionStyle.Display = 1 -> CSharpMath.Atom.Atoms.FractionStyle
+CSharpMath.Atom.Atoms.FractionStyle.Text = 2 -> CSharpMath.Atom.Atoms.FractionStyle
+CSharpMath.Atom.Atoms.Group
+CSharpMath.Atom.Atoms.Group.Clone(bool finalize) -> CSharpMath.Atom.Atoms.Group!
+CSharpMath.Atom.Atoms.Group.Group() -> void
+CSharpMath.Atom.Atoms.Group.InnerList.get -> CSharpMath.Atom.MathList!
+CSharpMath.Atom.Atoms.Group.InnerList.set -> void
+CSharpMath.Atom.Atoms.Macro
+CSharpMath.Atom.Atoms.Macro.Clone(bool finalize) -> CSharpMath.Atom.Atoms.Macro!
+CSharpMath.Atom.Atoms.Macro.Command.get -> string!
+CSharpMath.Atom.Atoms.Macro.Expansion() -> CSharpMath.Atom.MathList!
+CSharpMath.Atom.Atoms.Stack
+CSharpMath.Atom.Atoms.Stack.Clone(bool finalize) -> CSharpMath.Atom.Atoms.Stack!
+CSharpMath.Atom.Atoms.Stack.DisplayClassType.get -> System.Type!
+CSharpMath.Atom.Atoms.Stack.DisplayClassType.set -> void
+CSharpMath.Atom.Atoms.Stack.InnerList.get -> CSharpMath.Atom.MathList!
+CSharpMath.Atom.Atoms.Stack.InnerList.set -> void
+CSharpMath.Atom.Atoms.Stack.Over.get -> CSharpMath.Atom.Atoms.StackConstruction?
+CSharpMath.Atom.Atoms.Stack.Over.set -> void
+CSharpMath.Atom.Atoms.Stack.Stack() -> void
+CSharpMath.Atom.Atoms.Stack.Under.get -> CSharpMath.Atom.Atoms.StackConstruction?
+CSharpMath.Atom.Atoms.Stack.Under.set -> void
+CSharpMath.Atom.Atoms.StackConstruction
+CSharpMath.Atom.Atoms.StackConstruction.Clone(bool finalize) -> CSharpMath.Atom.Atoms.StackConstruction!
+CSharpMath.Atom.Atoms.StackConstruction.Extensible
+CSharpMath.Atom.Atoms.StackConstruction.Extensible.Extensible(string! glyph) -> void
+CSharpMath.Atom.Atoms.StackConstruction.Extensible.Glyph.get -> string!
+CSharpMath.Atom.Atoms.StackConstruction.MathListRow
+CSharpMath.Atom.Atoms.StackConstruction.MathListRow.Cramped.get -> bool
+CSharpMath.Atom.Atoms.StackConstruction.MathListRow.List.get -> CSharpMath.Atom.MathList!
+CSharpMath.Atom.Atoms.StackConstruction.MathListRow.MathListRow(CSharpMath.Atom.MathList! list, CSharpMath.Atom.LineStyle style, bool cramped) -> void
+CSharpMath.Atom.Atoms.StackConstruction.MathListRow.Style.get -> CSharpMath.Atom.LineStyle
+CSharpMath.Atom.Atoms.StrikeStyle
+CSharpMath.Atom.Atoms.StrikeStyle.Backward = 2 -> CSharpMath.Atom.Atoms.StrikeStyle
+CSharpMath.Atom.Atoms.StrikeStyle.Cross = 3 -> CSharpMath.Atom.Atoms.StrikeStyle
+CSharpMath.Atom.Atoms.StrikeStyle.Forward = 1 -> CSharpMath.Atom.Atoms.StrikeStyle
+CSharpMath.Atom.Atoms.StrikeStyle.Horizontal = 4 -> CSharpMath.Atom.Atoms.StrikeStyle
+CSharpMath.Atom.Atoms.StrikeStyle.None = 0 -> CSharpMath.Atom.Atoms.StrikeStyle
+CSharpMath.Atom.Atoms.Table.CellStyle.get -> CSharpMath.Atom.LineStyle?
+CSharpMath.Atom.Atoms.Table.CellStyle.set -> void
+CSharpMath.Atom.Atoms.Table.HorizontalLines.get -> System.Collections.Generic.List<int>!
+CSharpMath.Atom.Atoms.Table.HorizontalLines.set -> void
+CSharpMath.Atom.Atoms.Table.VerticalLines.get -> System.Collections.Generic.List<int>!
+CSharpMath.Atom.Atoms.Table.VerticalLines.set -> void
+CSharpMath.Atom.LaTeXParser.IsReadingOneCharField.get -> bool
+CSharpMath.Atom.LaTeXParser.IsReadingStopCharField.get -> bool
+CSharpMath.Atom.LaTeXParser.PeekChar() -> char
+CSharpMath.Atom.LaTeXParser.ReadCommandName() -> string!
+CSharpMath.Atom.LaTeXParser.TableEnvironment.Argument.get -> string?
+CSharpMath.Atom.LaTeXParser.TableEnvironment.Argument.set -> void
+CSharpMath.Atom.LaTeXParser.TableEnvironment.HorizontalLines.get -> System.Collections.Generic.List<int>!
+CSharpMath.Atom.LaTeXParser.UndoTo(int position) -> void
+CSharpMath.Display.Displays.BoxDisplay<TFont, TGlyph>
+CSharpMath.Display.Displays.BoxDisplay<TFont, TGlyph>.Ascent.get -> float
+CSharpMath.Display.Displays.BoxDisplay<TFont, TGlyph>.Ascent.set -> void
+CSharpMath.Display.Displays.BoxDisplay<TFont, TGlyph>.BackColor.get -> System.Drawing.Color?
+CSharpMath.Display.Displays.BoxDisplay<TFont, TGlyph>.BackColor.set -> void
+CSharpMath.Display.Displays.BoxDisplay<TFont, TGlyph>.BoxDisplay(CSharpMath.Display.Displays.ListDisplay<TFont, TGlyph>! child, bool keepWidth, bool keepHeight, bool keepDepth, bool drawChild, CSharpMath.Atom.Atoms.BoxHAlign hAlign, CSharpMath.Atom.Atoms.StrikeStyle strikeStyle, float strikeThickness, float strikeVerticalOffset, CSharpMath.Atom.Range range) -> void
+CSharpMath.Display.Displays.BoxDisplay<TFont, TGlyph>.Child.get -> CSharpMath.Display.Displays.ListDisplay<TFont, TGlyph>!
+CSharpMath.Display.Displays.BoxDisplay<TFont, TGlyph>.Descent.get -> float
+CSharpMath.Display.Displays.BoxDisplay<TFont, TGlyph>.Descent.set -> void
+CSharpMath.Display.Displays.BoxDisplay<TFont, TGlyph>.Draw(CSharpMath.Display.FrontEnd.IGraphicsContext<TFont, TGlyph>! context) -> void
+CSharpMath.Display.Displays.BoxDisplay<TFont, TGlyph>.DrawChild.get -> bool
+CSharpMath.Display.Displays.BoxDisplay<TFont, TGlyph>.HAlign.get -> CSharpMath.Atom.Atoms.BoxHAlign
+CSharpMath.Display.Displays.BoxDisplay<TFont, TGlyph>.HasScript.get -> bool
+CSharpMath.Display.Displays.BoxDisplay<TFont, TGlyph>.HasScript.set -> void
+CSharpMath.Display.Displays.BoxDisplay<TFont, TGlyph>.KeepWidth.get -> bool
+CSharpMath.Display.Displays.BoxDisplay<TFont, TGlyph>.Position.get -> System.Drawing.PointF
+CSharpMath.Display.Displays.BoxDisplay<TFont, TGlyph>.Position.set -> void
+CSharpMath.Display.Displays.BoxDisplay<TFont, TGlyph>.Range.get -> CSharpMath.Atom.Range
+CSharpMath.Display.Displays.BoxDisplay<TFont, TGlyph>.SetTextColorRecursive(System.Drawing.Color? textColor) -> void
+CSharpMath.Display.Displays.BoxDisplay<TFont, TGlyph>.StrikeStyle.get -> CSharpMath.Atom.Atoms.StrikeStyle
+CSharpMath.Display.Displays.BoxDisplay<TFont, TGlyph>.StrikeThickness.get -> float
+CSharpMath.Display.Displays.BoxDisplay<TFont, TGlyph>.StrikeVerticalOffset.get -> float
+CSharpMath.Display.Displays.BoxDisplay<TFont, TGlyph>.TextColor.get -> System.Drawing.Color?
+CSharpMath.Display.Displays.BoxDisplay<TFont, TGlyph>.TextColor.set -> void
+CSharpMath.Display.Displays.BoxDisplay<TFont, TGlyph>.Width.get -> float
+CSharpMath.Display.Displays.BoxDisplay<TFont, TGlyph>.Width.set -> void
+CSharpMath.Display.Displays.FractionDisplay<TFont, TGlyph>.NumeratorAlignment.get -> CSharpMath.Atom.Atoms.FractionAlignment
+CSharpMath.Display.Displays.FractionDisplay<TFont, TGlyph>.NumeratorAlignment.set -> void
+CSharpMath.Display.Displays.ListDisplay<TFont, TGlyph>.SetOverrideMetrics(float ascent, float descent, float width) -> void
+CSharpMath.Display.Displays.ListDisplay<TFont, TGlyph>.SetRangeOverride(CSharpMath.Atom.Range range) -> void
+CSharpMath.Display.Displays.RuleDisplay<TFont, TGlyph>
+CSharpMath.Display.Displays.RuleDisplay<TFont, TGlyph>.Ascent.get -> float
+CSharpMath.Display.Displays.RuleDisplay<TFont, TGlyph>.Ascent.set -> void
+CSharpMath.Display.Displays.RuleDisplay<TFont, TGlyph>.BackColor.get -> System.Drawing.Color?
+CSharpMath.Display.Displays.RuleDisplay<TFont, TGlyph>.BackColor.set -> void
+CSharpMath.Display.Displays.RuleDisplay<TFont, TGlyph>.Descent.get -> float
+CSharpMath.Display.Displays.RuleDisplay<TFont, TGlyph>.Descent.set -> void
+CSharpMath.Display.Displays.RuleDisplay<TFont, TGlyph>.Draw(CSharpMath.Display.FrontEnd.IGraphicsContext<TFont, TGlyph>! context) -> void
+CSharpMath.Display.Displays.RuleDisplay<TFont, TGlyph>.HasScript.get -> bool
+CSharpMath.Display.Displays.RuleDisplay<TFont, TGlyph>.HasScript.set -> void
+CSharpMath.Display.Displays.RuleDisplay<TFont, TGlyph>.Position.get -> System.Drawing.PointF
+CSharpMath.Display.Displays.RuleDisplay<TFont, TGlyph>.Position.set -> void
+CSharpMath.Display.Displays.RuleDisplay<TFont, TGlyph>.Range.get -> CSharpMath.Atom.Range
+CSharpMath.Display.Displays.RuleDisplay<TFont, TGlyph>.RuleDisplay(System.Drawing.PointF centreLineStart, float length, float thickness, bool vertical, CSharpMath.Atom.Range range) -> void
+CSharpMath.Display.Displays.RuleDisplay<TFont, TGlyph>.SetTextColorRecursive(System.Drawing.Color? textColor) -> void
+CSharpMath.Display.Displays.RuleDisplay<TFont, TGlyph>.TextColor.get -> System.Drawing.Color?
+CSharpMath.Display.Displays.RuleDisplay<TFont, TGlyph>.TextColor.set -> void
+CSharpMath.Display.Displays.RuleDisplay<TFont, TGlyph>.Width.get -> float
+CSharpMath.Display.Displays.RuleDisplay<TFont, TGlyph>.Width.set -> void
+CSharpMath.Display.Displays.StackDisplay<TFont, TGlyph>
+CSharpMath.Display.Displays.StackDisplay<TFont, TGlyph>.Ascent.get -> float
+CSharpMath.Display.Displays.StackDisplay<TFont, TGlyph>.Ascent.set -> void
+CSharpMath.Display.Displays.StackDisplay<TFont, TGlyph>.BackColor.get -> System.Drawing.Color?
+CSharpMath.Display.Displays.StackDisplay<TFont, TGlyph>.BackColor.set -> void
+CSharpMath.Display.Displays.StackDisplay<TFont, TGlyph>.Base.get -> CSharpMath.Display.Displays.ListDisplay<TFont, TGlyph>!
+CSharpMath.Display.Displays.StackDisplay<TFont, TGlyph>.Descent.get -> float
+CSharpMath.Display.Displays.StackDisplay<TFont, TGlyph>.Descent.set -> void
+CSharpMath.Display.Displays.StackDisplay<TFont, TGlyph>.Draw(CSharpMath.Display.FrontEnd.IGraphicsContext<TFont, TGlyph>! context) -> void
+CSharpMath.Display.Displays.StackDisplay<TFont, TGlyph>.HasScript.get -> bool
+CSharpMath.Display.Displays.StackDisplay<TFont, TGlyph>.HasScript.set -> void
+CSharpMath.Display.Displays.StackDisplay<TFont, TGlyph>.Over.get -> CSharpMath.Display.IDisplay<TFont, TGlyph>?
+CSharpMath.Display.Displays.StackDisplay<TFont, TGlyph>.Position.get -> System.Drawing.PointF
+CSharpMath.Display.Displays.StackDisplay<TFont, TGlyph>.Position.set -> void
+CSharpMath.Display.Displays.StackDisplay<TFont, TGlyph>.Range.get -> CSharpMath.Atom.Range
+CSharpMath.Display.Displays.StackDisplay<TFont, TGlyph>.SetTextColorRecursive(System.Drawing.Color? textColor) -> void
+CSharpMath.Display.Displays.StackDisplay<TFont, TGlyph>.StackDisplay(CSharpMath.Display.Displays.ListDisplay<TFont, TGlyph>! baseDisplay, CSharpMath.Display.IDisplay<TFont, TGlyph>? over, CSharpMath.Display.IDisplay<TFont, TGlyph>? under, CSharpMath.Atom.Range range) -> void
+CSharpMath.Display.Displays.StackDisplay<TFont, TGlyph>.TextColor.get -> System.Drawing.Color?
+CSharpMath.Display.Displays.StackDisplay<TFont, TGlyph>.TextColor.set -> void
+CSharpMath.Display.Displays.StackDisplay<TFont, TGlyph>.Under.get -> CSharpMath.Display.IDisplay<TFont, TGlyph>?
+CSharpMath.Display.Displays.StackDisplay<TFont, TGlyph>.Width.get -> float
+CSharpMath.Display.Displays.StackDisplay<TFont, TGlyph>.Width.set -> void
+override CSharpMath.Atom.Atoms.Box.DebugString.get -> string!
+override CSharpMath.Atom.Atoms.Box.ScriptsAllowed.get -> bool
+override CSharpMath.Atom.Atoms.Group.DebugString.get -> string!
+override CSharpMath.Atom.Atoms.Group.ScriptsAllowed.get -> bool
+override CSharpMath.Atom.Atoms.Macro.DebugString.get -> string!
+override CSharpMath.Atom.Atoms.Macro.ScriptsAllowed.get -> bool
+override CSharpMath.Atom.Atoms.Stack.DebugString.get -> string!
+override CSharpMath.Atom.Atoms.Stack.ScriptsAllowed.get -> bool
+override CSharpMath.Display.Displays.BoxDisplay<TFont, TGlyph>.ToString() -> string!
+override CSharpMath.Display.Displays.RuleDisplay<TFont, TGlyph>.ToString() -> string!
+override CSharpMath.Display.Displays.StackDisplay<TFont, TGlyph>.ToString() -> string!
+static CSharpMath.Atom.LaTeXSettings.AddMacro(string! name, int argumentCount, string! template) -> void
+CSharpMath.Atom.Atoms.LargeDelimiter
+CSharpMath.Atom.Atoms.LargeDelimiter.Clone(bool finalize) -> CSharpMath.Atom.Atoms.LargeDelimiter!
+CSharpMath.Atom.Atoms.LargeDelimiter.DelimiterSize
+CSharpMath.Atom.Atoms.LargeDelimiter.DelimiterSize.Size1 = 1 -> CSharpMath.Atom.Atoms.LargeDelimiter.DelimiterSize
+CSharpMath.Atom.Atoms.LargeDelimiter.DelimiterSize.Size2 = 2 -> CSharpMath.Atom.Atoms.LargeDelimiter.DelimiterSize
+CSharpMath.Atom.Atoms.LargeDelimiter.DelimiterSize.Size3 = 3 -> CSharpMath.Atom.Atoms.LargeDelimiter.DelimiterSize
+CSharpMath.Atom.Atoms.LargeDelimiter.DelimiterSize.Size4 = 4 -> CSharpMath.Atom.Atoms.LargeDelimiter.DelimiterSize
+CSharpMath.Atom.Atoms.LargeDelimiter.LargeDelimiter(string! nucleus, CSharpMath.Atom.Atoms.LargeDelimiter.DelimiterSize size, System.Type! mathClass) -> void
+CSharpMath.Atom.Atoms.LargeDelimiter.MathClass.get -> System.Type!
+CSharpMath.Atom.Atoms.LargeDelimiter.Size.get -> CSharpMath.Atom.Atoms.LargeDelimiter.DelimiterSize
+CSharpMath.Atom.Atoms.Macro.Arguments.get -> System.Collections.Generic.IReadOnlyList<string!>!
+CSharpMath.Display.Displays.GlyphConstructionDisplay<TFont, TGlyph>.InkWidth.get -> float
+CSharpMath.Display.Displays.GlyphDisplay<TFont, TGlyph>.InkWidth.get -> float
+CSharpMath.Display.Displays.HorizontalGlyphConstructionDisplay<TFont, TGlyph>.InkWidth.get -> float
+CSharpMath.Display.Displays.TextRunDisplay<TFont, TGlyph>.InkWidth.get -> float
+CSharpMath.Display.FrontEnd.IFontGlyphBounds<TGlyph>
+CSharpMath.Display.FrontEnd.IFontGlyphBounds<TGlyph>.GetAdvances(System.Collections.Generic.IEnumerable<TGlyph>! glyphs) -> System.Collections.Generic.IEnumerable<float>!
+CSharpMath.Display.FrontEnd.IFontGlyphBounds<TGlyph>.GetBoundingRects(System.Collections.Generic.IEnumerable<TGlyph>! glyphs) -> System.Collections.Generic.IEnumerable<System.Drawing.RectangleF>!
+CSharpMath.Display.IInkDisplay
+CSharpMath.Display.IInkDisplay.InkWidth.get -> float
+override CSharpMath.Atom.Atoms.LargeDelimiter.ScriptsAllowed.get -> bool
+override CSharpMath.Atom.Atoms.Style.FontStyle.get -> CSharpMath.Atom.FontStyle
+override CSharpMath.Atom.Atoms.Style.FontStyle.set -> void
+override CSharpMath.Atom.Atoms.Style.Nucleus.get -> string!
+override CSharpMath.Atom.Atoms.Style.Nucleus.set -> void
+static CSharpMath.Extensions.InkWidth<TFont, TGlyph>(this CSharpMath.Display.IDisplay<TFont, TGlyph>! display) -> float
+virtual CSharpMath.Atom.MathAtom.FontStyle.get -> CSharpMath.Atom.FontStyle
+virtual CSharpMath.Atom.MathAtom.FontStyle.set -> void
+virtual CSharpMath.Atom.MathAtom.Nucleus.get -> string!
+virtual CSharpMath.Atom.MathAtom.Nucleus.set -> void
+*REMOVED*CSharpMath.Atom.MathAtom.FontStyle.get -> CSharpMath.Atom.FontStyle
+*REMOVED*CSharpMath.Atom.MathAtom.FontStyle.set -> void
+*REMOVED*CSharpMath.Atom.MathAtom.Nucleus.get -> string!
+*REMOVED*CSharpMath.Atom.MathAtom.Nucleus.set -> void