Method index_session_turn_candidate

atomic-core/src/pristine/txn/write/mod.rs:404–444

(
        &mut self,
        record: crate::change::session::SessionRecord,
        existing_turns: Vec<crate::change::session::SessionTurn>,
        mut candidate: crate::change::session::SessionTurn

    }

    fn index_session_turn_candidate(
        &mut self,
        record: crate::change::session::SessionRecord,
        existing_turns: Vec<crate::change::session::SessionTurn>,
        mut candidate: crate::change::session::SessionTurn,
    ) -> PristineResult<()> {
        use crate::change::session::canonicalize_session_turns;

        let current_schema = self.has_current_session_ledger_schema(&record.session_id)?;
        candidate.turn_number = existing_turns.len() as u32;

        // The common chained append cannot sort before an existing turn:
        // causality keeps it blocked until the current last turn is emitted.
        let chained_append = existing_turns.is_empty()
            || candidate.previous_provenance
                == existing_turns.last().map(|turn| turn.provenance_hash);
        if current_schema && chained_append {
            return self.append_session_turn(record, candidate, &existing_turns);
        }

        let mut all_turns = existing_turns.clone();
        all_turns.push(candidate);
        let canonical = canonicalize_session_turns(all_turns);

        // Independent roots may also sort at the end. Keep the append-only
        // write path when canonicalization leaves every prior row untouched.
        if current_schema
            && canonical.get(..existing_turns.len()) == Some(existing_turns.as_slice())
        {
            if let Some(last) = canonical.last() {
                if !existing_turns
                    .iter()
                    .any(|turn| turn.provenance_hash == last.provenance_hash)
                {
                    return self.append_session_turn(record, last.clone(), &existing_turns);
                }
            }
        }

        self.rewrite_session_turns(record, canonical)
    }

    /// Rewrite one session's derived index from its complete immutable turn
    /// set. This keeps local keys, manifest order, lifecycle pointers, and KG