From 719355da90d6ddf9633461be99bed51a311783a6 Mon Sep 17 00:00:00 2001
From: Frank Tovar <mail@franktovar.de>
Date: Sat, 14 Mar 2026 01:25:43 +0100
Subject: [PATCH] Use XML geometry for critical PDF import

---
 src/RolemasterDb.App/rolemaster.db            | Bin 159744 -> 159744 bytes
 .../CriticalImportCommandRunner.cs            |  31 +-
 .../ImportArtifactPaths.cs                    |  24 +-
 .../ImportArtifactWriter.cs                   |  33 ++
 .../Parsing/ImportValidationReport.cs         |  13 +
 .../Parsing/ParsedCriticalCellArtifact.cs     |  17 +
 .../StandardCriticalTableParseResult.cs       |  13 +
 .../Parsing/StandardCriticalTableParser.cs    | 377 +++++++++---------
 .../Parsing/XmlTextFragment.cs                |  18 +
 ...PdfTextExtractor.cs => PdfXmlExtractor.cs} |  10 +-
 10 files changed, 335 insertions(+), 201 deletions(-)
 create mode 100644 src/RolemasterDb.ImportTool/ImportArtifactWriter.cs
 create mode 100644 src/RolemasterDb.ImportTool/Parsing/ImportValidationReport.cs
 create mode 100644 src/RolemasterDb.ImportTool/Parsing/ParsedCriticalCellArtifact.cs
 create mode 100644 src/RolemasterDb.ImportTool/Parsing/StandardCriticalTableParseResult.cs
 create mode 100644 src/RolemasterDb.ImportTool/Parsing/XmlTextFragment.cs
 rename src/RolemasterDb.ImportTool/{PdfTextExtractor.cs => PdfXmlExtractor.cs} (77%)

diff --git a/src/RolemasterDb.App/rolemaster.db b/src/RolemasterDb.App/rolemaster.db
index 8b072662857ae9ce1a28552f0df9f17741e12e18..183b54ec72aa2ef6c83414385abf942024f0d3cf 100644
GIT binary patch
delta 12986
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
Ijq}F-Kg$TkJpcdz

