Fusion du lot F : objections redit / contredit, coquilles validées par leur auteur, messagerie, délai de 3 jours

Conflits avec B2 : docs.rs garde shown_tally / shown_evaluation et votable ;
proposals.rs sert les totaux montrés et « votable » ; CONTROLES réunit C24
(« faire une objection », le panier par son adresse), C28–C33 et les deux passages.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

crates/ld-server/src/docs.rs

@@ -72,6 +72,12 @@ pub async fn require_open(state: &AppState, user: &IdentityRow, group: &GroupRow
     Ok(())
 }
 
+/// Does this identity open the group now (see `trustin_access::opens`)?
+pub async fn opens(state: &AppState, user: &IdentityRow, group: &GroupRow) -> AppResult<bool> {
+    let has = granted(state, &group.slug, &user.id).await?;
+    Ok(trustin_access::opens(&user.to_identity(), &group.to_group(), has))
+}
+
 /// May this identity vote in the group (see `trustin_access::votes_in`)?
 pub async fn may_vote(state: &AppState, user: &IdentityRow, group: &GroupRow) -> AppResult<bool> {
     let has = granted(state, &group.slug, &user.id).await?;
@@ -253,7 +259,9 @@ pub struct DocState {
     pub units: Vec<UnitRow>,
     pub proposals: Vec<ProposalRow>,
     pub tallies: HashMap<String, Tally>,
+    /// Versions held back by a standing objection: not votable, never entering into force.
     pub blocked: HashSet<String>,
+    /// Standing objections touching each version, either side.
     pub signal_counts: HashMap<String, i64>,
     pub electorate: u32,
     pub electorate_source: &'static str,
@@ -331,32 +339,9 @@ pub async fn load_state(state: &AppState, doc_id: &str) -> AppResult<DocState> {
         }
     }
 
-    #[derive(sqlx::FromRow)]
-    struct SignalRow {
-        proposal_id: String,
-        target_proposal_id: String,
-    }
-    let signals = sqlx::query_as::<_, SignalRow>(
-        "SELECT s.proposal_id, s.target_proposal_id FROM signals s JOIN proposals p ON p.id = s.proposal_id
-         JOIN units u ON u.id = p.unit_id WHERE u.doc_id = ? AND s.lifted_at IS NULL",
-    )
-    .bind(doc_id)
-    .fetch_all(&state.db)
-    .await?;
-    let in_force: HashSet<&str> = units.iter().filter_map(|u| u.in_force_id.as_deref()).collect();
-    let mut blocked = HashSet::new();
-    let mut signal_counts: HashMap<String, i64> = HashMap::new();
-    for s in &signals {
-        *signal_counts.entry(s.proposal_id.clone()).or_default() += 1;
-        *signal_counts.entry(s.target_proposal_id.clone()).or_default() += 1;
-        // Two texts that contradict each other never stand in force together.
-        if in_force.contains(s.target_proposal_id.as_str()) {
-            blocked.insert(s.proposal_id.clone());
-        }
-        if in_force.contains(s.proposal_id.as_str()) {
-            blocked.insert(s.target_proposal_id.clone());
-        }
-    }
+    // A standing objection holds back the latest arrival of its pair (never a version
+    // in force): not votable, and it cannot enter into force (ADR 0010).
+    let (blocked, signal_counts) = crate::objections::held(state, doc_id, &units).await?;
     let (electorate, electorate_source) = electorate(state, &group).await?;
     let measure = participation::stored(state, &group.slug).await?;
     let participation = Participation::of(
@@ -410,6 +395,11 @@ impl DocState {
         self.scale().evaluate(self.shown_tally(&p.id), self.voting_level(unit, p)).ok()
     }
 
+    /// Open to a vote: open or in force, and not held back by an objection.
+    pub fn votable(&self, p: &ProposalRow) -> bool {
+        matches!(p.status.as_str(), "open" | "in_force") && !self.blocked.contains(&p.id)
+    }
+
     pub fn unit_states(&self) -> Vec<UnitState> {
         let by_id: HashMap<&str, &ProposalRow> = self.proposals.iter().map(|p| (p.id.as_str(), p)).collect();
         self.units
@@ -560,7 +550,8 @@ fn proposal_json(
         "evaluation": eval,
         "votedAtInertia": voted_at,
         "blocked": st.blocked.contains(&p.id),
-        "signals": st.signal_counts.get(&p.id).copied().unwrap_or(0),
+        "votable": st.votable(p),
+        "objections": st.signal_counts.get(&p.id).copied().unwrap_or(0),
         "myVote": mine.map(|v| v.choice.as_str()),
         "myVoteStale": mine.is_some_and(|v| v.revision != p.revision),
         "myVoteChain": mine.is_some_and(|v| v.source == "chain"),