fix(core): count sectioned outputs as outputs (#257)

CompiledReport.OutputCount returned Outputs.Count, excluding SectionedOutputs,
and OutputFormats listed only the plain outputs' formats. Both collections
produce a delivered artifact, so a report with one plain and one sectioned output
looked single-output.

The API's sync mode supports single-output reports only and guards on
OutputCount, so it accepted such a report; the runner then wrote both files and
the endpoint streamed artifacts[0] — the caller silently received one of the two,
and which one depended on directory-enumeration order. GET /reports under-reported
the same report's formats.

Count and list both kinds, so the guard rejects what its own message says it
rejects. Covered by a test verified to fail against the old accessor.

Author: thiagoluga

CHANGELOG.md

@@ -58,6 +58,11 @@ The `NeoReports.Abstractions` contract follows SemVer strictly.
   the host — D20 — this is a nudge, not a behaviour change).
 
 ### Fixed
+- **Sectioned outputs are counted as outputs.** `CompiledReport.OutputCount` (and `OutputFormats`)
+  omitted them, so a report with one plain and one sectioned output looked single-output: the API's
+  sync mode — which supports single-output reports only — accepted it, the runner wrote both files,
+  and the caller silently received whichever one directory enumeration yielded first. `GET /reports`
+  under-reported such a report's formats for the same reason.
 - **Google Sheets no longer drops a column whose header cell isn't text.** Requests ask for
   `UNFORMATTED_VALUE`, so a year-numbered header (`2024`) or a `TRUE`/`FALSE` one arrives as a JSON
   number/boolean; the header index accepted strings only, while the data path decodes every kind. The

docs/STATUS-AND-BACKLOG.md

@@ -258,7 +258,9 @@ rather than decided:
   error strings). The read- and write-failure paths in the same method scrub; the **upload** path does
   not — and the sync endpoint deliberately suppresses the very same string, so one route hides what
   the other returns verbatim.
-- **API: sync mode's single-output guard ignores sectioned outputs.** `OutputCount` counts only
+- ~~**API: sync mode's single-output guard ignores sectioned outputs.**~~ **FIXED** — `OutputCount`
+  and `OutputFormats` now include sectioned outputs, so the guard rejects the mixed report it always
+  claimed to and the listing reports every format. Original description: `OutputCount` counts only
   `Outputs`, so a report with one plain and one sectioned output passes the guard, the runner writes
   two artifacts, and the caller silently receives **one** — which one decided by directory-enumeration
   order. The same undercount makes `GET /reports` under-report a sectioned report's formats.

src/NeoReports.Core/CompiledReport.cs

@@ -50,7 +50,13 @@ internal CompiledReport(
         RowCountFactory = countRows;
         Deadline = deadline;
 
-        OutputFormats = outputs.Select(o => o.Factory.Format).ToArray();
+        // Both collections produce a delivered artifact, so both belong in the count and the format
+        // list. Counting only Outputs made a report with one plain and one sectioned output look
+        // single-output: the API's sync guard let it through, the runner then wrote two files, and the
+        // caller silently received whichever one directory enumeration happened to yield first.
+        OutputFormats = outputs.Select(o => o.Factory.Format)
+            .Concat(sectionedOutputs.Select(s => s.Spec.Factory.Format))
+            .ToArray();
         DestinationTypes = destinations.Select(d => d.Factory.Type).ToArray();
     }
 
@@ -64,7 +70,7 @@ internal CompiledReport(
     public int PageSize { get; }
 
     /// <summary>Number of configured outputs (formats).</summary>
-    public int OutputCount => Outputs.Count;
+    public int OutputCount => Outputs.Count + SectionedOutputs.Count;
 
     /// <summary>Format id of each configured output, in order (e.g. "csv", "xlsx").</summary>
     public IReadOnlyList<string> OutputFormats { get; }

tests/NeoReports.Core.UnitTests/MultiViewTests.cs

@@ -97,6 +97,26 @@ public void A_view_without_columns_and_no_report_columns_is_rejected()
         Should.Throw<ConfigurationException>(act).Message.ShouldContain("no columns");
     }
 
+    [Fact]
+    public void Sectioned_outputs_are_counted_and_listed_alongside_plain_ones()
+    {
+        // Both kinds produce a delivered artifact. Counting only the plain ones made a report like
+        // this one look single-output, so the API's sync guard — which promises "single-output reports
+        // only" — let it through; the runner then wrote two files and the caller silently received
+        // whichever one directory enumeration yielded first.
+        var report = new ReportBuilder<Sale>("mixed")
+            .From(new FakeBatchSource<Sale>(new[] { Page(1) }))
+            .Column(v => v.Id, "Id")
+            .To(new OutputSpec(new FakeWriterFactory()))
+            .ToSections(new SectionedOutputSpec(new FakeSectionedWriterFactory()), s => s
+                .Section("All", v => v.Where(x => x.Id > 0)))
+            .Build();
+
+        report.OutputCount.ShouldBe(2);
+        report.OutputFormats.ShouldContain("fake");
+        report.OutputFormats.Count.ShouldBe(2);
+    }
+
     [Fact]
     public async Task Sectioned_output_projects_each_section_from_a_single_read()
     {