delta 11609
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
Ht@VEaY`zsP

diff --git a/src/RolemasterDb.ImportTool/CriticalImportCommandRunner.cs b/src/RolemasterDb.ImportTool/CriticalImportCommandRunner.cs
index 238775f..4cbaf30 100644
--- a/src/RolemasterDb.ImportTool/CriticalImportCommandRunner.cs
+++ b/src/RolemasterDb.ImportTool/CriticalImportCommandRunner.cs
@@ -5,7 +5,8 @@ namespace RolemasterDb.ImportTool;
 public sealed class CriticalImportCommandRunner
 {
     private readonly CriticalImportManifestLoader manifestLoader = new();
-    private readonly PdfTextExtractor pdfTextExtractor = new();
+    private readonly ImportArtifactWriter artifactWriter = new();
+    private readonly PdfXmlExtractor pdfXmlExtractor = new();
     private readonly StandardCriticalTableParser standardParser = new();
 
     public async Task<int> RunAsync(ResetOptions options)
@@ -26,8 +27,8 @@ public sealed class CriticalImportCommandRunner
     {
         var entry = GetManifestEntry(options.Table);
         var artifactPaths = CreateArtifactPaths(entry.Slug);
-        await pdfTextExtractor.ExtractAsync(ResolveRepositoryPath(entry.PdfPath), artifactPaths.ExtractedTextPath);
-        Console.WriteLine($"Extracted {entry.Slug} to {artifactPaths.ExtractedTextPath}");
+        await pdfXmlExtractor.ExtractAsync(ResolveRepositoryPath(entry.PdfPath), artifactPaths.XmlPath);
+        Console.WriteLine($"Extracted {entry.Slug} to {artifactPaths.XmlPath}");
         return 0;
     }
 
@@ -36,16 +37,24 @@ public sealed class CriticalImportCommandRunner
         var entry = GetManifestEntry(options.Table);
         var artifactPaths = CreateArtifactPaths(entry.Slug);
 
-        if (!File.Exists(artifactPaths.ExtractedTextPath))
+        if (!File.Exists(artifactPaths.XmlPath))
         {
-            Console.Error.WriteLine($"Missing extracted text artifact: {artifactPaths.ExtractedTextPath}");
+            Console.Error.WriteLine($"Missing XML artifact: {artifactPaths.XmlPath}");
             return 1;
         }
 
-        var extractedText = await File.ReadAllTextAsync(artifactPaths.ExtractedTextPath);
-        var parsedTable = Parse(entry, extractedText);
+        var xmlContent = await File.ReadAllTextAsync(artifactPaths.XmlPath);
+        var parseResult = Parse(entry, xmlContent);
+        await artifactWriter.WriteAsync(artifactPaths, parseResult, CancellationToken.None);
+
+        if (!parseResult.ValidationReport.IsValid)
+        {
+            throw new InvalidOperationException(
+                $"Validation failed for '{entry.Slug}'. See {artifactPaths.ValidationReportPath} for details.");
+        }
+
         var loader = new CriticalImportLoader(ResolveDatabasePath(options.DatabasePath));
-        var result = await loader.LoadAsync(parsedTable);
+        var result = await loader.LoadAsync(parseResult.Table);
 
         Console.WriteLine(
             $"Loaded {result.TableSlug}: {result.ColumnCount} columns, {result.RollBandCount} roll bands, {result.ResultCount} results.");
@@ -82,14 +91,14 @@ public sealed class CriticalImportCommandRunner
             ?? throw new InvalidOperationException($"No enabled manifest entry was found for '{tableSlug}'.");
     }
 
-    private ParsedCriticalTable Parse(CriticalImportManifestEntry entry, string extractedText)
+    private StandardCriticalTableParseResult Parse(CriticalImportManifestEntry entry, string xmlContent)
     {
         if (!string.Equals(entry.Family, "standard", StringComparison.OrdinalIgnoreCase))
         {
-            throw new InvalidOperationException($"Family '{entry.Family}' is not supported by phase 1.");
+            throw new InvalidOperationException($"Family '{entry.Family}' is not supported by phase 2.");
         }
 
-        return standardParser.Parse(entry, extractedText);
+        return standardParser.Parse(entry, xmlContent);
     }
 
     private static ImportArtifactPaths CreateArtifactPaths(string slug) =>
diff --git a/src/RolemasterDb.ImportTool/ImportArtifactPaths.cs b/src/RolemasterDb.ImportTool/ImportArtifactPaths.cs
index 7965855..8b45346 100644
--- a/src/RolemasterDb.ImportTool/ImportArtifactPaths.cs
+++ b/src/RolemasterDb.ImportTool/ImportArtifactPaths.cs
@@ -2,18 +2,34 @@ namespace RolemasterDb.ImportTool;
 
 public sealed class ImportArtifactPaths
 {
-    private ImportArtifactPaths(string directoryPath, string extractedTextPath)
+    private ImportArtifactPaths(
+        string directoryPath,
+        string xmlPath,
+        string fragmentsJsonPath,
+        string parsedCellsJsonPath,
+        string validationReportPath)
     {
         DirectoryPath = directoryPath;
-        ExtractedTextPath = extractedTextPath;
+        XmlPath = xmlPath;
+        FragmentsJsonPath = fragmentsJsonPath;
+        ParsedCellsJsonPath = parsedCellsJsonPath;
+        ValidationReportPath = validationReportPath;
     }
 
     public string DirectoryPath { get; }
-    public string ExtractedTextPath { get; }
+    public string XmlPath { get; }
+    public string FragmentsJsonPath { get; }
+    public string ParsedCellsJsonPath { get; }
+    public string ValidationReportPath { get; }
 
     public static ImportArtifactPaths Create(string artifactsRootPath, string tableSlug)
     {
         var directoryPath = Path.Combine(artifactsRootPath, tableSlug);
-        return new ImportArtifactPaths(directoryPath, Path.Combine(directoryPath, "extracted.txt"));
+        return new ImportArtifactPaths(
+            directoryPath,
+            Path.Combine(directoryPath, "source.xml"),
+            Path.Combine(directoryPath, "fragments.json"),
+            Path.Combine(directoryPath, "parsed-cells.json"),
+            Path.Combine(directoryPath, "validation-report.json"));
     }
 }
diff --git a/src/RolemasterDb.ImportTool/ImportArtifactWriter.cs b/src/RolemasterDb.ImportTool/ImportArtifactWriter.cs
new file mode 100644
index 0000000..53c3cc4
--- /dev/null
+++ b/src/RolemasterDb.ImportTool/ImportArtifactWriter.cs
@@ -0,0 +1,33 @@
+using System.Text.Json;
+
+using RolemasterDb.ImportTool.Parsing;
+
+namespace RolemasterDb.ImportTool;
+
+public sealed class ImportArtifactWriter
+{
+    private static readonly JsonSerializerOptions JsonOptions = new()
+    {
+        WriteIndented = true
+    };
+
+    public async Task WriteAsync(ImportArtifactPaths artifactPaths, StandardCriticalTableParseResult parseResult, CancellationToken cancellationToken = default)
+    {
+        Directory.CreateDirectory(artifactPaths.DirectoryPath);
+
+        await File.WriteAllTextAsync(
+            artifactPaths.FragmentsJsonPath,
+            JsonSerializer.Serialize(parseResult.Fragments, JsonOptions),
+            cancellationToken);
+
+        await File.WriteAllTextAsync(
+            artifactPaths.ParsedCellsJsonPath,
+            JsonSerializer.Serialize(parseResult.Cells, JsonOptions),
+            cancellationToken);
+
+        await File.WriteAllTextAsync(
+            artifactPaths.ValidationReportPath,
+            JsonSerializer.Serialize(parseResult.ValidationReport, JsonOptions),
+            cancellationToken);
+    }
+}
diff --git a/src/RolemasterDb.ImportTool/Parsing/ImportValidationReport.cs b/src/RolemasterDb.ImportTool/Parsing/ImportValidationReport.cs
new file mode 100644
index 0000000..f9a4c73
--- /dev/null
+++ b/src/RolemasterDb.ImportTool/Parsing/ImportValidationReport.cs
@@ -0,0 +1,13 @@
+namespace RolemasterDb.ImportTool.Parsing;
+
+public sealed class ImportValidationReport(
+    bool isValid,
+    IReadOnlyList<string> errors,
+    int rowCount,
+    int cellCount)
+{
+    public bool IsValid { get; } = isValid;
+    public IReadOnlyList<string> Errors { get; } = errors;
+    public int RowCount { get; } = rowCount;
+    public int CellCount { get; } = cellCount;
+}
diff --git a/src/RolemasterDb.ImportTool/Parsing/ParsedCriticalCellArtifact.cs b/src/RolemasterDb.ImportTool/Parsing/ParsedCriticalCellArtifact.cs
new file mode 100644
index 0000000..76475a3
--- /dev/null
+++ b/src/RolemasterDb.ImportTool/Parsing/ParsedCriticalCellArtifact.cs
@@ -0,0 +1,17 @@
+namespace RolemasterDb.ImportTool.Parsing;
+
+public sealed class ParsedCriticalCellArtifact(
+    string rollBandLabel,
+    string columnKey,
+    IReadOnlyList<string> lines,
+    string rawCellText,
+    string descriptionText,
+    string? rawAffixText)
+{
+    public string RollBandLabel { get; } = rollBandLabel;
+    public string ColumnKey { get; } = columnKey;
+    public IReadOnlyList<string> Lines { get; } = lines;
+    public string RawCellText { get; } = rawCellText;
+    public string DescriptionText { get; } = descriptionText;
+    public string? RawAffixText { get; } = rawAffixText;
+}
diff --git a/src/RolemasterDb.ImportTool/Parsing/StandardCriticalTableParseResult.cs b/src/RolemasterDb.ImportTool/Parsing/StandardCriticalTableParseResult.cs
new file mode 100644
index 0000000..0b5182a
--- /dev/null
+++ b/src/RolemasterDb.ImportTool/Parsing/StandardCriticalTableParseResult.cs
@@ -0,0 +1,13 @@
+namespace RolemasterDb.ImportTool.Parsing;
+
+public sealed class StandardCriticalTableParseResult(
+    ParsedCriticalTable table,
+    IReadOnlyList<XmlTextFragment> fragments,
+    IReadOnlyList<ParsedCriticalCellArtifact> cells,
+    ImportValidationReport validationReport)
+{
+    public ParsedCriticalTable Table { get; } = table;
+    public IReadOnlyList<XmlTextFragment> Fragments { get; } = fragments;
+    public IReadOnlyList<ParsedCriticalCellArtifact> Cells { get; } = cells;
+    public ImportValidationReport ValidationReport { get; } = validationReport;
+}
diff --git a/src/RolemasterDb.ImportTool/Parsing/StandardCriticalTableParser.cs b/src/RolemasterDb.ImportTool/Parsing/StandardCriticalTableParser.cs
index 7e52e80..876c9cd 100644
--- a/src/RolemasterDb.ImportTool/Parsing/StandardCriticalTableParser.cs
+++ b/src/RolemasterDb.ImportTool/Parsing/StandardCriticalTableParser.cs
@@ -1,208 +1,206 @@
 using System.Text.RegularExpressions;
+using System.Xml;
+using System.Xml.Linq;
 
 namespace RolemasterDb.ImportTool.Parsing;
 
 public sealed class StandardCriticalTableParser
 {
-    private static readonly Regex ColumnRegex = new(@"\b([A-E])\b", RegexOptions.IgnoreCase | RegexOptions.Compiled);
-    private static readonly Regex RollBandRegex = new(@"^\s*(?<label>\d{2,3}(?:-\d{2,3})?|\d{2,3}\+)\s*$", RegexOptions.Compiled);
-    private static readonly Regex RollBandLineRegex = new(@"^\s*(?<label>\d{2,3}(?:-\d{2,3})?|\d{2,3}\+)(?<rest>\s+.*)?$", RegexOptions.Compiled);
+    private const int HeaderToBodyMinimumGap = 20;
+    private const int TopGroupingTolerance = 2;
 
-    public ParsedCriticalTable Parse(CriticalImportManifestEntry entry, string extractedText)
+    public StandardCriticalTableParseResult Parse(CriticalImportManifestEntry entry, string xmlContent)
     {
-        var lines = extractedText.Replace("\r\n", "\n", StringComparison.Ordinal)
-            .Replace('\f', '\n')
-            .Split('\n');
+        var fragments = LoadFragments(xmlContent);
+        var headerFragments = FindHeaderFragments(fragments);
+        var rowLabelFragments = FindRowLabelFragments(fragments, headerFragments);
+        var validationErrors = new List<string>();
 
-        var headerIndex = Array.FindIndex(lines, IsColumnHeaderLine);
-        if (headerIndex < 0)
-        {
-            throw new InvalidOperationException("The standard table header could not be found in the extracted text.");
-        }
-
-        var columnStarts = GetColumnStarts(lines[headerIndex]);
-        var boundaries = GetColumnBoundaries(columnStarts);
-        var columns = columnStarts
-            .Select((item, index) => new ParsedCriticalColumn(item.Label, item.Label, "severity", index + 1))
+        var columnCenters = headerFragments
+            .OrderBy(item => item.Left)
+            .Select(item => new ColumnAnchor(item.Text.ToUpperInvariant(), item.CenterX))
             .ToList();
 
-        var firstRollBandIndex = FindNextRollBandIndex(lines, headerIndex + 1);
-        if (firstRollBandIndex < 0)
-        {
-            throw new InvalidOperationException("No roll bands were found in the extracted text.");
-        }
-
-        var keyLineIndex = Array.FindIndex(lines, firstRollBandIndex, item => item.TrimStart().StartsWith("Key:", StringComparison.OrdinalIgnoreCase));
-        if (keyLineIndex < 0)
-        {
-            keyLineIndex = lines.Length;
-        }
-
-        var leadingLines = lines[(headerIndex + 1)..firstRollBandIndex]
-            .Where(item => !string.IsNullOrWhiteSpace(item))
+        var rowAnchors = rowLabelFragments
+            .OrderBy(item => item.Top)
+            .Select((item, index) => new RowAnchor(item.Text, item.Top, index + 1))
             .ToList();
 
-        var rollBands = new List<ParsedCriticalRollBand>();
-        var results = new List<ParsedCriticalResult>();
-        var currentLabel = string.Empty;
-        var currentRowLines = new List<string>();
-        var rowIndex = 0;
-
-        void FlushCurrentRow()
+        if (rowAnchors.Count == 0)
         {
-            if (string.IsNullOrEmpty(currentLabel))
-            {
-                return;
-            }
-
-            rowIndex++;
-            var rollBand = CreateRollBand(currentLabel, rowIndex);
-            rollBands.Add(rollBand);
-
-            var cellLines = SplitRowLines(currentRowLines, boundaries, columns.Count);
-            for (var columnIndex = 0; columnIndex < columns.Count; columnIndex++)
-            {
-                var rawCellLines = cellLines[columnIndex]
-                    .Where(item => !string.IsNullOrWhiteSpace(item))
-                    .ToList();
-
-                var rawAffixLines = rawCellLines
-                    .Where(IsAffixLikeLine)
-                    .ToList();
-
-                var descriptionLines = rawCellLines
-                    .Where(item => !IsAffixLikeLine(item))
-                    .ToList();
-
-                results.Add(new ParsedCriticalResult(
-                    columns[columnIndex].ColumnKey,
-                    rollBand.Label,
-                    string.Join(Environment.NewLine, rawCellLines),
-                    CollapseWhitespace(string.Join(' ', descriptionLines)),
-                    rawAffixLines.Count == 0 ? null : string.Join(Environment.NewLine, rawAffixLines)));
-            }
-
-            currentLabel = string.Empty;
-            currentRowLines = new List<string>();
+            validationErrors.Add("No roll-band labels were found in the XML artifact.");
         }
 
-        for (var lineIndex = firstRollBandIndex; lineIndex < keyLineIndex; lineIndex++)
+        var bodyStartTop = headerFragments.Max(item => item.Top) + HeaderToBodyMinimumGap;
+        var keyTop = fragments
+            .Where(item => string.Equals(item.Text, "Key:", StringComparison.OrdinalIgnoreCase))
+            .Select(item => (int?)item.Top)
+            .Min() ?? int.MaxValue;
+
+        var bodyFragments = fragments
+            .Where(item =>
+                item.Top >= bodyStartTop &&
+                item.Top < keyTop - 1 &&
+                !rowAnchors.Any(anchor => anchor.Top == item.Top && string.Equals(anchor.Label, item.Text, StringComparison.OrdinalIgnoreCase)) &&
+                !headerFragments.Contains(item))
+            .ToList();
+
+        var parsedRollBands = rowAnchors
+            .Select(anchor => CreateRollBand(anchor.Label, anchor.SortOrder))
+            .ToList();
+
+        var parsedCells = new List<ParsedCriticalCellArtifact>();
+        var parsedResults = new List<ParsedCriticalResult>();
+
+        for (var rowIndex = 0; rowIndex < rowAnchors.Count; rowIndex++)
         {
-            if (TryParseRollBandLine(lines[lineIndex], out var label, out var trailingText))
+            var rowStart = rowIndex == 0
+                ? bodyStartTop
+                : (int)Math.Floor((rowAnchors[rowIndex - 1].Top + rowAnchors[rowIndex].Top) / 2.0);
+
+            var rowEnd = rowIndex == rowAnchors.Count - 1
+                ? keyTop - 1
+                : (int)Math.Floor((rowAnchors[rowIndex].Top + rowAnchors[rowIndex + 1].Top) / 2.0);
+
+            var rowFragments = bodyFragments
+                .Where(item => item.Top >= rowStart && item.Top < rowEnd)
+                .ToList();
+
+            foreach (var columnAnchor in columnCenters)
             {
-                var trailingTextBelongsToCurrentRow = IsAffixLikeLine(trailingText);
+                var cellFragments = rowFragments
+                    .Where(item => ResolveColumn(item.CenterX, columnCenters) == columnAnchor.Key)
+                    .OrderBy(item => item.Top)
+                    .ThenBy(item => item.Left)
+                    .ToList();
 
-                if (!string.IsNullOrWhiteSpace(trailingText) &&
-                    !string.IsNullOrEmpty(currentLabel) &&
-                    !trailingTextBelongsToCurrentRow)
+                if (cellFragments.Count == 0)
                 {
-                    currentRowLines.Add(trailingText);
+                    validationErrors.Add($"Missing content for roll band '{rowAnchors[rowIndex].Label}', column '{columnAnchor.Key}'.");
+                    continue;
                 }
 
-                FlushCurrentRow();
-                currentLabel = label;
-                if (rowIndex == 0)
-                {
-                    currentRowLines.AddRange(leadingLines);
-                }
+                var lines = BuildLines(cellFragments);
+                var rawAffixLines = lines.Where(IsAffixLikeLine).ToList();
+                var descriptionLines = lines.Where(line => !IsAffixLikeLine(line)).ToList();
+                var rawCellText = string.Join(Environment.NewLine, lines);
+                var descriptionText = CollapseWhitespace(string.Join(' ', descriptionLines));
+                var rawAffixText = rawAffixLines.Count == 0 ? null : string.Join(Environment.NewLine, rawAffixLines);
 
-                if (!string.IsNullOrWhiteSpace(trailingText) && trailingTextBelongsToCurrentRow)
-                {
-                    currentRowLines.Add(trailingText);
-                }
+                parsedCells.Add(new ParsedCriticalCellArtifact(
+                    rowAnchors[rowIndex].Label,
+                    columnAnchor.Key,
+                    lines,
+                    rawCellText,
+                    descriptionText,
+                    rawAffixText));
 
-                continue;
-            }
-
-            if (!string.IsNullOrWhiteSpace(lines[lineIndex]))
-            {
-                currentRowLines.Add(lines[lineIndex]);
+                parsedResults.Add(new ParsedCriticalResult(
+                    columnAnchor.Key,
+                    rowAnchors[rowIndex].Label,
+                    rawCellText,
+                    descriptionText,
+                    rawAffixText));
             }
         }
 
-        FlushCurrentRow();
+        if (columnCenters.Count != 5)
+        {
+            validationErrors.Add($"Expected 5 standard-table columns but found {columnCenters.Count}.");
+        }
 
-        return new ParsedCriticalTable(
+        if (parsedCells.Count != rowAnchors.Count * columnCenters.Count)
+        {
+            validationErrors.Add(
+                $"Expected {rowAnchors.Count * columnCenters.Count} parsed cells but produced {parsedCells.Count}.");
+        }
+
+        var validationReport = new ImportValidationReport(
+            validationErrors.Count == 0,
+            validationErrors,
+            rowAnchors.Count,
+            parsedCells.Count);
+
+        var table = new ParsedCriticalTable(
             entry.Slug,
             entry.DisplayName,
             entry.Family,
             Path.GetFileName(entry.PdfPath),
-            "Imported from PDF text extraction.",
-            columns,
-            rollBands,
-            results);
+            "Imported from PDF XML extraction.",
+            columnCenters.Select((item, index) => new ParsedCriticalColumn(item.Key, item.Key, "severity", index + 1)).ToList(),
+            parsedRollBands,
+            parsedResults);
+
+        return new StandardCriticalTableParseResult(table, fragments, parsedCells, validationReport);
     }
 
-    private static bool IsColumnHeaderLine(string line)
+    private static List<XmlTextFragment> LoadFragments(string xmlContent)
     {
-        var matches = ColumnRegex.Matches(line);
-        return matches.Count == 5;
-    }
+        using var stringReader = new StringReader(xmlContent);
+        using var xmlReader = XmlReader.Create(
+            stringReader,
+            new XmlReaderSettings
+            {
+                DtdProcessing = DtdProcessing.Ignore
+            });
 
-    private static List<(string Label, int Start)> GetColumnStarts(string headerLine)
-    {
-        var matches = ColumnRegex.Matches(headerLine);
-        return matches
-            .Select(match => (match.Groups[1].Value.ToUpperInvariant(), match.Index))
+        var document = XDocument.Load(xmlReader);
+
+        return document.Descendants("page")
+            .SelectMany(page =>
+            {
+                var pageNumber = int.Parse(page.Attribute("number")?.Value ?? "1");
+                return page.Elements("text")
+                    .Select(item => new XmlTextFragment(
+                        pageNumber,
+                        int.Parse(item.Attribute("top")?.Value ?? throw new InvalidOperationException("Missing text top attribute.")),
+                        int.Parse(item.Attribute("left")?.Value ?? throw new InvalidOperationException("Missing text left attribute.")),
+                        int.Parse(item.Attribute("width")?.Value ?? throw new InvalidOperationException("Missing text width attribute.")),
+                        int.Parse(item.Attribute("height")?.Value ?? throw new InvalidOperationException("Missing text height attribute.")),
+                        NormalizeText(string.Concat(item.DescendantNodes().OfType<XText>().Select(node => node.Value)))))
+                    .Where(item => !string.IsNullOrWhiteSpace(item.Text));
+            })
             .ToList();
     }
 
-    private static int[] GetColumnBoundaries(IReadOnlyList<(string Label, int Start)> columns)
+    private static List<XmlTextFragment> FindHeaderFragments(IReadOnlyList<XmlTextFragment> fragments)
     {
-        var boundaries = new int[columns.Count - 1];
-        for (var index = 0; index < boundaries.Length; index++)
-        {
-            boundaries[index] = (columns[index].Start + columns[index + 1].Start) / 2;
-        }
+        var groupedByTop = fragments
+            .Where(item => item.Text.Length == 1 && char.IsLetter(item.Text[0]))
+            .GroupBy(item => item.Top)
+            .OrderBy(group => group.Key);
 
-        return boundaries;
-    }
-
-    private static int FindNextRollBandIndex(IReadOnlyList<string> lines, int startIndex)
-    {
-        for (var index = startIndex; index < lines.Count; index++)
+        foreach (var group in groupedByTop)
         {
-            if (TryParseRollBandLine(lines[index], out _, out _))
+            var ordered = group.OrderBy(item => item.Left).ToList();
+            var labels = ordered.Select(item => item.Text.ToUpperInvariant()).ToList();
+            if (labels.SequenceEqual(["A", "B", "C", "D", "E"]))
             {
-                return index;
+                return ordered;
             }
         }
 
-        return -1;
+        throw new InvalidOperationException("Could not find the standard-table A-E header row in the XML artifact.");
     }
 
-    private static bool TryParseRollBandLabel(string line, out string label)
+    private static List<XmlTextFragment> FindRowLabelFragments(
+        IReadOnlyList<XmlTextFragment> fragments,
+        IReadOnlyList<XmlTextFragment> headerFragments)
     {
-        var match = RollBandRegex.Match(line);
-        if (!match.Success)
-        {
-            label = string.Empty;
-            return false;
-        }
+        var leftCutoff = headerFragments.Min(item => item.Left) - 10;
+        var bodyStartTop = headerFragments.Max(item => item.Top) + HeaderToBodyMinimumGap;
 
-        label = match.Groups[1].Value.Replace(" ", string.Empty, StringComparison.Ordinal);
-        return true;
+        return fragments
+            .Where(item =>
+                item.Left < leftCutoff &&
+                item.Top >= bodyStartTop &&
+                IsRollBandLabel(item.Text))
+            .OrderBy(item => item.Top)
+            .ToList();
     }
 
-    private static bool TryParseRollBandLine(string line, out string label, out string trailingText)
-    {
-        var match = RollBandLineRegex.Match(line);
-        if (!match.Success)
-        {
-            label = string.Empty;
-            trailingText = string.Empty;
-            return false;
-        }
-
-        label = match.Groups["label"].Value.Replace(" ", string.Empty, StringComparison.Ordinal);
-
-        var restGroup = match.Groups["rest"];
-        trailingText = restGroup.Success
-            ? string.Concat(new string(' ', restGroup.Index), restGroup.Value.TrimEnd())
-            : string.Empty;
-
-        return true;
-    }
+    private static bool IsRollBandLabel(string value) =>
+        Regex.IsMatch(value.Trim(), @"^\d{2,3}(?:-\d{2,3})?$|^\d{2,3}\+$");
 
     private static ParsedCriticalRollBand CreateRollBand(string label, int sortOrder)
     {
@@ -217,35 +215,39 @@ public sealed class StandardCriticalTableParser
             : new ParsedCriticalRollBand(label, int.Parse(parts[0]), int.Parse(parts[1]), sortOrder);
     }
 
-    private static List<string>[] SplitRowLines(IReadOnlyList<string> rowLines, int[] boundaries, int columnCount)
+    private static string ResolveColumn(double centerX, IReadOnlyList<ColumnAnchor> columns)
     {
-        var result = Enumerable.Range(0, columnCount)
-            .Select(_ => new List<string>())
-            .ToArray();
-
-        foreach (var line in rowLines)
+        for (var index = 0; index < columns.Count - 1; index++)
         {
-            for (var columnIndex = 0; columnIndex < columnCount; columnIndex++)
+            var boundary = (columns[index].CenterX + columns[index + 1].CenterX) / 2.0;
+            if (centerX < boundary)
             {
-                var start = columnIndex == 0 ? 0 : boundaries[columnIndex - 1];
-                var end = columnIndex == columnCount - 1
-                    ? line.Length
-                    : Math.Min(boundaries[columnIndex], line.Length);
-
-                if (start >= line.Length || end <= start)
-                {
-                    continue;
-                }
-
-                var segment = line[start..end].Trim();
-                if (!string.IsNullOrWhiteSpace(segment))
-                {
-                    result[columnIndex].Add(segment);
-                }
+                return columns[index].Key;
             }
         }
 
-        return result;
+        return columns[^1].Key;
+    }
+
+    private static IReadOnlyList<string> BuildLines(IReadOnlyList<XmlTextFragment> fragments)
+    {
+        var lines = new List<List<XmlTextFragment>>();
+
+        foreach (var fragment in fragments.OrderBy(item => item.Top).ThenBy(item => item.Left))
+        {
+            if (lines.Count == 0 || Math.Abs(lines[^1][0].Top - fragment.Top) > TopGroupingTolerance)
+            {
+                lines.Add([fragment]);
+                continue;
+            }
+
+            lines[^1].Add(fragment);
+        }
+
+        return lines
+            .Select(line => CollapseWhitespace(string.Join(' ', line.OrderBy(item => item.Left).Select(item => item.Text))))
+            .Where(item => !string.IsNullOrWhiteSpace(item))
+            .ToList();
     }
 
     private static bool IsAffixLikeLine(string line)
@@ -256,7 +258,7 @@ public sealed class StandardCriticalTableParser
             return false;
         }
 
-        if (value == "—")
+        if (value == "-" || value == "\u2014")
         {
             return true;
         }
@@ -270,16 +272,27 @@ public sealed class StandardCriticalTableParser
         }
 
         return value.StartsWith("+", StringComparison.Ordinal) ||
-               value.StartsWith('∑') ||
-               value.StartsWith('∏') ||
-               value.StartsWith('π') ||
-               value.StartsWith('∫') ||
+               value.StartsWith("\u2211", StringComparison.Ordinal) ||
+               value.StartsWith("\u220F", StringComparison.Ordinal) ||
+               value.StartsWith("\u03C0", StringComparison.Ordinal) ||
+               value.StartsWith("\u222B", StringComparison.Ordinal) ||
                char.IsDigit(value[0]) ||
-               value.Contains(" – ", StringComparison.Ordinal) ||
+               value.Contains(" - ", StringComparison.Ordinal) ||
                value.Contains("(-", StringComparison.Ordinal) ||
                value.Contains("(+", StringComparison.Ordinal);
     }
 
     private static string CollapseWhitespace(string value) =>
         Regex.Replace(value.Trim(), @"\s+", " ");
+
+    private static string NormalizeText(string value) =>
+        value
+            .Replace('\u00a0', ' ')
+            .Replace('\r', ' ')
+            .Replace('\n', ' ')
+            .Trim();
+
+    private sealed record ColumnAnchor(string Key, double CenterX);
+
+    private sealed record RowAnchor(string Label, int Top, int SortOrder);
 }
diff --git a/src/RolemasterDb.ImportTool/Parsing/XmlTextFragment.cs b/src/RolemasterDb.ImportTool/Parsing/XmlTextFragment.cs
new file mode 100644
index 0000000..e3d771a
--- /dev/null
+++ b/src/RolemasterDb.ImportTool/Parsing/XmlTextFragment.cs
@@ -0,0 +1,18 @@
+namespace RolemasterDb.ImportTool.Parsing;
+
+public sealed class XmlTextFragment(
+    int pageNumber,
+    int top,
+    int left,
+    int width,
+    int height,
+    string text)
+{
+    public int PageNumber { get; } = pageNumber;
+    public int Top { get; } = top;
+    public int Left { get; } = left;
+    public int Width { get; } = width;
+    public int Height { get; } = height;
+    public string Text { get; } = text;
+    public double CenterX => Left + (Width / 2.0);
+}
diff --git a/src/RolemasterDb.ImportTool/PdfTextExtractor.cs b/src/RolemasterDb.ImportTool/PdfXmlExtractor.cs
similarity index 77%
rename from src/RolemasterDb.ImportTool/PdfTextExtractor.cs
rename to src/RolemasterDb.ImportTool/PdfXmlExtractor.cs
index 0485479..0bd0198 100644
--- a/src/RolemasterDb.ImportTool/PdfTextExtractor.cs
+++ b/src/RolemasterDb.ImportTool/PdfXmlExtractor.cs
@@ -2,7 +2,7 @@ using System.Diagnostics;
 
 namespace RolemasterDb.ImportTool;
 
-public sealed class PdfTextExtractor
+public sealed class PdfXmlExtractor
 {
     public async Task ExtractAsync(string pdfPath, string outputPath, CancellationToken cancellationToken = default)
     {
@@ -10,14 +10,16 @@ public sealed class PdfTextExtractor
 
         var startInfo = new ProcessStartInfo
         {
-            FileName = "pdftotext",
+            FileName = "pdftohtml",
             RedirectStandardError = true,
             RedirectStandardOutput = true,
             UseShellExecute = false,
             CreateNoWindow = true
         };
 
-        startInfo.ArgumentList.Add("-layout");
+        startInfo.ArgumentList.Add("-xml");
+        startInfo.ArgumentList.Add("-i");
+        startInfo.ArgumentList.Add("-noframes");
         startInfo.ArgumentList.Add(pdfPath);
         startInfo.ArgumentList.Add(outputPath);
 
@@ -28,7 +30,7 @@ public sealed class PdfTextExtractor
         if (process.ExitCode != 0)
         {
             var error = await process.StandardError.ReadToEndAsync(cancellationToken);
-            throw new InvalidOperationException($"pdftotext failed for '{pdfPath}': {error}");
+            throw new InvalidOperationException($"pdftohtml failed for '{pdfPath}': {error}");
         }
     }
 }