Harden idedata against non-list compile DBs and stale caches, blanket the size summary

A compile DB that parses as valid JSON but is not a list now raises
EsphomeError inside IDEDATA_BEST_EFFORT_ERRORS instead of a TypeError that
fails an already-linked build. Cached idedata is validated on read against
the write path's guarantees (dict shape, no launcher as compiler, include
union present) so caches from older versions regenerate instead of serving
degraded data, and the served copy is re-stamped with the current ELF path.
Response-file shape sentinels key on the output object rather than the
source file, so two objects built from one source keep both include sets.

The size summary mirrors the standalone hardening PR: a blank partition
size cell raises by name, and a blanket guard keeps unexpected nested
shapes from raising past a build that already linked.

tests/unit_tests/build_helpers/test_idedata.py

@@ -574,11 +574,101 @@ def test_load_or_build_idedata_never_caches_a_launcher(tmp_path: Path) -> None:
     assert not cache.exists()
 
 
+@pytest.mark.parametrize(
+    "cached",
+    (
+        {"cc_path": "/x/gcc", "cxx_path": "/opt/homebrew/bin/ccache"},
+        {"cc_path": "/x/gcc", "cxx_path": "/tools/g++"},
+        {"cc_path": "/x/gcc", "cxx_path": "/tools/g++", "includes": {}},
+    ),
+    ids=("launcher-cxx", "no-includes", "no-build-list"),
+)
+def test_load_or_build_idedata_regenerates_invalid_cache(
+    tmp_path: Path, cached: dict
+) -> None:
+    """A cache written by an older version fails validation and regenerates."""
+    compile_commands = _write_compile_commands(tmp_path)
+    cache = tmp_path / "c.json"
+    cache.write_text(json.dumps(cached))
+    os.utime(cache, (compile_commands.stat().st_mtime + 5,) * 2)
+    with patch.object(idedata, "get_toolchain_includes", return_value=[]):
+        data = idedata.load_or_build_idedata(
+            compile_commands, tmp_path / "f.elf", cache
+        )
+    assert data["cxx_path"] == "/tools/g++"
+    assert "includes" in data
+
+
+def test_load_or_build_idedata_cache_hit_restamps_prog_path(tmp_path: Path) -> None:
+    """A served cache carries the current ELF path, not the one it was written with."""
+    compile_commands = _write_compile_commands(tmp_path)
+    cache = tmp_path / "c.json"
+    cache.write_text(
+        json.dumps(
+            {
+                "cc_path": "/tools/gcc",
+                "cxx_path": "/tools/g++",
+                "includes": {"build": [], "toolchain": []},
+                "prog_path": "/old/location/firmware.elf",
+            }
+        )
+    )
+    os.utime(cache, (compile_commands.stat().st_mtime + 5,) * 2)
+    data = idedata.load_or_build_idedata(
+        compile_commands, tmp_path / "firmware.elf", cache
+    )
+    assert data["prog_path"] == str(tmp_path / "firmware.elf")
+
+
+def test_idedata_from_build_non_list_compile_db_raises(tmp_path: Path) -> None:
+    """Valid JSON that is not a list raises by name, inside the best-effort tuple."""
+    compile_commands = tmp_path / "compile_commands.json"
+    for bad in ("{}", "null", '"text"'):
+        compile_commands.write_text(bad)
+        with pytest.raises(EsphomeError, match="not a compile-command list"):
+            idedata.idedata_from_build(compile_commands)
+
+
+def test_idedata_from_build_same_file_rsp_commands_never_dedupe(
+    tmp_path: Path,
+) -> None:
+    """Two objects built from one source with different .rsp files keep both
+    include sets; the rsp sentinel keys on the output, not the source."""
+    file = f"{ABS}build/src/esphome/core/shared.cpp"
+    entries = []
+    for name in ("a", "b"):
+        rsp = tmp_path / f"{name}.o.rsp"
+        rsp.write_text(f"-I{ABS}inc/{name}")
+        entries.append(
+            {
+                "directory": str(tmp_path),
+                "file": file,
+                "command": f"/tools/g++ @{rsp.name} -c {file} -o {name}.o",
+                "output": f"{name}.o",
+            }
+        )
+    compile_commands = tmp_path / "compile_commands.json"
+    compile_commands.write_text(json.dumps(entries))
+    with patch.object(idedata, "get_toolchain_includes", return_value=[]):
+        data = idedata.idedata_from_build(compile_commands)
+    joined = " ".join(data["includes"]["build"])
+    assert "inc/a" in joined and "inc/b" in joined
+
+
 def test_load_or_build_idedata_cache_hit_skips_rebuild(tmp_path: Path) -> None:
     """A valid cache newer than the compile DB is served without re-parsing."""
     compile_commands = _write_compile_commands(tmp_path)
     cache = tmp_path / "c.json"
-    cache.write_text(json.dumps({"cc_path": "/tools/gcc", "cached": True}))
+    cache.write_text(
+        json.dumps(
+            {
+                "cc_path": "/tools/gcc",
+                "cxx_path": "/tools/g++",
+                "includes": {"build": ["/inc"], "toolchain": []},
+                "cached": True,
+            }
+        )
+    )
     os.utime(cache, (compile_commands.stat().st_mtime + 5,) * 2)
     with patch.object(idedata, "idedata_from_build") as mock_build:
         data = idedata.load_or_build_idedata(

tests/unit_tests/test_size_summary.py

@@ -205,8 +205,19 @@ def test_print_summary_non_dict_json_warns(tmp_path, caplog) -> None:
 
 
 def test_print_summary_zero_app_partition_warns(tmp_path, caplog) -> None:
-    """A malformed partition row parsing to 0 must not render a 0% bar for
-    CI's memory-impact extraction to ingest."""
+    """A partition row with size 0 drops the Flash bar instead of rendering 0%."""
+    size_json = tmp_path / "size.json"
+    size_json.write_text(
+        '{"memory_types": {"DRAM": {"used": 1, "size": 2}}, "image_size": 100}'
+    )
+    partitions = tmp_path / "partitions.csv"
+    partitions.write_text("app0, app, ota_0, 0x10000, 0,\n")
+    print_summary(size_json, partitions)
+    assert "app partition size is" in caplog.text
+
+
+def test_print_summary_blank_partition_size_warns(tmp_path, caplog) -> None:
+    """A blank size cell raises ValueError by name instead of parsing to 0."""
     size_json = tmp_path / "size.json"
     size_json.write_text(
         '{"memory_types": {"DRAM": {"used": 1, "size": 2}}, "image_size": 100}'
@@ -214,4 +225,21 @@ def test_print_summary_zero_app_partition_warns(tmp_path, caplog) -> None:
     partitions = tmp_path / "partitions.csv"
     partitions.write_text("app0, app, ota_0, 0x10000, ,\n")
     print_summary(size_json, partitions)
-    assert "app partition size is" in caplog.text
+    assert "blank partition size cell" in caplog.text
+
+
+@pytest.mark.parametrize(
+    "payload",
+    (
+        '{"memory_types": []}',
+        '{"memory_types": {"DRAM": 5}}',
+        '{"memory_types": {"DRAM": {"used": "x", "size": "y"}}}',
+    ),
+    ids=("non-dict-memory-types", "scalar-region", "non-numeric-sizes"),
+)
+def test_print_summary_nested_shapes_never_raise(tmp_path, caplog, payload) -> None:
+    """The blanket guard keeps unexpected nested shapes from raising."""
+    size_json = tmp_path / "size.json"
+    size_json.write_text(payload)
+    print_summary(size_json, tmp_path / "partitions.csv")
+    assert "Skipping size summary" in caplog.text