@@ -59,3 +59,14 @@ class CoverageFailureTestCase:
     expected_exit_code: int
     expected_lines: tuple[str, ...]
     expected_absent: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class RenderCaptureTestCase:
+    """A generated project with every feature block and the render kinds its capture proves."""
+
+    description: str
+    seed: int
+    blocks: tuple[str, ...]
+    command: tuple[str, ...]
+    expected_kinds: frozenset[str]
@@ -49,6 +49,27 @@ def _perturbed(*, until, **stages):
     return dataclasses.replace(result, model_files=tuple(reversed(result.model_files)))
 
 
+frontier.native_frontier = _perturbed
+"""
+
+RENDER_PERTURBATION: str = """
+import dataclasses
+
+import sqlbuild.compiler.frontier.main._compile_frontier as frontier
+from sqlbuild.compiler.frontier.types import CompilerStage
+
+_original = frontier.native_frontier
+
+
+def _perturbed(*, until, **stages):
+    result = _original(until=until, **stages)
+    if until is not CompilerStage.COMPILE_PROJECT_INPUTS or not result.model_inputs:
+        return result
+    first = result.model_inputs[0]
+    changed = dataclasses.replace(first, macro_deps=(*first.macro_deps, "perturbed_by_test"))
+    return dataclasses.replace(result, model_inputs=(changed, *result.model_inputs[1:]))
+
+
 frontier.native_frontier = _perturbed
 """
 
 
@@ -16,6 +16,7 @@
 from tests.e2e.scripts.compiler_differential.helpers import (
     DISCOVERY_PERTURBATION,
     NATIVE_ONLY_STDERR_LINE,
+    RENDER_PERTURBATION,
     harness_arguments,
     perturbation_arguments,
     write_broken_ref_project,
@@ -129,6 +130,42 @@ def test_given_perturbed_native_discovery_when_comparing_then_discovery_capture_
     assert all(re.search(pattern, output) for pattern in test_case.expected_patterns), output
 
 
+@pytest.mark.parametrize(
+    "test_case",
+    [
+        HarnessRunTestCase(
+            description="perturbed_native_compile_inputs",
+            extra_arguments=(),
+            expected_exit_code=1,
+            expected_lines=("DIFF project/waffle_shop",),
+            expected_patterns=(
+                r"- stage capture 0-compile/002-compile_project_inputs\.json at "
+                r"/model_inputs/0/macro_deps/",
+                r"- stage capture 2-plan/002-compile_project_inputs\.json at "
+                r"/model_inputs/0/macro_deps/",
+            ),
+            expected_absent=("001-discovered_project_inputs.json",),
+        )
+    ],
+    ids=lambda case: case.description,
+)
+def test_given_perturbed_native_render_when_comparing_then_compile_inputs_capture_names_the_stage(
+    test_case: HarnessRunTestCase, tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    exit_code: int = run_compiler_differential(
+        harness_arguments(
+            work_dir=tmp_path / "work",
+            extra=perturbation_arguments(tmp_path / "perturbation", source=RENDER_PERTURBATION),
+        )
+    )
+
+    output: str = capsys.readouterr().out
+    assert exit_code == test_case.expected_exit_code, output
+    assert all(line in output for line in test_case.expected_lines), output
+    assert all(re.search(pattern, output) for pattern in test_case.expected_patterns), output
+    assert not any(text in output for text in test_case.expected_absent), output
+
+
 @pytest.mark.parametrize(
     "test_case",
     [
 
@@ -0,0 +1,68 @@
+"""A real plan captures every compile-input field canonically and proves every render kind."""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+from scripts.compiler_differential._helpers.coverage.render import (
+    render_capture_problems,
+    rendered_input_kinds,
+    required_render_kinds,
+)
+from scripts.compiler_differential._helpers.running.execution import harness_environment
+from scripts.compiler_differential.constants import (
+    GENERATOR_FEATURE_BLOCKS,
+    RENDER_STAGE_CAPTURE_SUFFIX,
+    SQB_ENTRY,
+    STAGE_CAPTURE_ENV_VAR,
+)
+from scripts.compiler_differential.main.generate_project import generate_project
+from tests.e2e.scripts.compiler_differential._test_types import RenderCaptureTestCase
+
+
+@pytest.mark.parametrize(
+    "test_case",
+    [
+        RenderCaptureTestCase(
+            description="every_feature_block_planned",
+            seed=11,
+            blocks=GENERATOR_FEATURE_BLOCKS,
+            command=("plan", "--json"),
+            expected_kinds=frozenset(required_render_kinds()),
+        )
+    ],
+    ids=lambda case: case.description,
+)
+def test_given_project_with_every_render_input_when_capturing_then_capture_is_complete(
+    test_case: RenderCaptureTestCase, tmp_path: Path
+) -> None:
+    project_dir: Path = tmp_path / "project"
+    capture_dir: Path = tmp_path / "captures"
+    generate_project(seed=test_case.seed, blocks=test_case.blocks).write(project_dir)
+
+    completed: subprocess.CompletedProcess[str] = subprocess.run(
+        [sys.executable, "-c", SQB_ENTRY, "--no-color", *test_case.command],
+        cwd=project_dir,
+        env={**harness_environment(), STAGE_CAPTURE_ENV_VAR: str(capture_dir)},
+        capture_output=True,
+        text=True,
+        check=False,
+        timeout=600,
+    )
+
+    assert completed.returncode == 0, completed.stdout + completed.stderr
+    text: str = next(capture_dir.glob(f"*{RENDER_STAGE_CAPTURE_SUFFIX}")).read_text(
+        encoding="utf-8"
+    )
+    assert render_capture_problems(text) == ()
+    assert test_case.expected_kinds <= rendered_input_kinds(text), (
+        test_case.expected_kinds - rendered_input_kinds(text)
+    )
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-vv"])