Proposal lists without rendering every diff; each file's lines computed once 3571c519ada6

## Unreleased

## 0.6.0 (2026-10-20)

- **An event bus between the hub's processes (#273):** on PostgreSQL, what one process publishes (a push, a check, a run's jobs, a comment, a waiting webhook delivery, a choice in the conflict resolver) reaches every other process over `LISTEN/NOTIFY`, so live pages on any web process see a push made through another, and a separate worker delivers a push's webhooks at once instead of on its once-a-minute pass. Nothing to configure; on SQLite the bus stays in process. Events say "look now" and are delivered at most once; a process that loses its listening connection listens again on a new one and logs that events may have been missed. A live page that reconnects with an event id its process never gave (another web process's, or one from before a restart) is now told to reload instead of waiting for newer ids. In the conflict resolver, choices and landings cross processes; who is present stays per process. See docs/roles.md.

        .map(|p| {

            let (app, repo, owner, name, id) = (app.clone(), repo.clone(), owner.clone(), name.clone(), row.id);

            async move {

                let v = crate::web::proposals::verdict(&app, &loaded, id).await?;

                Ok(crate::web::proposals::to_api(&app, &owner, &name, &loaded, &v, None).await)

            }

        Some(id) => db::repos::get_by_id(&app.db, id).await?.map(|r| format!("{}/{}", app.config.base_url(), r.slug())),

        None => None,

    };

    let v = crate::web::proposals::verdict(&app, &loaded, row.id).await?;

    Ok(Json(crate::web::proposals::to_api(&app, &owner, &name, &loaded, &v, source_url).await))

}

        Some(id) => db::repos::get_by_id(&app.db, id).await?.map(|r| format!("{}/{}", app.config.base_url(), r.slug())),

        None => None,

    };

    let v = crate::web::proposals::verdict(&app, &loaded, row.id).await?;

    Ok(Json(crate::web::proposals::to_api(&app, &owner, &name, &loaded, &v, source_url).await))

}

    let c = caller(&app, &headers).await?;

    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;

    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;

    let heads = match side.as_str() {

        "base" => loaded.target_heads,

        "head" => loaded.heads,

        crate::web::proposals::open_proposal(&app, &repo, &row, &me, &body.title, &body.body, &body.target, &body.source, body.draft)

            .await

            .map_err(|e| ApiError(StatusCode::BAD_REQUEST, e))?;

    let v = crate::web::proposals::verdict(&app, &loaded, row.id).await?;

    Ok((StatusCode::CREATED, Json(crate::web::proposals::to_api(&app, &owner, &name, &loaded, &v, None).await)))

}

    let paths: std::collections::BTreeSet<String> = out.iter().filter(|c| c.anchor.is_some()).filter_map(|c| c.path.clone()).collect();

    if !paths.is_empty() {

        let repo = RepoName::new(&owner, &name).ok_or_else(|| not_found("no such repository"))?;

        let lines = app

            .repos

            .read(&repo, move |r, _| {

    let c = caller(&app, &headers).await?;

    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;

    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;

    let v = crate::web::proposals::verdict(&app, &loaded, row.id).await?;

    Ok(Json(

        v.reviews

    let c = caller(&app, &headers).await?;

    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;

    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;

    Ok(Json(db::hooks::checks_for_state(&app.db, row.id, &loaded.state).await?.iter().map(check_of).collect()))

}

    }

    let Some(repo) = RepoName::new(&row.owner, &row.name) else { return };

    let number = p.number;

    let required = db::hooks::required_checks(&app.db, row.id).await.unwrap_or_default();

    let checks = db::hooks::checks_for_state(&app.db, row.id, &loaded.state).await.unwrap_or_default();

    let failed: Vec<&str> = required

    lines.get(new_no.checked_sub(1)?).map(|((h, i), _)| (*h, *i))

}

/// The current line (1-based) of an atom in `path`, if it is still live.

pub fn line_of(loaded: &Loaded, path: &str, atom: (ChangeHash, u32)) -> Option<usize> {

    let f = loaded.snapshot.files.get(path)?;

/// Compute the projection and everything derived from it.

pub async fn load(app: &Shared, repo: &RepoName, row: pdb::ProposalRow) -> Result<Loaded, crate::repos::RepoError> {

    let fork_dir = match (row.source_kind.as_str(), row.source_repo_id) {

        ("fork", Some(id)) => {

            db::repos::get_by_id(&app.db, id).await.ok().flatten().and_then(|r| RepoName::new(&r.owner, &r.name)).map(|n| app.repos.dir(&n))

            };

            let p: Projection = pl::project(r, cache, &r2.target, source)?;

            let target_loaded = cache.load(r, &p.target_heads)?;

            let mut atoms = HashMap::new();

            for f in &files {

                for l in &f.lines {

                    }

                }

            }

    for p in open.into_iter().filter(|p| p.target == bookmark) {

        let id = p.id;

        let number = p.number;

            if l.row.state == "landed" && l.row.landed_by.is_empty() {

                pdb::set_landed(&app.db, id, &l.target_state, actor, "push").await.ok();

            } else if l.row.is_open() && !l.hashes.is_empty() && crate::flow::enabled(app, row) {