The port: ParsedResult model, LegacyResultReader, and the renderer migration (#391, Tasks 3–5b) - #443

…t typing (#391, Tasks 8–10) (#447)

* test: pin extension-based attachment typing and map public.data on the legacy backend

Task 10 of the migration plan. The AttachmentType(filenameExtension:)
initializer itself landed with #443; what was missing is the cross-backend
agreement pin and one table entry: LegacyResultReader's UTI fallback omitted
public.data, so an extensionless public.data attachment degraded
.data -> .unknown on the legacy backend only.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* fix: surface XCResultToolError diagnoses through LocalizedError

Carried forward from the #441 review: consumers now exist (faults and
warnings format these errors), and localizedDescription printed the generic
NSError boilerplate rather than the command, exit status, and stderr.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* feat: export attachments through the modern xcresulttool path

Task 9 of the migration plan. One `export attachments` call per bundle plus
the manifest.json join (activity attachment uuid <-> basename of
exportedFileName) replaces the legacy per-payload export and its lock table;
only the one-shot export is guarded. Run logs come from `get log --type
action` and render from the structured messages, since the new format has
no emittedOutput.

Committed ahead of Task 8 so each commit builds: the reader's payloadStore
property references this type.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* feat: add ModernResultReader for the new xcresulttool format

Task 8 of the migration plan. Parity rules carried exactly: statuses map
into the neutral enum (Expected Failure still flattens to unknown
downstream); multi-repetition status derives from the Repetition children
and ignores the parent Test Case's own result (RetryResults reports Passed
there for a Failed-then-Passed test); the tree renders flat, without the
legacy wrapper groups.

Failure text joins the two documents rather than choosing one: measured on
Xcode 26.2, every assertion failure appears both as a failure-flagged
activity row (positioned and timestamped, but stripped of file:line) and as
a Failure Message node (file:line kept, no timestamp). Each message retitles
the first unclaimed failure activity whose title is its exact suffix, in
document order, nested rows included; unmatched messages (skip reasons,
expected-failure notes) append. The plan's original guard kept the activity
title instead, which shipped strictly less information than the spec's
failureTitlePrefix entry documents — coordinator-approved correction,
amended in the plan.

A failed activities query records the new .missingActivities fault; fields
the format structurally lacks never fault, pinned by a full modern-path
render of all three fixtures asserting zero faults.

The sample app gains a parameterized @test so Arguments nodes stop being
fixture-unexercised; its argument sets merge into one rendered row, moving
the TestResults header total from 17 to 18.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* docs: amend plan and spec for Tasks 8-10 as executed

The load-bearing correction: failure text is a join of the two documents,
not a choice between them. Measured on Xcode 26.2, the activities document
carries every assertion failure as a positioned, timestamped, sometimes
nested failure row missing only the file:line prefix; the plan's original
anti-double-count guard would have dropped the prefixed Failure Message and
shipped less than the spec's failureTitlePrefix entry documents.
Coordinator-approved retitle-join recorded in both documents.

Mechanical notes: Task 9 commits before Task 8 (type dependency), TestRun is
nested in TestActivities, the AttachmentType initializer shipped failable in
443, and regenerating fixtures after the sample-app change collapses the
plan's 6-of-7 intermediate state.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

