Skip to content

[DocumentExtraction] DI/CU abort on overlapping table cells, and the README quick starts drop up to half the text #95

Open

Description

@luisquintanilla

I found two independent problems while validating dotnet/extensions#7962. Both reproduce on the published packages (CommunityToolkit.DocumentExtraction.* 1.0.0-preview on Microsoft.Extensions.Documents.Abstractions 11.0.0-preview.1.26560.3), and neither depends on dotnet/extensions#7962. Part 3 is follow-up work for after that change ships.

TL;DR

# Problem Impact Fix size
1 The Azure DI and CU adapters throw when the service reports a cell inside another cell's span The whole document fails (InvalidOperationException) ~70 lines in a shared helper plus 2 call sites, and 3 shared regression tests (prototype below: 650/650 tests pass)
2 Provider READMEs and the root README teach traversal loops that skip table cells, nested sections and/or image.Text On hard pages, readers see 48–50 % (CU/DI) of the text the document actually contains Docs only
3 After dotnet/extensions#7962 ships: adopt GetText() / EnumerateContent() and drop dead cell is null checks Simpler docs, a single supported reading path Docs plus a version bump

1. Bug: overlapping cell spans abort the whole document (Document Intelligence and Content Understanding)

Repro

var client = new DocumentIntelligenceClient(endpoint, new DefaultAzureCredential())
    .AsDocumentExtractionClient(new() { DefaultModel = "prebuilt-layout" });
await using var pdf = File.OpenRead("complex_header_006.pdf");
var document = await client.ExtractAsync(pdf, "complex_header_006.pdf", "application/pdf");
  • Actual:
System.InvalidOperationException: A covered position must be edited through its anchor cell.
   at Microsoft.Extensions.Documents.ExtractionDocumentTableCellCollection.set_Item(Int32 row, Int32 column, ...)
   at CommunityToolkit.DocumentExtraction.AzureDocumentIntelligence.DocumentIntelligenceExtractionClient.MapTables(...)
  • Expected: the document extracts. The offending cells carry no text.

Root cause

Raw prebuilt-layout output (Azure.AI.DocumentIntelligence 1.0.0) for table 1 on that page (28 × 11, 289 cells):

cell kind anchor span content
cells[5] columnHeader [0,5] 3 × 6 header text
cells[9] columnHeader [2,5] 1 × 1 (empty)
cells[10] columnHeader [2,7] 1 × 1 (empty)
cells[11] columnHeader [2,8] 1 × 1 (empty)
cells[12] columnHeader [2,9] 1 × 1 (empty)
cells[13] columnHeader [2,10] 1 × 1 (empty)

cells[9..13] all lie inside the 3 × 6 span anchored at [0,5].

Both Azure adapters assign every provider cell blindly:

  • src/AzureDocumentIntelligence/DocumentIntelligenceExtractionClient.cs:222
  • src/AzureContentUnderstanding/ContentUnderstandingExtractionClient.cs:247
mappedTable.Cells[cell.RowIndex, cell.ColumnIndex] = mappedCell;

ExtractionDocumentTableCellCollection's setter rejects a covered position ("A covered position must be edited through its anchor cell."). It also rejects a span that overlaps an existing anchor ("Cell spans cannot overlap another cell."). Either exception propagates out of ExtractAsync, so one malformed header row loses the entire document.

Precedent: the VLM adapter already validates occupancy up front with a HashSet<(int,int)> and throws a descriptive InvalidDataException (src/VisionLanguageModel/VisionLanguageModelDocumentExtractionClient.cs:273-296). The Azure adapters have no equivalent.

Proposed fix

A fix is ready as a single commit (+148/−6; see Patch at the end). It needs nothing beyond the published abstractions package. I'm happy to open it as a PR.

  1. src/Shared/ProviderAdapterHelpers.cs: add ReserveTableCell(bool[,] occupied, row, column, rowSpan, columnSpan, isEmpty, context). It returns the span to map, or null to skip the cell. The policy:

    Situation Action Lossless?
    The cell's rectangle is free Map as reported and mark it occupied yes
    The rectangle overlaps an occupied position and the cell has no text or elements Skip (the observed DI case) yes
    The rectangle overlaps, the cell has content, and its own [row,col] is free Map as 1 × 1 (keeps the text, drops the conflicting span) text yes, span no
    The cell has content and its own [row,col] is covered InvalidDataException("<provider> table N: cell at row r, column c has content but lies inside another cell's span.") n/a (same as VLM)
    Address out of range Unchanged: the table setter still throws ArgumentOutOfRangeException (the existing bad-cell contract test) n/a
  2. Call sites: allocate var occupied = new bool[table.RowCount, table.ColumnCount]; per table, then:

if (ProviderAdapterHelpers.ReserveTableCell(
        occupied, cell.RowIndex, cell.ColumnIndex, cell.RowSpan ?? 1, cell.ColumnSpan ?? 1,
        cell.Elements.Count == 0 && string.IsNullOrWhiteSpace(cell.Content),
        $"Document Intelligence table {index}") is not { } span)
{
    continue;
}
// ...construct the cell with span.RowSpan / span.ColumnSpan instead of cell.RowSpan ?? 1 / cell.ColumnSpan ?? 1
  1. Second passes: MapSections reads table.Cells[cell.RowIndex, cell.ColumnIndex]! for cells with Elements (DI :295, CU :301). These need no change: a cell with elements is never "empty", so it is either mapped at its own anchor or the helper throws.

Maintainer decision: what should happen to a non-empty cell inside another span? The prototype throws, matching VLM. Alternatives: append its text to the covering anchor (which means rebuilding that anchor, because Content is get-only), or skip it with a diagnostic. No real document in the 10-page sample hit this case. Only empty overlaps were observed.

Tests

The tests live in the shared partial class test/AzureTestSupport/AzureMappingRegressionTests.cs, which is compiled into both the DI and CU test projects via CONTENT_UNDERSTANDING. The new theory is ExtractAsync_OverlappingCellSpans_DoNotAbortDocument, which adds cells to AzureWireFixture.Create()'s 2 × 3 table (which has a 2 × 2 header anchored at [0,0]):

Scenario Added cells Assertion
empty-covered empty 1 × 1 at [1,1] succeeds; [0,0] is still 2 × 2 with "Total amount"; Cells[1,1] is null
text-span-overlap "Tax" at [1,2], then "Notes" at [0,2] with rowSpan 2 succeeds; "Notes" is 1 × 1 at [0,2]; "Tax" is kept at [1,2]
text-covered "Tax" at [1,1] InvalidDataException whose message contains row 1, column 1

Validation

Check Result
New tests on current main (74935f4), fix stashed 6/6 fail with the reported InvalidOperationException (3 DI + 3 CU)
Full DocumentExtraction suite with fix, published abstractions 11.0.0-preview.1.26560.3 650/650 pass (644 existing + 6 new)
Same suite against a dotnet/extensions#7962 prototype package 650/650 pass
Live prebuilt-layout on complex_header_006 with the patched adapters DI: OK (was: throws). Table 1 maps 284 anchors: 289 provider cells minus exactly the 5 empty covered cells, with 6 merged cells kept. CU: OK (unchanged).

Acceptance criteria

  • DI and CU never throw InvalidOperationException from ExtractionDocumentTableCellCollection while mapping service output.
  • Empty cells inside another span are dropped without losing any text.
  • Non-empty overlaps follow the documented policy, and any exception names the provider, table index, row and column.
  • Shared regression tests cover both adapters.
  • ParseBench-2/complex_header_006 extracts with DI prebuilt-layout.

2. Docs: the quick starts teach loops that silently skip content

