Improve drone Space map presentation

Research-steered map-first update: default grouped markers by coordinate/site, marker size by case count, strongest-evidence coloring, coordinate-quality symbols, repeated-marker mode, and source-linked marker detail panels.

README.md

@@ -13,4 +13,4 @@ python_version: 3.11
 
 Map-first review surface for public-source reports about mystery, unidentified, suspicious, or unauthorized drone activity around sensitive sites.
 
-This Space plots the expanded case set on a world map, with evidence tiers, source links, coordinate-quality labels, country/site filters, and row-level claim boundaries. It does not claim that any row proves threat, attribution, anomalous origin, or hostile intent.
+The default map groups repeated reports by coordinate/site so dense clusters are readable. Marker size is case count, color is strongest evidence tier, and symbol is coordinate quality. Selecting a marker opens the source-linked cases behind it.

public_space_app.py

@@ -8,7 +8,18 @@ import pandas as pd
 import plotly.express as px
 
 
-DISPLAY_COLUMNS = [
+GROUP_COLUMNS = [
+    "case_count",
+    "strongest_evidence_tier",
+    "plot_label",
+    "coordinate_quality",
+    "country",
+    "date_span",
+    "probable_cluster_count",
+    "evidence_mix",
+    "top_source_domains",
+]
+CASE_COLUMNS = [
     "case_rank",
     "evidence_tier",
     "report_date",
@@ -20,31 +31,55 @@ DISPLAY_COLUMNS = [
     "source_domain",
     "followup_status",
 ]
+TIER_RANK = {
+    "resolved_sensitive_site_report": 0,
+    "named_sensitive_site_report": 1,
+    "source_discovered_report": 2,
+}
+TIER_LABEL = {
+    "resolved_sensitive_site_report": "resolved site report",
+    "named_sensitive_site_report": "named-site report",
+    "source_discovered_report": "source-discovered report",
+}
+COARSE_COORDINATE_QUALITIES = {"region_centroid", "country_centroid", "city_area_centroid"}
 
 
 def _load_data(data_dir: Path) -> tuple[pd.DataFrame, dict, dict]:
     cases = pd.read_csv(data_dir / "mystery_drone_sensitive_site_cases.csv").fillna("")
     manifest = json.loads((data_dir / "release_manifest.json").read_text(encoding="utf-8"))
     quality = json.loads((data_dir / "quality_report.json").read_text(encoding="utf-8"))
+    cases["case_rank"] = pd.to_numeric(cases["case_rank"], errors="coerce").fillna(999999).astype(int)
+    cases["plot_lat"] = pd.to_numeric(cases["plot_lat"], errors="coerce")
+    cases["plot_lon"] = pd.to_numeric(cases["plot_lon"], errors="coerce")
     cases["report_year"] = cases["report_date"].astype(str).str.slice(0, 4).replace("", "unknown")
+    cases["map_group_id"] = cases.apply(
+        lambda row: "|".join(
+            [
+                f"{float(row['plot_lat']):.4f}" if pd.notna(row["plot_lat"]) else "",
+                f"{float(row['plot_lon']):.4f}" if pd.notna(row["plot_lon"]) else "",
+                str(row.get("plot_label", "")),
+                str(row.get("coordinate_quality", "")),
+                str(row.get("country", "")),
+            ]
+        ),
+        axis=1,
+    )
     return cases, manifest, quality
 
 
 def _markdown_header(manifest: dict, quality: dict) -> str:
     tiers = manifest.get("counts_by_evidence_tier", {})
-    countries = manifest.get("counts_by_country", {})
-    top_countries = ", ".join(f"{key}: {value}" for key, value in list(countries.items())[:7])
     return f"""# Mystery Drone Reports Around Sensitive Sites
 
-Map-first public review surface for mystery, unidentified, suspicious, or unauthorized drone reports around military, airport, maritime, emergency-service, and critical-infrastructure contexts.
+Map-first review surface for public-source reports around military, airport, maritime, emergency-service, and critical-infrastructure contexts.
 
-**{manifest.get("case_count", 0)} cases** | **{manifest.get("probable_cluster_count", 0)} probable clusters** | **release gate: {"pass" if quality.get("release_grade") else "review"}**
+**{manifest.get("case_count", 0)} cases** | **{manifest.get("probable_cluster_count", 0)} probable clusters** | **{quality.get("mappable_case_count", 0)} mapped rows** | **release gate: {"pass" if quality.get("release_grade") else "review"}**
 
-Evidence tiers: resolved sensitive-site reports `{tiers.get("resolved_sensitive_site_report", 0)}`, named-site cases `{tiers.get("named_sensitive_site_report", 0)}`, source-discovered reports `{tiers.get("source_discovered_report", 0)}`.
+Default view groups repeated reports at the same public coordinate so dense clusters, like New Jersey, read as one place-marker with a case list instead of a pile of overlapping dots.
 
-Country coverage: {top_countries}
+Evidence tiers: resolved site `{tiers.get("resolved_sensitive_site_report", 0)}`, named site `{tiers.get("named_sensitive_site_report", 0)}`, source-discovered `{tiers.get("source_discovered_report", 0)}`.
 
-Rows are source-indexed report cases, not verified findings of threat, attribution, anomalous origin, or hostile intent. Map points use the best public coordinate available: site centroid, city/region centroid, country centroid, or a clearly labeled fallback.
+Map points are source-indexed report locations, not verified findings of threat, attribution, anomalous origin, or hostile intent. `coordinate_quality` tells you whether a marker is a site, city, region, or country centroid.
 """
 
 
@@ -52,20 +87,54 @@ def _options(values: pd.Series) -> list[str]:
     return sorted(str(value) for value in values.dropna().astype(str).unique() if str(value))
 
 
+def _strongest_tier(values: pd.Series) -> str:
+    tiers = [str(value) for value in values if str(value)]
+    if not tiers:
+        return "source_discovered_report"
+    return sorted(tiers, key=lambda value: TIER_RANK.get(value, 99))[0]
+
+
+def _count_text(values: pd.Series, *, label_map: dict[str, str] | None = None, limit: int = 4) -> str:
+    counts = values.astype(str).replace("", "unknown").value_counts()
+    parts = []
+    for key, value in counts.head(limit).items():
+        label = label_map.get(key, key) if label_map else key
+        parts.append(f"{label}: {int(value)}")
+    return "; ".join(parts)
+
+
+def _date_span(values: pd.Series) -> str:
+    dates = sorted(str(value) for value in values if str(value))
+    if not dates:
+        return "undated"
+    if dates[0] == dates[-1]:
+        return dates[0]
+    return f"{dates[0]} to {dates[-1]}"
+
+
 def _filter_cases(
     cases: pd.DataFrame,
     evidence_tiers: list[str] | None,
+    coordinate_qualities: list[str] | None,
     countries: list[str] | None,
     site_types: list[str] | None,
+    source_domains: list[str] | None,
+    years: list[str] | None,
     query: str,
 ) -> pd.DataFrame:
     filtered = cases.copy()
     if evidence_tiers:
         filtered = filtered[filtered["evidence_tier"].isin(evidence_tiers)]
+    if coordinate_qualities:
+        filtered = filtered[filtered["coordinate_quality"].isin(coordinate_qualities)]
     if countries:
         filtered = filtered[filtered["country"].isin(countries)]
     if site_types:
         filtered = filtered[filtered["site_type"].isin(site_types)]
+    if source_domains:
+        filtered = filtered[filtered["source_domain"].isin(source_domains)]
+    if years:
+        filtered = filtered[filtered["report_year"].isin(years)]
     query = str(query or "").strip().lower()
     if query:
         haystack = (
@@ -73,6 +142,8 @@ def _filter_cases(
             + " "
             + filtered["site_name"].astype(str)
             + " "
+            + filtered["plot_label"].astype(str)
+            + " "
             + filtered["country"].astype(str)
             + " "
             + filtered["source_domain"].astype(str)
@@ -81,133 +152,257 @@ def _filter_cases(
     return filtered.sort_values(["case_rank"]).reset_index(drop=True)
 
 
-def _summary_text(filtered: pd.DataFrame) -> str:
+def _group_cases(filtered: pd.DataFrame) -> pd.DataFrame:
+    rows: list[dict] = []
+    if filtered.empty:
+        return pd.DataFrame(columns=GROUP_COLUMNS + ["map_group_id", "plot_lat", "plot_lon"])
+    for group_id, group in filtered.groupby("map_group_id", sort=False):
+        strongest = _strongest_tier(group["evidence_tier"])
+        rows.append(
+            {
+                "map_group_id": group_id,
+                "case_count": int(len(group)),
+                "strongest_evidence_tier": strongest,
+                "plot_lat": float(group["plot_lat"].iloc[0]),
+                "plot_lon": float(group["plot_lon"].iloc[0]),
+                "plot_label": str(group["plot_label"].iloc[0]),
+                "coordinate_quality": str(group["coordinate_quality"].iloc[0]),
+                "country": str(group["country"].iloc[0]),
+                "date_span": _date_span(group["report_date"]),
+                "probable_cluster_count": int(group["probable_cluster_id"].nunique()),
+                "evidence_mix": _count_text(group["evidence_tier"], label_map=TIER_LABEL),
+                "top_source_domains": _count_text(group["source_domain"], limit=3),
+                "site_types": _count_text(group["site_type"], limit=3),
+            }
+        )
+    grouped = pd.DataFrame(rows)
+    grouped = grouped.sort_values(
+        ["case_count", "strongest_evidence_tier", "plot_label"],
+        ascending=[False, True, True],
+    ).reset_index(drop=True)
+    return grouped
+
+
+def _marker_rows(filtered: pd.DataFrame, mode: str, repeated_only: bool) -> pd.DataFrame:
+    working = filtered.copy()
+    if mode == "Coarse-location review":
+        working = working[working["coordinate_quality"].isin(COARSE_COORDINATE_QUALITIES)]
+    if mode == "Individual cases":
+        group_sizes = working["map_group_id"].value_counts().to_dict()
+        if repeated_only:
+            working = working[working["map_group_id"].map(group_sizes).fillna(0) > 1]
+        markers = working.copy()
+        markers["case_count"] = 1
+        markers["strongest_evidence_tier"] = markers["evidence_tier"]
+        markers["date_span"] = markers["report_date"]
+        markers["probable_cluster_count"] = 1
+        markers["evidence_mix"] = markers["evidence_tier"].map(lambda value: TIER_LABEL.get(str(value), str(value)))
+        markers["top_source_domains"] = markers["source_domain"]
+        return markers.sort_values(["case_rank"]).reset_index(drop=True)
+    grouped = _group_cases(working)
+    if repeated_only and not grouped.empty:
+        grouped = grouped[grouped["case_count"] > 1].reset_index(drop=True)
+    return grouped
+
+
+def _summary_text(filtered: pd.DataFrame, markers: pd.DataFrame, mode: str) -> str:
     if filtered.empty:
         return "No rows match the current filters."
-    tier_counts = filtered["evidence_tier"].value_counts().to_dict()
-    country_counts = filtered["country"].value_counts().head(8).to_dict()
-    tiers = ", ".join(f"{key}: {value}" for key, value in tier_counts.items())
-    countries = ", ".join(f"{key}: {value}" for key, value in country_counts.items())
-    return f"Showing {len(filtered)} cases. Evidence tiers: {tiers}. Top countries: {countries}."
+    precise_count = int((filtered["coordinate_quality"] == "site_centroid").sum())
+    grouped_count = int(len(markers))
+    largest_stack = int(markers["case_count"].max()) if "case_count" in markers and not markers.empty else 0
+    return (
+        f"Showing {len(filtered)} cases as {grouped_count} map markers in `{mode}` mode. "
+        f"{precise_count} cases use site centroids; the largest visible marker groups {largest_stack} cases. "
+        "Marker size is case count; color is strongest evidence tier; symbol is coordinate quality."
+    )
 
 
-def _map(filtered: pd.DataFrame):
-    if filtered.empty:
-        fig = px.scatter_geo(pd.DataFrame({"plot_lat": [], "plot_lon": []}), lat="plot_lat", lon="plot_lon", height=620)
+def _map(markers: pd.DataFrame, mode: str):
+    if markers.empty:
+        fig = px.scatter_geo(pd.DataFrame({"plot_lat": [], "plot_lon": []}), lat="plot_lat", lon="plot_lon", height=690)
         fig.update_layout(margin={"l": 0, "r": 0, "t": 20, "b": 0})
         return fig
-    plot_rows = filtered.copy()
-    plot_rows["plot_lat"] = pd.to_numeric(plot_rows["plot_lat"], errors="coerce")
-    plot_rows["plot_lon"] = pd.to_numeric(plot_rows["plot_lon"], errors="coerce")
-    plot_rows = plot_rows.dropna(subset=["plot_lat", "plot_lon"])
     fig = px.scatter_geo(
-        plot_rows,
+        markers,
         lat="plot_lat",
         lon="plot_lon",
-        color="evidence_tier",
+        color="strongest_evidence_tier",
         symbol="coordinate_quality",
-        hover_name="headline",
+        size="case_count",
+        size_max=36 if mode != "Individual cases" else 14,
+        hover_name="plot_label",
         hover_data={
-            "case_rank": True,
-            "site_name": True,
-            "plot_label": True,
+            "case_count": True,
+            "probable_cluster_count": True,
             "country": True,
-            "report_date": True,
-            "source_domain": True,
+            "date_span": True,
+            "evidence_mix": True,
+            "top_source_domains": True,
             "coordinate_quality": True,
             "plot_lat": False,
             "plot_lon": False,
         },
         projection="natural earth",
-        height=660,
+        height=690,
+        color_discrete_map={
+            "resolved_sensitive_site_report": "#b42318",
+            "named_sensitive_site_report": "#b76e00",
+            "source_discovered_report": "#2b6f9e",
+        },
     )
-    fig.update_traces(marker={"size": 9, "opacity": 0.78, "line": {"width": 0.4, "color": "white"}})
+    fig.update_traces(marker={"opacity": 0.78, "line": {"width": 0.6, "color": "white"}})
     fig.update_geos(showland=True, landcolor="#eef2f5", showocean=True, oceancolor="#dfeaf2", showcountries=True)
-    fig.update_layout(margin={"l": 0, "r": 0, "t": 24, "b": 0}, legend_orientation="h")
+    fig.update_layout(
+        margin={"l": 0, "r": 0, "t": 24, "b": 0},
+        legend_orientation="h",
+        legend_title_text="Evidence tier / coordinate quality",
+    )
     return fig
 
 
-def _table(filtered: pd.DataFrame) -> pd.DataFrame:
-    return filtered[DISPLAY_COLUMNS].copy()
+def _cases_for_marker(marker: dict, filtered_rows: list[dict], mode: str) -> list[dict]:
+    if mode == "Individual cases":
+        case_id = marker.get("case_id")
+        return [row for row in filtered_rows if row.get("case_id") == case_id]
+    group_id = marker.get("map_group_id")
+    return [row for row in filtered_rows if row.get("map_group_id") == group_id]
 
 
-def _render(cases: pd.DataFrame, evidence_tiers, countries, site_types, query):
-    filtered = _filter_cases(cases, evidence_tiers, countries, site_types, query)
-    rows = filtered.to_dict("records")
-    return _summary_text(filtered), _map(filtered), _table(filtered), rows, _detail(rows, 0)
-
-
-def _detail(rows: list[dict], index: int | None) -> str:
-    if not rows:
-        return "No case selected."
+def _detail(markers: list[dict], filtered_rows: list[dict], index: int | None, mode: str) -> str:
+    if not markers:
+        return "No map marker selected."
     try:
-        row = rows[int(index or 0)]
+        marker = markers[int(index or 0)]
     except (IndexError, TypeError, ValueError):
-        row = rows[0]
-    return f"""### {row.get("headline", "")}
-
-- Evidence tier: `{row.get("evidence_tier", "")}`
-- Follow-up status: `{row.get("followup_status", "")}`
-- Report date: `{row.get("report_date", "")}` (`{row.get("date_quality", "")}`)
-- Site signal: `{row.get("site_name", "")}` / `{row.get("site_type", "")}`
-- Map point: `{row.get("plot_label", "")}` / `{row.get("coordinate_quality", "")}`
-- Location signal: `{row.get("country", "")}` `{row.get("state_region", "")}`
-- Source: [{row.get("publisher", "") or row.get("source_domain", "")}]({row.get("source_url", "")})
-- Boundary: {row.get("claim_boundary", "")}
-- Row hash: `{row.get("public_row_sha256", "")}`
-"""
+        marker = markers[0]
+    marker_cases = _cases_for_marker(marker, filtered_rows, mode)
+    marker_cases = sorted(
+        marker_cases,
+        key=lambda row: (
+            TIER_RANK.get(str(row.get("evidence_tier")), 99),
+            str(row.get("report_date", "")),
+            int(row.get("case_rank") or 999999),
+        ),
+    )
+    quality = marker.get("coordinate_quality", "")
+    warning = ""
+    if quality in COARSE_COORDINATE_QUALITIES:
+        warning = "\n\n**Coordinate note:** this marker is a coarse centroid. Use it as a review location, not a precise sighting coordinate."
+    lines = [
+        f"### {marker.get('plot_label', '')}",
+        "",
+        f"- Map mode: `{mode}`",
+        f"- Cases at marker: `{len(marker_cases)}`",
+        f"- Probable clusters: `{marker.get('probable_cluster_count', '')}`",
+        f"- Evidence mix: {marker.get('evidence_mix', '')}",
+        f"- Date span: `{marker.get('date_span', '')}`",
+        f"- Coordinate quality: `{quality}`",
+        f"- Top source domains: {marker.get('top_source_domains', '')}",
+        warning,
+        "",
+        "#### Cases behind this marker",
+    ]
+    for row in marker_cases[:18]:
+        lines.extend(
+            [
+                "",
+                f"**#{row.get('case_rank')} - {row.get('headline', '')}**",
+                f"- `{row.get('evidence_tier', '')}` | `{row.get('report_date', '')}` | `{row.get('site_name', '')}`",
+                f"- Source: [{row.get('publisher', '') or row.get('source_domain', '')}]({row.get('source_url', '')})",
+                f"- Boundary: {row.get('claim_boundary', '')}",
+            ]
+        )
+    if len(marker_cases) > 18:
+        lines.append(f"\n...and {len(marker_cases) - 18} more rows in the marker table/filter result.")
+    return "\n".join(line for line in lines if line is not None)
+
+
+def _render(
+    cases: pd.DataFrame,
+    evidence_tiers,
+    coordinate_qualities,
+    countries,
+    site_types,
+    source_domains,
+    years,
+    mode,
+    repeated_only,
+    query,
+):
+    filtered = _filter_cases(cases, evidence_tiers, coordinate_qualities, countries, site_types, source_domains, years, query)
+    markers = _marker_rows(filtered, mode or "Grouped sites", bool(repeated_only))
+    filtered_rows = filtered.to_dict("records")
+    marker_records = markers.to_dict("records")
+    marker_table_columns = GROUP_COLUMNS if mode != "Individual cases" else CASE_COLUMNS
+    marker_table = markers[[column for column in marker_table_columns if column in markers.columns]].copy()
+    return (
+        _summary_text(filtered, markers, mode or "Grouped sites"),
+        _map(markers, mode or "Grouped sites"),
+        marker_table,
+        marker_records,
+        filtered_rows,
+        _detail(marker_records, filtered_rows, 0, mode or "Grouped sites"),
+    )
 
 
 def build_app(data_dir: str | Path):
     data_dir = Path(data_dir)
     cases, manifest, quality = _load_data(data_dir)
+    evidence_choices = _options(cases["evidence_tier"])
+    coordinate_choices = _options(cases["coordinate_quality"])
     with gr.Blocks(title="Mystery Drone Reports Around Sensitive Sites") as app:
         gr.Markdown(_markdown_header(manifest, quality))
         with gr.Row():
-            evidence_filter = gr.CheckboxGroup(
-                choices=_options(cases["evidence_tier"]),
-                value=_options(cases["evidence_tier"]),
-                label="Evidence tier",
+            mode = gr.Radio(
+                choices=["Grouped sites", "Individual cases", "Coarse-location review"],
+                value="Grouped sites",
+                label="Map mode",
             )
-            country_filter = gr.Dropdown(
-                choices=_options(cases["country"]),
-                value=[],
-                multiselect=True,
-                label="Country",
-            )
-            site_filter = gr.Dropdown(
-                choices=_options(cases["site_type"]),
-                value=[],
-                multiselect=True,
-                label="Site type",
-            )
-        query = gr.Textbox(label="Search", placeholder="Try Langley, Copenhagen, airport, military base")
+            repeated_only = gr.Checkbox(value=False, label="Only repeated markers")
+            query = gr.Textbox(label="Search", placeholder="Try New Jersey, Langley, Copenhagen, airport, military base")
+        with gr.Row():
+            evidence_filter = gr.CheckboxGroup(choices=evidence_choices, value=evidence_choices, label="Evidence tier")
+            coordinate_filter = gr.CheckboxGroup(choices=coordinate_choices, value=coordinate_choices, label="Coordinate quality")
+        with gr.Row():
+            country_filter = gr.Dropdown(choices=_options(cases["country"]), value=[], multiselect=True, label="Country")
+            site_filter = gr.Dropdown(choices=_options(cases["site_type"]), value=[], multiselect=True, label="Site type")
+            source_filter = gr.Dropdown(choices=_options(cases["source_domain"]), value=[], multiselect=True, label="Source domain")
+            year_filter = gr.Dropdown(choices=_options(cases["report_year"]), value=[], multiselect=True, label="Report year")
         summary = gr.Markdown()
-        map_plot = gr.Plot(label="Case map")
-        table = gr.Dataframe(label="Filtered cases", interactive=False)
-        rows_state = gr.State([])
-        detail = gr.Markdown()
-
-        def render(evidence_tiers, countries, site_types, search_query):
-            return _render(cases, evidence_tiers, countries, site_types, search_query)
-
-        for control in (evidence_filter, country_filter, site_filter, query):
-            control.change(
-                render,
-                inputs=[evidence_filter, country_filter, site_filter, query],
-                outputs=[summary, map_plot, table, rows_state, detail],
-            )
-
-        def select_detail(rows, evt: gr.SelectData):
+        with gr.Row():
+            with gr.Column(scale=3):
+                map_plot = gr.Plot(label="Grouped case map")
+            with gr.Column(scale=2):
+                detail = gr.Markdown()
+        marker_table = gr.Dataframe(label="Visible map markers", interactive=False)
+        marker_rows_state = gr.State([])
+        filtered_rows_state = gr.State([])
+
+        def render(evidence_tiers, coordinate_qualities, countries, site_types, source_domains, years, map_mode, repeats, search_query):
+            return _render(cases, evidence_tiers, coordinate_qualities, countries, site_types, source_domains, years, map_mode, repeats, search_query)
+
+        inputs = [
+            evidence_filter,
+            coordinate_filter,
+            country_filter,
+            site_filter,
+            source_filter,
+            year_filter,
+            mode,
+            repeated_only,
+            query,
+        ]
+        outputs = [summary, map_plot, marker_table, marker_rows_state, filtered_rows_state, detail]
+        for control in inputs:
+            control.change(render, inputs=inputs, outputs=outputs)
+
+        def select_marker(markers, filtered_rows, map_mode, evt: gr.SelectData):
             if not evt or evt.index is None:
-                return _detail(rows, 0)
+                return _detail(markers, filtered_rows, 0, map_mode)
             row_index = evt.index[0] if isinstance(evt.index, (list, tuple)) else evt.index
-            return _detail(rows, row_index)
+            return _detail(markers, filtered_rows, row_index, map_mode)
 
-        table.select(select_detail, inputs=rows_state, outputs=detail)
-        app.load(
-            render,
-            inputs=[evidence_filter, country_filter, site_filter, query],
-            outputs=[summary, map_plot, table, rows_state, detail],
-        )
+        marker_table.select(select_marker, inputs=[marker_rows_state, filtered_rows_state, mode], outputs=detail)
+        app.load(render, inputs=inputs, outputs=outputs)
     return app

space_manifest.json

@@ -1,5 +1,5 @@
 {
-  "space_bundle_version": "mystery_drone_sensitive_site_space_v1",
+  "space_bundle_version": "mystery_drone_sensitive_site_space_v2",
   "source_release_version": "mystery-drone-sensitive-site-cases-2026-05-v1",
   "case_count": 149,
   "release_grade": true,
@@ -13,14 +13,14 @@
     {
       "artifact_role": "space_public_app",
       "artifact_path": "public_space_app.py",
-      "content_sha256": "fa5bdda74630f425a0389dbb89ba43ab1bc81d9302a5a0feeb657d5146ccd172",
-      "byte_count": 8877
+      "content_sha256": "05ecfaa2d35d3cb16dcfba7a9bc94ea9a19d21a49fe875acc704b50f27c419f1",
+      "byte_count": 17863
     },
     {
       "artifact_role": "readme",
       "artifact_path": "README.md",
-      "content_sha256": "3dc884fb6fe90ae55d6494c38e365e0660dc68efb2519d8e54f7c14fc19e2669",
-      "byte_count": 626
+      "content_sha256": "050e3c4fcac1cc1dd91c026f350d2e458d4641c0da2d8ec18c06009a8d7be990",
+      "byte_count": 605
     },
     {
       "artifact_role": "requirements",
@@ -47,5 +47,5 @@
       "byte_count": 1008
     }
   ],
-  "bundle_hash": "89aeb842010180e667afc7a238b888daaf1480ac29ed298735b5f454c67e107b"
+  "bundle_hash": "1efe312db89231fc27a11b2c2e540727fd9196ed7bec35115afee24d474cda6e"
 }