…elease notes (#391, Tasks 14–15) (#451)

* feat!: emit our own schema from --json instead of the legacy object graph

BREAKING: --json previously dumped xcresulttool's legacy object graph verbatim.
That graph is Apple's internal shape and disappears with the legacy commands,
so --json now emits a documented schema, identical on both backends.

docs/json-schema.md is the contract, written before the encoder: field names
and nesting with a complete worked example, enum spellings, one uniform null
rule, duration and timestamp formats, ordering guarantees, and a semver
schemaVersion policy. The encoder (JsonReport.swift) is an explicit layer
rather than a synthesized Encodable on the internal model, so renaming a
Parsed* property breaks compilation instead of silently renaming public
output. ResultFile.exportJson() — the last exportRecursiveJson() call, kept
since Task 5a — is deleted; XCResultKit is confined to ResultReading/Legacy/.

JsonReportTests holds the output to the contract across both backends:
recursive schema identity, values deeply equal outside the two permitted
difference classes (JsonClassMask masks exactly the declared losses, with
non-vacuity stats), and arguments compared per class 2 — legacy asserted
== [] explicitly, modern asserted non-empty for the parameterized fixture.

The value differential surfaced one reader-parity gap the HTML differential
cannot see: under a retry-enabled plan, legacy stamps every summary
"iteration 1" while modern reports repetition info only for real
repetitions, and nothing renders a lone iteration number. The legacy reader
now strips it (strippingLoneIterationNumber) — a single execution carries no
repetition information on either backend. Recorded as a Task 14 execution
rule in the spec.

Refs #391 (Task 14).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* fix: fold in the carried review findings from #447 and #450

- Pin the no-startTime keep-guard (#450 review): a no-start activity row
  carrying an attachment, a failure flag, or surviving children is kept by
  the symbol-annotation drop; only the contentless row is an annotation.
  Crafted-document test, since no fixture produces the shape.
- Suffix the failure-artifact name per matrix leg in test.yml (#450 review):
  upload-artifact v4 refuses duplicate names, so a run where both legs fail
  would have lost the second upload.
- ModernPayloadStore takes XCResultToolInvoking instead of the concrete
  client (#447 review), so export-failure faulting is provable in-suite; the
  new test also pins that a failed one-shot export no longer leaks its temp
  directory (removed in the catch — deinit never saw it).
- An out-of-range repetition index no longer falls back silently to
  runs.first (#447 review): the iteration renders no activities and records
  .missingActivities, instead of borrowing repetition 1's rows.

Refs #391.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* docs: document --result-reader and the --json schema change

README gains the --result-reader section, the --json break with a
before/after snippet, and the known backend differences drawn from the
allow-list. The 4.0 release notes are drafted at docs/release-notes/4.0.0.md
in the 3.0.0 narrative style for the release to source, covering the full
Task 15 checklist including the items added by rulings R1/R5/R7 and the
#443/#450 reviews. The spec gains a status header (phases 1-5 landed, phase
6 deliberately deferred) and the Task 14 execution rules; the plan's Tasks
14-15 are ticked with implementation amendments recorded.

Refs #391 (Task 15).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* docs: state schema identity, not value identity, in the README

The --json section claimed the file is identical across readers; the
contract's own headline is schema identity, with declared value differences.
Point at those and at testCase.arguments, the modern-only capability.
Addresses the valid half of CodeRabbit's review on #451.

Refs #391.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

…ixes #460) (#486)

* Give every status a filter, and the log something to filter it with (fixes #460)

The last of #439's redesign PRs. A1 gave the report a summary header, A2 gave
the tree Xcode's outline, A3a gave each view its own surface and reserved a
slot in each toolbar. This fills the slots.

## The expected-failure bucket (#460)

The model has named `.expectedFailure` since #443 and A1's tally has counted
it in a bucket of its own since the header landed. The filter row was the last
reading of a run that still had it in no bucket at all: five functions, each
naming the four row classes it shows or hides, and an expected failure carries
none of them. So "Passed" left one on screen — a reader asking for the tests
that passed was shown one that did not — and "All" could not put it back,
because "All" only ever set `display: block` on those same four. The group
pass then read the row as hidden, so a suite of nothing but expected failures
vanished from the tree the moment the reader touched any filter, "All"
included.

**Decision: they leave `unknown` entirely, and nothing in the header moves.**
That is the whole point — A1 already put them where they belong, and the
coordination this needed was to make the toolbar agree rather than to move a
count. `CoreTests` has carried the disagreement as a comment since A1 ("the two
readings disagree until A3 rebuilds the filters"); it now asserts the partition
instead.

**The pills are the legend, made operable.** Both are rendered from the run's
`Tally`: same buckets, same order, same drop-the-empty-ones rule. A leading
"All", then one pill per outcome the run produced. That is what closes the
class of defect rather than the instance — `unknown` had exactly the same gap
and no issue filed against it, and it is filtered now for the same reason
`expectedFailure` is: a status gets a pill *because* the run produced it.

Three consequences worth stating, since each was a filter that did not finish:

- **A suite goes when its last visible row does.** The pass this replaces
  bailed out on any group holding a sub-group, so the legacy backend's two
  wrapper levels — "Selected tests" and "<target>.xctest" — survived every
  filter. Two selected rows sat under three empty headings. Deciding
  deepest-first covers both cases with one rule.
- **A filtered-out test takes its screenshot with it.** `.screenshot-tail` is
  emitted *between* rows rather than inside one (A2), so it was outside
  everything the filters touched.
- **A childless suite is a row.** `Run.allTests` counts one as a leaf — the
  shape a crashed target leaves behind, which `TruncationFaultTests` is built
  from — so the pills count it and now filter it.

## Tests and runs

Xcode's toolbar states 21 tests and 23 runs on `TestResults.xcresult`; ours
knew only tests. The difference is `parameterizedAddition(value:)`, which ran
once per argument set.

Neither `iterations` nor `arguments` could carry that: both readers
deliberately collapse argument executions into one iteration (that is what
makes the two backends agree on the rows), and only the modern format names
the argument values. The *count* is in both bundles — legacy has one sibling
metadata entry per execution, modern one `Arguments` child — and legacy was
throwing it away in `mergingArgumentExecutions`. `ParsedTestCase` gains
`executionCount`, so this converges the readers rather than reading anything
new, and `DifferentialTests.testExecutionCountsAgreeAcrossBackends` holds them
converged, with a non-vacuity check because equality is free if nothing ever
ran twice.

The toolbar reads `23 executions`, not "23 runs": this report already spends
the word "run" on a destination, which the picker labels `Run 1`, `Run 2`.
It is `aria-live`, because a filter changes it. Each row that accounts for a
difference says so — `3 arguments`, the option-A mockup's own tag — and only
the count is stated, never the values, which one backend cannot see.

No per-run rows in the tree: counts and filter semantics only.

## A name filter, in both views

Xcode puts a Filter field at the trailing end of both toolbars. So does this,
in the slot A3a reserved. On Tests it is a name-substring filter over the tree
that *composes* with the pills — "Failed" and "one" together mean the failing
tests whose names contain "one". On Logs it filters the log's lines.

**The log moves into the page to make that possible.** It was an
`<iframe src>` pointing at a `file://` sibling or a `data:` URI — a foreign
origin either way — and two things followed that the report shipped: nothing
in the page could filter, search or scroll it, which is why A3a's toolbar
carried an inert "All Messages" label where a control belongs; and it could
not see the token layer, so in dark mode the Logs view was a white slab with
black text, the same class of defect as the base64 status PNGs #459 replaced.
`logs-1440-dark.png` in the A3a evidence is that slab; the one here is the
same view themed.

A single `<pre>` rather than an element per line: a filter that rebuilds one
text node is a string join, where a six-figure log would otherwise be a
six-figure DOM. The `.log` export is untouched — it is the artifact #480 fixed
and `DifferentialLogTests` compares — and inline mode gets *smaller*, since
escaped text costs less than the same bytes base64'd into a URI.

## Substitution order, closed rather than ordered

`Run` fills its two templates from two ordered lists instead of one
dictionary. `HTML.html` reduces over a dictionary, so it fills placeholders in
hash order and fills the ones an earlier replacement *inserted* as readily as
the ones the template author wrote — the hazard the A3a review found in the
picker. Two per-view templates make it closable: each list holds only what its
own template needs, so a test named `[[LOG_TEXT]]` is not merely filled late
but unfillable, and a log line reading `[[TEST_SUMMARIES]]` likewise. Both
directions pinned in `PlaceholderOrderTests`.

## Verification

- `swift test` — 193 tests, 0 failures, 3 skipped, on both legs (default/auto
  and `XCHR_RESULT_READER=modern`).
- `DifferentialTests` green on both legs; the allow-list is untouched.
- `visual` — 48 Playwright tests, 0 failures: six axe states (two new — the
  filtered tree and the filtered log), contrast over both themes, both
  fixtures and now both *views*, the filter behaviour, and 375px.
- Masked duration shapes untouched.
- `swiftformat --lint` clean; no new SwiftLint warnings.

Refs #439.

* Match suite names in the tree filter too

A filter over a tree that only ever reads its leaves is one a reader finds out
about the hard way: typing the name of a suite they can see emptied the pane.
Matching an ancestor keeps that suite and the tests inside it, which is what
the same query does in Xcode's outline.

The status filter stays a leaf question. A suite's own status is folded from
its children, so filtering on it would put rows of every outcome under a
heading claiming one.

Gated with its own precondition: the test asserts that no row carries the
suite's name itself, or it would be measuring substring matching rather than
ancestry.

Refs #439.

* Put the log's monospace stack in the token layer

The one literal A3b left outside it. The sheet has had zero hardcoded font
stacks since #455 gave it a token layer, and the log body had no business
being the exception.

Refs #439.

* Carry every tail screenshot with its row, not just the nearest

Review finding, verified before fixing. `TestScreenshotFlow` emits a test's
*last three* screenshots (`suffix(tailCount)`), so a test with several is
preceded by several — and the filter walked back exactly one sibling, leaving
the outer ones on screen with no row to belong to.

The synthetic fixture already contains such a row (`testFails()`, whose
standard activities and failure activity each carry a screenshot), so the gate
was passing on a one-tail row while the two-tail one went unchecked. It now
counts every tail rather than the first, and asserts the fixture actually holds
a run of more than one — mutation-tested against the one-sibling version, which
it fails.

Refs #439.

* Keep the executions count level with the rows on screen

Review finding, reproduced before fixing. Filter the real two-bundle report to
`Passed` and the toolbar reads `14 executions`; jump to a failing test from the
digest and a thirteenth row appears — 15 executions on screen — while the
toolbar still says 14. `digestJump` cleared `display` on the row and its
ancestors itself and never recomputed, so it walked around the single writer
the file's own contract names ("One writer, so the rendered value and every
recomputation of it are the same sentence"). The element is `aria-live`, so the
notice a screen-reader reader gets when a row arrives was silence.

The count is now taken off the rows rather than accumulated while the filter
decides them: `countExecutionsOnScreen` sums the visible rows' `data-runs` and
writes through `setCount`, and both the filter and the jump call it. Anything
that changes what the pane holds can restate the figure the same way.

The gate is the reviewer's scenario exactly — `Passed`, then the digest jump —
asserting the toolbar equals the executions actually visible, summed from the
rows, with a precondition that the jump really did reveal one. It fails on the
old code (`4 executions` where 5 are showing) and holds on the new. The goldens
carry only this script change.

Refs #439.

* Say only what the fixtures show about the combined shape

Two documentation nits from the review of #486.

The cross-reference named `testExecutionCountsMatchAcrossBackends`; the test is
`testExecutionCountsAgreeAcrossBackends`. A stale name in a repo that otherwise
keeps them exact is a reader sent looking for a test that does not exist.

And the note on a test that is both parameterized and repeated asserted more
than anyone here can know: "legacy counts the product, modern the larger of the
two". No fixture exercises that shape, which is the whole reason it is written
down — and modern's answer in particular turns on where the `Repetition` nodes
sit, `R` if they nest under `Arguments` rather than `max(R, A)`. The note now
says the shape is unmeasured and names the gate that would catch it, which is
what the reasoning behind the field actually supports.

Refs #439.