ExtractionDocument is a tree: sections → elements → (nested sections | tables → cells → elements | images with OCR'd Text). DI and CU produce nested trees: every one of the 10 sampled pages for CU, and 8 of 9 for DI, had depth > 1. PdfPig, Mistral and plain VLM output is flat. A loop that works on PdfPig therefore silently loses text on Azure. See dotnet/extensions#7962.

Measured impact

These are live runs: ParseBench-2, 10 hard PDF pages (charts, complex headers, dense and financial tables, multi-column layouts). Recall is the fraction of ground-truth tokens a reader sees.

Reading pattern Used in CU DI PdfPig / Mistral / Ollama
EnumerateContent().OfType<ExtractionDocumentTextElement>() DI/CU/PdfPig/VLM READMEs 0.48 0.50 0.81 / 0.76 / 0.83
Recursive walker with cells and nested sections but no image.Text root README PrintElement 0.84 0.77 same
Recursive walker with cells, nested sections and image.Text proposed 0.92 0.85 same

DI covered 9 of 10 pages because of problem 1 above.

Where

At 74935f4:

File Line Pattern What's skipped
DocumentExtraction/README.md 163–165 EnumerateContent() + element.Content is TextContent table cells, image.Text (≈ B on Azure)
DocumentExtraction/README.md 278–315 (PrintElement) recursive, reads cells and sections image.Text; if (cell is null) continue; at :305 hides the covered/anchor distinction
src/AzureDocumentIntelligence/README.md 74 EnumerateContent().OfType<ExtractionDocumentTextElement>() table cells, image.Text
src/AzureContentUnderstanding/README.md 81 same same
src/PdfPig/README.md 61, 78 same (flat today, so harmless, but it's the pattern people copy)
src/VisionLanguageModel/README.md 77 same table cells
src/Mistral/README.md 89, 166 EnumerateContent() + Content is TextContent table cells

The prose already warns about this (DI README :158, CU README :152, and the SKILL.md files for CU :81, DI :83, VLM :100 and PdfPig :68 all say "EnumerateContent() does not enter table cells"), but the code right above it doesn't follow the warning.

Proposed fix (works today, no new APIs)

Replace each quick-start loop with one shared, copy-pasteable helper. Put it in the root README and link to it from the provider READMEs:

static IEnumerable<string> ReadText(ExtractionDocumentElement element)
{
    switch (element)
    {
        case ExtractionDocumentTextElement { Content: TextContent text }:
            yield return text.Text;
            break;
        case ExtractionDocumentImageElement image when !string.IsNullOrWhiteSpace(image.Text):
            yield return image.Text;               // OCR'd text inside figures (DI/CU)
            break;
        case ExtractionDocumentTableElement table:
            for (int r = 0; r < table.Cells.RowCount; r++)
                for (int c = 0; c < table.Cells.ColumnCount; c++)
                    if (table.Cells[r, c]?.Content is { } cell)   // null = empty or covered by a merged cell
                        foreach (string s in ReadText(cell)) yield return s;
            break;
        case ExtractionDocumentSection section:
            foreach (var child in section.Elements)
                foreach (string s in ReadText(child)) yield return s;
            break;
    }
}

foreach (var section in document.Sections)
    foreach (var element in section.Elements)
        foreach (string text in ReadText(element))
            Console.WriteLine(text);

The samples repo walker received the same fix in luisquintanilla/dotnet-document-extraction-samples#1. Its recall moved from 0.84/0.77 (CU/DI) to match the whole-document reference (0.92/0.85 in the latest run).

Acceptance criteria

  • No README or SKILL.md shows a loop that filters to ExtractionDocumentTextElement without also descending into cells and reading image.Text.
  • The root README's PrintElement reads image.Text.
  • Provider READMEs keep their existing "does not enter table cells" prose only where it is still accurate, and point to the helper.

3. Follow-up after dotnet/extensions#7962 ships (December)

dotnet/extensions#7962 adds GetText() for document, element and cell, and makes ExtractionDocumentTableCellCollection enumerate anchor cells only. Once CTK takes that package:

  • Replace the helper from part 2 with document.GetText(), or with document.EnumerateContent() + element.GetText() for per-element reading.
  • Delete if (cell is null) continue; (root README :305) and similar null checks when iterating table.Cells, since enumeration no longer yields empty positions.
  • Optionally switch the problem 1 helper to table.Cells.GetCoveringCell(r, c) instead of a local bool[,]. Keep the current behavior.
  • Update the SKILL.md wording (CU :81, DI :83, VLM :100, PdfPig :68) to "use GetText() for complete text, or EnumerateContent() for structure".

Compatibility: the full CTK DocumentExtraction suite passes unchanged against the dotnet/extensions#7962 prototype package (644/644 before the problem 1 fix, 650/650 with it). No source changes are needed to adopt it.


Environment

  • CommunityToolkit/AI main @ 74935f4.
  • Azure.AI.DocumentIntelligence 1.0.0 (prebuilt-layout) and Azure.AI.ContentUnderstanding (prebuilt-layout analyzer), both live.
  • ParseBench-2: 10 pages across charts, complex_table_headers, dense_tables, financial_tables and multi-column categories.
  • Harness, pinned corpus and per-page results: validation/parsebench in the samples repo. The overlap failure is recorded in its results/summary.md.
Patch (git am, applies to main @ 74935f4)
From 93c3d2955c98c5e160ca44fe7166dda3ee506c5d Mon Sep 17 00:00:00 2001
From: Luis Quintanilla <luisquintanilla@users.noreply.github.com>
Date: Thu, 19 Nov 2026 12:52:48 -0500
Subject: [PATCH] Don't abort extraction when DI/CU report overlapping table
 cells

Document Intelligence and Content Understanding can report empty 1x1 cells inside another cell's span (e.g. ParseBench-2 complex_header_006). Assigning them through ExtractionDocumentTableCellCollection throws, aborting the whole document. Track occupied positions while mapping: skip empty covered cells, keep text from a cell whose span overlaps as a 1x1 cell, and raise a descriptive InvalidDataException only when a non-empty cell's own position is covered.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---
 .../ContentUnderstandingExtractionClient.cs   | 13 +++-
 .../DocumentIntelligenceExtractionClient.cs   | 15 +++--
 .../src/Shared/ProviderAdapterHelpers.cs      | 66 +++++++++++++++++++
 .../AzureMappingRegressionTests.cs            | 60 +++++++++++++++++
 4 files changed, 148 insertions(+), 6 deletions(-)

diff --git a/DocumentExtraction/src/AzureContentUnderstanding/ContentUnderstandingExtractionClient.cs b/DocumentExtraction/src/AzureContentUnderstanding/ContentUnderstandingExtractionClient.cs
index 475ea63..c6e8854 100644
--- a/DocumentExtraction/src/AzureContentUnderstanding/ContentUnderstandingExtractionClient.cs
+++ b/DocumentExtraction/src/AzureContentUnderstanding/ContentUnderstandingExtractionClient.cs
@@ -223,8 +223,17 @@ private static void MapTables(
             IReadOnlyList<ExtractionDocumentSourceReference> tableSources = ParseSources(table.Source, frames, table);
             var mappedTable = new ExtractionDocumentTableElement(null, table.RowCount, table.ColumnCount);
             elements.Add($"/tables/{index}", mappedTable);
+            var occupied = new bool[table.RowCount, table.ColumnCount];
             foreach (Azure.AI.ContentUnderstanding.DocumentTableCell cell in table.Cells)
             {
+                if (ProviderAdapterHelpers.ReserveTableCell(
+                    occupied, cell.RowIndex, cell.ColumnIndex, cell.RowSpan ?? 1, cell.ColumnSpan ?? 1,
+                    cell.Elements.Count == 0 && string.IsNullOrWhiteSpace(cell.Content),
+                    $"Content Understanding table {index}") is not { } span)
+                {
+                    continue;
+                }
+
                 IReadOnlyList<ExtractionDocumentSourceReference> cellSources = ParseSources(cell.Source, frames, cell);
                 ExtractionDocumentElement? cellContent = cell.Elements.Count > 0
                     ? new ExtractionDocumentSection()
@@ -236,9 +245,9 @@ private static void MapTables(
 
                 var mappedCell = cellContent is null
                     ? new Microsoft.Extensions.Documents.ExtractionDocumentTableCell(
-                        cell.RowSpan ?? 1, cell.ColumnSpan ?? 1, cell.Kind?.ToString())
+                        span.RowSpan, span.ColumnSpan, cell.Kind?.ToString())
                     : new Microsoft.Extensions.Documents.ExtractionDocumentTableCell(
-                        cellContent, cell.RowSpan ?? 1, cell.ColumnSpan ?? 1, cell.Kind?.ToString());
+                        cellContent, span.RowSpan, span.ColumnSpan, cell.Kind?.ToString());
                 foreach (ExtractionDocumentSourceReference source in cellSources)
                 {
                     mappedCell.Sources.Add(source);
diff --git a/DocumentExtraction/src/AzureDocumentIntelligence/DocumentIntelligenceExtractionClient.cs b/DocumentExtraction/src/AzureDocumentIntelligence/DocumentIntelligenceExtractionClient.cs
index f3a7658..e56ffd2 100644
--- a/DocumentExtraction/src/AzureDocumentIntelligence/DocumentIntelligenceExtractionClient.cs
+++ b/DocumentExtraction/src/AzureDocumentIntelligence/DocumentIntelligenceExtractionClient.cs
@@ -188,8 +188,17 @@ private static void MapTables(
 
             var mappedTable = new ExtractionDocumentTableElement(null, table.RowCount, table.ColumnCount);
             elements.Add($"/tables/{index}", mappedTable);
+            var occupied = new bool[table.RowCount, table.ColumnCount];
             foreach (Azure.AI.DocumentIntelligence.DocumentTableCell cell in table.Cells)
             {
+                if (ProviderAdapterHelpers.ReserveTableCell(
+                    occupied, cell.RowIndex, cell.ColumnIndex, cell.RowSpan ?? 1, cell.ColumnSpan ?? 1,
+                    cell.Elements.Count == 0 && string.IsNullOrWhiteSpace(cell.Content),
+                    $"Document Intelligence table {index}") is not { } span)
+                {
+                    continue;
+                }
+
                 ExtractionDocumentSourceReference[] cellSources = cell.BoundingRegions
                     .Select(region => ProviderAdapterHelpers.CreateSource(
                         frames[region.PageNumber].SourcePage,
@@ -210,10 +219,8 @@ private static void MapTables(
                 }
 
                 var mappedCell = content is null
-                    ? new Microsoft.Extensions.Documents.ExtractionDocumentTableCell(
-                        cell.RowSpan ?? 1, cell.ColumnSpan ?? 1, kind)
-                    : new Microsoft.Extensions.Documents.ExtractionDocumentTableCell(
-                        content, cell.RowSpan ?? 1, cell.ColumnSpan ?? 1, kind);
+                    ? new Microsoft.Extensions.Documents.ExtractionDocumentTableCell(span.RowSpan, span.ColumnSpan, kind)
+                    : new Microsoft.Extensions.Documents.ExtractionDocumentTableCell(content, span.RowSpan, span.ColumnSpan, kind);
                 foreach (ExtractionDocumentSourceReference source in cellSources)
                 {
                     mappedCell.Sources.Add(source);
diff --git a/DocumentExtraction/src/Shared/ProviderAdapterHelpers.cs b/DocumentExtraction/src/Shared/ProviderAdapterHelpers.cs
index dd42af9..c3b0e8c 100644
--- a/DocumentExtraction/src/Shared/ProviderAdapterHelpers.cs
+++ b/DocumentExtraction/src/Shared/ProviderAdapterHelpers.cs
@@ -145,6 +145,72 @@ public static ExtractionDocumentSourceReference CreateSource(
             (points ?? []).Select(point => new ExtractionDocumentPoint(point.X, point.Y)).ToArray(),
             nativeRepresentation);
 
+    /// <summary>
+    /// Reserves the grid positions of a provider table cell so that overlapping provider cells cannot abort the document.
+    /// </summary>
+    /// <returns>
+    /// The span to map the cell with, or <see langword="null"/> when the cell is empty and lies inside another cell's span.
+    /// A non-empty cell whose own position is free keeps its text as a 1x1 cell when its span would overlap.
+    /// </returns>
+    public static (int RowSpan, int ColumnSpan)? ReserveTableCell(
+        bool[,] occupied, int row, int column, int rowSpan, int columnSpan, bool isEmpty, string context)
+    {
+        int rows = occupied.GetLength(0);
+        int columns = occupied.GetLength(1);
+        if (row < 0 || column < 0 || row >= rows || column >= columns)
+        {
+            // Let the table reject the address with its existing exception.
+            return (rowSpan, columnSpan);
+        }
+
+        if (!Overlaps(rowSpan, columnSpan))
+        {
+            Mark(rowSpan, columnSpan);
+            return (rowSpan, columnSpan);
+        }
+
+        if (isEmpty)
+        {
+            return null;
+        }
+
+        if (!occupied[row, column])
+        {
+            Mark(1, 1);
+            return (1, 1);
+        }
+
+        throw new InvalidDataException(
+            $"{context}: cell at row {row}, column {column} has content but lies inside another cell's span.");
+
+        bool Overlaps(int rs, int cs)
+        {
+            for (int r = row; r < Math.Min(rows, row + rs); r++)
+            {
+                for (int c = column; c < Math.Min(columns, column + cs); c++)
+                {
+                    if (occupied[r, c])
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        void Mark(int rs, int cs)
+        {
+            for (int r = row; r < Math.Min(rows, row + rs); r++)
+            {
+                for (int c = column; c < Math.Min(columns, column + cs); c++)
+                {
+                    occupied[r, c] = true;
+                }
+            }
+        }
+    }
+
     public static string? NormalizeTextRole(string? role)
         => role?.ToLowerInvariant() switch
         {
diff --git a/DocumentExtraction/test/AzureTestSupport/AzureMappingRegressionTests.cs b/DocumentExtraction/test/AzureTestSupport/AzureMappingRegressionTests.cs
index f2cb6be..3c24b94 100644
--- a/DocumentExtraction/test/AzureTestSupport/AzureMappingRegressionTests.cs
+++ b/DocumentExtraction/test/AzureTestSupport/AzureMappingRegressionTests.cs
@@ -395,6 +395,66 @@ public async Task ExtractAsync_MultipleContents_DoNotCompareIndependentOffsets()
     }
 #endif
 
+    [Theory]
+    [InlineData("empty-covered")]
+    [InlineData("text-span-overlap")]
+    [InlineData("text-covered")]
+    public async Task ExtractAsync_OverlappingCellSpans_DoNotAbortDocument(string scenario)
+    {
+        var root = AzureWireFixture.Create();
+        var cells = AzureWireFixture.Content(root)["tables"]![0]!["cells"]!.AsArray();
+        JsonNode Cell(int row, int column, int rowSpan, string text)
+        {
+            var cell = cells[0]!.DeepClone();
+            cell["rowIndex"] = row;
+            cell["columnIndex"] = column;
+            cell["rowSpan"] = rowSpan;
+            cell["columnSpan"] = 1;
+            cell["kind"] = "content";
+            cell["content"] = text;
+            return cell;
+        }
+
+        switch (scenario)
+        {
+            case "empty-covered":
+                // Document Intelligence reports empty 1x1 cells inside another header's span (ParseBench-2 complex_header_006).
+                cells.Add(Cell(1, 1, 1, ""));
+                break;
+            case "text-span-overlap":
+                cells.Add(Cell(1, 2, 1, "Tax"));
+                cells.Add(Cell(0, 2, 2, "Notes"));
+                break;
+            case "text-covered":
+                cells.Add(Cell(1, 1, 1, "Tax"));
+                break;
+        }
+
+        var transport = Replay(AzureWireFixture.Bytes(root));
+        using var client = Create(transport);
+        using var input = new MemoryStream([1, 2, 3]);
+        if (scenario == "text-covered")
+        {
+            var error = await Assert.ThrowsAsync<InvalidDataException>(() => Extract(client, input));
+            Assert.Contains("row 1, column 1", error.Message, StringComparison.Ordinal);
+            return;
+        }
+
+        var result = await Extract(client, input);
+        var table = Assert.Single(result.EnumerateContent().OfType<ExtractionDocumentTableElement>());
+        var header = Assert.IsType<ExtractionDocumentTableCell>(table.Cells[0, 0]);
+        Assert.Equal((2, 2), (header.RowSpan, header.ColumnSpan));
+        Assert.Equal("Total amount", Text(Assert.IsType<ExtractionDocumentTextElement>(header.Content)));
+        Assert.Null(table.Cells[1, 1]);
+        if (scenario == "text-span-overlap")
+        {
+            var notes = Assert.IsType<ExtractionDocumentTableCell>(table.Cells[0, 2]);
+            Assert.Equal((1, 1), (notes.RowSpan, notes.ColumnSpan));
+            Assert.Equal("Notes", Text(Assert.IsType<ExtractionDocumentTextElement>(notes.Content)));
+            Assert.Equal("Tax", Text(Assert.IsType<ExtractionDocumentTextElement>(table.Cells[1, 2]!.Content)));
+        }
+    }
+
     private static JsonObject FigureFixture()
     {
         var root = AzureWireFixture.Create();
-- 
2.56.1.windows.1

Activity

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    bugSomething isn't workingdocumentationImprovements or additions to documentation

    Type

    No type

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions