chore(desktop): add a packaged startup benchmark - #49758

The devex benchmark measures bun dev:desktop to Home. Nothing measured what users launch: a packaged build restoring its tabs against an already-running service. This adds bun run bench:startup.

flowchart LR
  A["packaged exe<br/>(dist/win-unpacked)"] --> B["isolated home<br/>%APPDATA%, XDG, DB, config, service registration<br/>OPENCODE_* / OTEL_* stripped"]
  B --> C["warm service (bundled CLI, once)<br/>or cold: spawned per launch"]
  C --> D["N launches, interleaved A/B with --compare<br/>1 warm-up launch discarded"]
  D --> E["milestones since spawn:<br/>process created · Node start · Node bootstrapped · app starting<br/>service ready · renderer process · window visible · first paint · shell · idle"]
  D -. --profile-main .-> F["main CPU profile from first statement"]
  D -. --profile-renderer .-> G["renderer main-thread CPU profile"]
  D -. --trace .-> H["Chromium --trace-startup"]

What it isolates. Own %APPDATA%/XDG/DB/config/service registration (the desktop deletes XDG_STATE_HOME on Windows, so isolation goes through the home directory), the developer's OPENCODE_*/OTEL_* environment stripped (an inherited OTLP endpoint added a Sentry round trip to every CLI exit inside the measured app), a private service port for cold mode, and it only ever kills the process tree it spawned (a prod-channel build shares its executable name with the installed app).

What it measures. Main-log milestones, renderer paint timing and DOM readiness over CDP, renderer idle (first 500 ms window under 10 % main-thread task time that stays quiet for --settle-ms) and total renderer task time. After each run it reads process.getCreationTime() and performance.nodeTiming from the main process over --inspect (nothing attaches until the run is over), which splits the time before our first log line into Electron native init, Node bootstrap, and Electron JS init + our bundle — so a fat main bundle can't hide inside a "Chromium boot" number.

Per-run detail (in every sample of the JSON report): the merged main-process log timeline — main plus the scoped crash/onboarding/window/renderer logs as [ms, file, message] — the renderer's main-thread breakdown (script, layout, style, counts, DOM nodes, JS heap), navigation/resource/paint timing and any performance.marks, the working set of every process in the app's tree once idle, and the main process's CPU time. The summary adds median phase durations between consecutive checkpoints:

electron native init                55
node bootstrap                      18
electron js init + main bundle     412
main layers → window created       131
renderer boot → first paint        524
first paint → shell                113
shell → idle                        68

memory once idle — total 518 MB · main cpu 1468 ms · renderer heap 17 MB, 1318 nodes, layout 41 ms/11×, style 53 ms/87×
main 154 · gpu-process 106 · utility 54 · crashpad-handler 46 · renderer 141 · ssh.exe 10 · conhost.exe 7
```n
**Modes.** `--service warm|cold`, `--fresh` (profile wiped per launch: first launch after install), `--compare <exe>` (alternating launches so drift hits both builds equally), `--warmup N` (discarded launches; the first launch of a new binary pays the antivirus scan), `--offline` (implicit for beta/prod), `--seed <userData>` (restore real tabs/drafts), `--profile-main`, `--profile-renderer`, `--trace`.

Sample, packaged `v2` build vs the startup PR set, same machine, interleaved, warm service, median of 4 (ms since spawn):

| milestone | v2 | startup PRs |
|---|---|---|
| process created | 9 | 9 |
| Node starts (Electron native init done) | 49 | 51 |
| Node bootstrap complete | 63 | 63 |
| first main-process log line | 610 | 394 |
| service ready | 875 | 588 |
| renderer process | 920 | 511 |
| window visible | 1,273 | 786 |
| first paint | 1,440 | 959 |
| shell visible | 1,496 | 1,067 |
| renderer idle | 1,550 | 1,127 |
| renderer main-thread task time | 595 | 549 |

(This run was taken on a loaded machine; the interleaving is what makes the comparison valid.)