# Evidence manifest

What counts as proof. "It should work" is not on this list.

## Levels of evidence, weakest to strongest

1. **Compiles** — `cargo check -p <crate>`. Necessary, never sufficient. Makepad resolves the splash DSL at runtime, so a widget or style error survives `cargo check` and appears on launch.
2. **Unit-tested** — `cargo test -p <crate>` for a Cx-free crate. Strong for rules: physics, generation, scoring, netcode, merge.
3. **Driven** — a `makepad-test` test that launches the real app, sends real input, and asserts on `widget_snapshot()` or a log line.
4. **Seen** — a `screenshot()` from that run, inspected by you, at the actual target aspect ratio.
5. **Measured** — frame time, draw calls, instance bytes, entity counts, against `apps/arcade/BUDGETS.md`.
6. **Shipped** — `--release` build succeeds and runs.

## Required by change size

| Change | Required |
| --- | --- |
| Constant, copy, colour | 1 |
| Rule change in a Cx-free crate | 1, 2 |
| New mechanic | 1, 2, 3 |
| Visual or UI change | 1, 3, 4 |
| Performance work | 1, 5 (before *and* after) |
| Full game or premium pass | all six, plus the scorecard |

## Capturing each

**Unit test** — the Cx-free crates are the point of the architecture:

```bash
cargo test -p makepad-game-sim
cargo test -p makepad-game-gen
cargo test -p makepad-game-blocks
```

**Driven test** — `makepad-test` gives `TestApp` with `type_text`, `press_key`, `touch_down`, `screenshot`, `widget_dump`, `widget_snapshot`, `wait_for_log_contains`:

```rust
use makepad_test::{makepad_test, TestApp, KeyCode};

#[makepad_test]
fn player_scores_on_pickup(app: TestApp) {
    app.wait_for_log_contains("game: ready");
    app.press_key(KeyCode::ArrowUp);
    app.wait_for_log_contains("score: 1");
    let shot = app.screenshot();
    println!("evidence: {}", shot.display());
}
```

**Headless probe** — for render and perf claims without a window:

```bash
cargo run -p makepad-arcade --example bigworld_probe --release
```

**Measurement** — read from the renderer, do not estimate:

```rust
renderer.frame_p90_ms();      // Option<f32>
renderer.quality_level();     // adaptive quality actually applied
renderer.quality_reason();    // why it dropped
```

`RenderStats::instance_floats` is the authority on instance stream width — the BUDGETS numbers were taken from the compiled shader, not counted by hand. Do the same.

**Asset resolution** — prove the scene is not silently on primitives:

```rust
assert!(renderer.model_is_loaded("kenney/racing/vehicle-truck-yellow"));
```

## Screenshot discipline

- Capture at the target aspect ratio, not the default window.
- Capture the states that exist: menu, playing, paused, win, lose. A premium claim with only one screenshot is unverified.
- Look at them. An agent that captures a screenshot and does not describe what is in it has produced a file, not evidence.
- Name them for what they show: `artifacts/shots/playing-desert-1920x1080.png`.

## Reporting

Keep detailed evidence and the scorecard in `artifacts/`. Keep the final answer focused on what works and what the remaining risks are. State plainly what you could not run and why — an unrun check reported as passing is the one failure mode that destroys trust in everything else in the report.