@@ -187,7 +187,11 @@ Manifest order controls project, filter, baseline, and table row order. The main
 page shows a grouped bar chart with a fixed 0–100% axis. Each group is a
 candidate version, and each bar in a group is an SDK baseline. Numeric release
 labels, including prereleases, sort from oldest to newest. Custom version labels
-keep their manifest order. Select a bar to open its report, or select a legend
+keep their manifest order. The chart and the Markdown/SVG tables show the
+highest patch version of each minor version, for example 0.23.1 and not 0.23.0.
+A selected earlier patch version, for example from a release notes link, is
+shown too, and changes are measured from the previous shown version. Summaries
+and reports include every version. Select a bar to open its report, or select a legend
 item to isolate a baseline. About four versions fill the visible width, the
 percentage axis stays in place while the chart scrolls, and wide bars show their
 values. When one baseline is shown, each version shows the change in matched
@@ -208,12 +212,10 @@ python3 Tools/InterfaceCoverage/Scripts/collect_openswiftui_releases.py collect
   --xcode /Applications/Xcode-16.4.0.app --xcode /Applications/Xcode-26.6.0.app
 ```
 
-Use `--all-releases` in place of `--release` to compare the published releases
-that include both XCFrameworks. It keeps only the highest patch version of each
-minor version, for example 0.23.1 and not 0.23.0. A release comes after its
-prereleases. `--release` uses the given versions as they are. Pass `--site-url`
-to make summary links absolute. Add `--include-manifest` with an earlier
-manifest to keep its reports for other projects in the same site.
+Use `--all-releases` in place of `--release` to compare every published release
+that includes both XCFrameworks. Pass `--site-url` to make summary links
+absolute. Add `--include-manifest` with an earlier manifest to keep its reports
+for other projects in the same site.
 
 The results for one release, target, and SDK form a cache entry: one report for
 each scope and a `cache.json` file. An entry is reused while its fingerprint
 
@@ -109,30 +109,8 @@ def release_metadata(repository, version, directory, refresh=False):
     return json.loads(path.read_text())
 
 
-def version_key(version):
-    """Orders semantic versions. A release comes after its prereleases."""
-    match = re.fullmatch(r'v?(\d+)\.(\d+)(?:\.(\d+))?(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?', version)
-    if match is None:
-        return None
-    major, minor, patch, prerelease = match.groups()
-    parts = [(0, int(part), '') if part.isdigit() else (1, 0, part) for part in (prerelease or '').split('.') if part]
-    return (int(major), int(minor), int(patch or 0)), not prerelease, parts
-
-
-def latest_patches(versions):
-    """Keeps the highest patch version of each major and minor version, in the input order.
-    Labels that are not semantic versions are kept."""
-    latest = {}
-    for version in versions:
-        key = version_key(version)
-        if key is not None and (key[0][:2] not in latest or key > version_key(latest[key[0][:2]])):
-            latest[key[0][:2]] = version
-    return [version for version in versions if version_key(version) is None or latest[version_key(version)[0][:2]] == version]
-
-
 def published_releases(repository, work):
-    """Returns the published releases that include both XCFrameworks, oldest first. Only the
-    highest patch version of each minor version is kept."""
+    """Returns the published releases that include both XCFrameworks, oldest first."""
     releases = json.loads(gh('release', 'list', '--repo', repository, '--limit', '1000',
                              '--exclude-drafts', '--json', 'tagName,publishedAt'))
     result = []
@@ -145,7 +123,7 @@ def published_releases(repository, work):
             names = {asset['name'] for asset in release_metadata(repository, version, work / 'releases' / version, refresh=True)['assets']}
         if all(name in names for name in wanted):
             result.append(version)
-    return latest_patches(result)
+    return result
 
 
 def asset_digests(repository, version, work):
@@ -365,7 +343,7 @@ def add_site_options(command):
     releases = collect_command.add_mutually_exclusive_group(required=True)
     releases.add_argument('--release', action='append', help='Release tag. Repeat for more releases.')
     releases.add_argument('--all-releases', action='store_true',
-                          help='Use the highest patch version of each minor version among the published releases that include both XCFrameworks.')
+                          help='Use every published release that includes both XCFrameworks.')
     collect_command.add_argument('--xcode', action='append', required=True, type=pathlib.Path,
                                  help='Xcode application that supplies the baseline SDK. Repeat for more baselines.')
     collect_command.add_argument('--target', action='append', choices=sorted(TARGETS),
 
@@ -120,8 +120,11 @@ public enum CoverageSite {
         files["assets/site.js"] = Data(script.utf8)
         for group in ordered(records.map(\.group)) {
             let rows = records.filter { $0.group == group }
-            files["tables/\(group).md"] = Data(markdown(rows).utf8)
-            files["tables/\(group).svg"] = Data(svg(rows).utf8)
+            // Like the chart, tables show the highest patch version of each minor version.
+            let shown = Set(latestPatches(ordered(rows.map(\.version))))
+            let tableRows = rows.filter { shown.contains($0.version) }
+            files["tables/\(group).md"] = Data(markdown(tableRows).utf8)
+            files["tables/\(group).svg"] = Data(svg(tableRows).utf8)
             // A badge shows the latest version that has a result for each baseline.
             let versions = versionOrder(ordered(rows.map(\.version)))
             for baseline in ordered(rows.map(\.baseline)) {
@@ -174,6 +177,19 @@ public enum CoverageSite {
 
     /// Sorts numeric release labels, including prereleases, from oldest to newest.
     /// Other labels keep their manifest order. The site script uses the same rule.
+    /// Keeps the highest patch version of each minor version. Other labels are kept.
+    static func latestPatches(_ versions: [String]) -> [String] {
+        func minor(_ version: String) -> String? {
+            guard let match = version.wholeMatch(of: /^v?(\d+)\.(\d+)(?:\.\d+)?(?:-[\da-zA-Z.-]+)?(?:\+[\da-zA-Z.-]+)?$/) else { return nil }
+            return "\(match.1).\(match.2)"
+        }
+        let sorted = versionOrder(versions)
+        return sorted.enumerated().filter { index, version in
+            guard let key = minor(version) else { return true }
+            return !sorted[(index + 1)...].contains { minor($0) == key }
+        }.map(\.element)
+    }
+
     static func versionOrder(_ versions: [String]) -> [String] {
         let pattern = /^v?(\d+)\.(\d+)(?:\.(\d+))?(?:-([\da-zA-Z-]+(?:\.[\da-zA-Z-]+)*))?(?:\+[\da-zA-Z-]+(?:\.[\da-zA-Z-]+)*)?$/
         var parsed: [(version: String, numbers: [Int], prerelease: [Substring])] = []
 
@@ -45,6 +45,7 @@
   let groupRows = [];
   let rows = [];
   let chartWidth = 0;
+  let chartVersions = null;
   let current = null;
   let documentData = null;
   let request = 0;
@@ -163,10 +164,27 @@
     return node;
   }
 
-  // Compares a result with the previous version that has a result for the same baseline.
+  function minorVersion(version) {
+    const match = /^v?(\d+)\.(\d+)(?:\.\d+)?(?:-[\da-z.-]+)?(?:\+[\da-z.-]+)?$/i.exec(version);
+    return match ? `${match[1]}.${match[2]}` : null;
+  }
+
+  // The chart shows the highest patch version of each minor version, and the selected version.
+  // A summary link can select an earlier patch version, which is then shown too.
+  function displayedVersions() {
+    const versions = versionOrder(unique(groupRows.map(row => row.version)));
+    const selected = reports.find(row => row.id === state.report)?.version;
+    return versions.filter((version, index) => {
+      const minor = minorVersion(version);
+      return version === selected || !minor || versions.slice(index + 1).every(other => minorVersion(other) !== minor);
+    });
+  }
+
+  // Compares a result with the previous shown version that has a result for the same baseline.
   function change(record) {
     if (!record.summary.reference) return null;
-    const series = rows.filter(row => row.baseline === record.baseline && row.summary.reference > 0);
+    const shown = displayedVersions();
+    const series = rows.filter(row => row.baseline === record.baseline && row.summary.reference > 0 && shown.includes(row.version));
     const order = versionOrder(unique(series.map(row => row.version)));
     const index = order.indexOf(record.version);
     const previous = index > 0 ? series.find(row => row.version === order[index - 1]) : null;
@@ -189,6 +207,11 @@
   }
 
   function updateChartSelection() {
+    // Selecting another bar can hide an earlier patch version that was shown for the selection.
+    if (!embedded && chartVersions !== null && displayedVersions().join("|") !== chartVersions) {
+      renderChart();
+      return;
+    }
     $("chart").querySelectorAll("[data-report]").forEach(point => {
       point.setAttribute("aria-pressed", String(point.dataset.report === state.report));
     });
@@ -209,7 +232,8 @@
     const focused = document.activeElement?.closest("[data-report]")?.dataset.report;
     const scrollLeft = $("chart-scroll")?.scrollLeft || 0;
     const baselines = unique(groupRows.map(row => row.baseline));
-    const versions = versionOrder(unique(groupRows.map(row => row.version)));
+    const versions = displayedVersions();
+    chartVersions = versions.join("|");
     const visible = baselines.filter(baseline => !state.baseline || baseline === state.baseline);
     // With one baseline, each version also shows the change from the previous version.
     const showChanges = visible.length === 1;
@@ -351,7 +375,7 @@
       head.append(th);
     }
     const body = table.createTBody();
-    for (const version of unique(rows.map(row => row.version))) {
+    for (const version of displayedVersions().filter(version => rows.some(row => row.version === version))) {
       const tr = body.insertRow();
       const th = element("th", version);
       th.scope = "row";
 
@@ -254,6 +254,24 @@ struct CoverageSiteTests {
         #expect(markdown.contains("| iOS 18.5 | [0.00%]("))
     }
 
+    @Test func tablesShowTheLatestPatchOfEachMinorVersion() throws {
+        let root = try temporaryDirectory()
+        defer { try? FileManager.default.removeItem(at: root) }
+        let rows = try ["0.9.0", "0.10.0", "0.10.1"].map { version -> [String: Any] in
+            var row = try fixture(root)
+            row["version"] = version
+            return row
+        }
+        let output = try generate(root, rows: rows)
+        let tables = try FileManager.default.contentsOfDirectory(at: output.appendingPathComponent("tables"), includingPropertiesForKeys: nil)
+        let markdown = try String(contentsOf: #require(tables.first { $0.pathExtension == "md" }), encoding: .utf8)
+        #expect(markdown.contains("| 0.9.0 |"))
+        #expect(markdown.contains("| 0.10.1 |"))
+        #expect(!markdown.contains("| 0.10.0 |"))
+        // Summaries keep every version, so release notes of earlier patches can link to them.
+        #expect(FileManager.default.fileExists(atPath: output.appendingPathComponent("summary/example/0.10.0.json").path))
+    }
+
     @Test func rejectsInconsistentCounts() throws {
         let root = try temporaryDirectory()
         defer { try? FileManager.default.removeItem(at: root) }