Port the synchronous event serialization core to Rust

Move the synchronous core of client event serialization out of
`synapse/events/utils.py` and into `rust/src/events/serialize.rs`. The
Python `EventClientSerializer` now performs all DB/IO (fetching
redactions, running module callbacks, resolving admin/MSC4354 config) up
front in `_prepare_serialization`, then hands the pre-fetched data to the
Rust `serialize_event`, which recurses entirely in Rust. Bundled
aggregations are read directly from the Rust `BundledAggregations`
pyclass.

`SerializeEventConfig` and the `event_format` callable become a Rust
pyclass and the `EventFormat` enum respectively; call sites are updated
to pass the enum.

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

Author: erikjohnston

rust/src/duration.rs

@@ -40,6 +40,11 @@ impl SynapseDuration {
         Self { milliseconds }
     }
 
+    /// Returns the duration as a number of milliseconds.
+    pub const fn as_millis(&self) -> u64 {
+        self.milliseconds
+    }
+
     /// Creates a `SynapseDuration` from a number of hours.
     pub const fn from_hours(hours: u32) -> Self {
         // We take a u32 here so that we know the multiplication won't overflow.

rust/src/events/constants.rs

@@ -74,6 +74,36 @@ pub mod unsigned_field {
     pub const AGE_TS: &str = "age_ts";
     /// Unsigned field: redacted_because
     pub const REDACTED_BECAUSE: &str = "redacted_because";
+    /// Unsigned field: redacted_by
+    pub const REDACTED_BY: &str = "redacted_by";
+    /// Unsigned field: transaction_id
+    pub const TRANSACTION_ID: &str = "transaction_id";
+    /// Unsigned field: org.matrix.msc4140.delay_id
+    pub const DELAY_ID: &str = "org.matrix.msc4140.delay_id";
+    /// Unsigned field: membership (MSC4115)
+    pub const MEMBERSHIP: &str = "membership";
+    /// Unsigned field: msc4354_sticky_duration_ttl_ms (MSC4354)
+    pub const STICKY_TTL: &str = "msc4354_sticky_duration_ttl_ms";
+    /// Unsigned field: io.element.synapse.soft_failed (admin metadata)
+    pub const SOFT_FAILED: &str = "io.element.synapse.soft_failed";
+    /// Unsigned field: io.element.synapse.policy_server_spammy (admin metadata)
+    pub const POLICY_SERVER_SPAMMY: &str = "io.element.synapse.policy_server_spammy";
+    /// Unsigned field: invite_room_state
+    pub const INVITE_ROOM_STATE: &str = "invite_room_state";
+    /// Unsigned field: knock_room_state
+    pub const KNOCK_ROOM_STATE: &str = "knock_room_state";
+    /// Unsigned field: m.relations
+    pub const M_RELATIONS: &str = "m.relations";
+}
+
+/// Relation types (the `rel_type` of an `m.relates_to`).
+pub mod relation_type {
+    /// Relation type: m.reference
+    pub const REFERENCE: &str = "m.reference";
+    /// Relation type: m.replace
+    pub const REPLACE: &str = "m.replace";
+    /// Relation type: m.thread
+    pub const THREAD: &str = "m.thread";
 }
 
 /// Membership Event Fields

rust/src/events/internal_metadata.rs

@@ -498,6 +498,41 @@ impl EventInternalMetadata {
             .write()
             .map_err(|_| PyRuntimeError::new_err("EventInternalMetadata lock poisoned"))
     }
+
+    /// The event ID of the redaction event, if this event has been redacted.
+    pub fn redacted_by(&self) -> PyResult<Option<String>> {
+        Ok(self.read_inner()?.redacted_by.clone())
+    }
+
+    /// The transaction ID, if set when the event was created.
+    pub fn txn_id(&self) -> PyResult<Option<String>> {
+        Ok(self.read_inner()?.get_txn_id().map(|s| s.to_owned()))
+    }
+
+    /// The device ID of the sender, if set.
+    pub fn device_id(&self) -> PyResult<Option<String>> {
+        Ok(self.read_inner()?.get_device_id().map(|s| s.to_owned()))
+    }
+
+    /// The access token ID of the sender, if set.
+    pub fn token_id(&self) -> PyResult<Option<i64>> {
+        Ok(self.read_inner()?.get_token_id())
+    }
+
+    /// The delay ID, set only if the event was a delayed event.
+    pub fn delay_id(&self) -> PyResult<Option<String>> {
+        Ok(self.read_inner()?.get_delay_id().map(|s| s.to_owned()))
+    }
+
+    /// Whether the event has been soft failed.
+    pub fn soft_failed(&self) -> PyResult<bool> {
+        Ok(self.read_inner()?.is_soft_failed())
+    }
+
+    /// Whether the policy server marked this event as spammy.
+    pub fn policy_server_spammy(&self) -> PyResult<bool> {
+        Ok(self.read_inner()?.get_policy_server_spammy())
+    }
 }
 
 /// Helper to convert `None` to an `AttributeError` for a property getter.

rust/src/events/mod.rs

@@ -88,6 +88,7 @@ pub mod formats;
 pub mod internal_metadata;
 pub mod json_object;
 pub mod relations;
+pub mod serialize;
 pub mod signatures;
 pub mod unsigned;
 pub mod utils;
@@ -110,9 +111,12 @@ pub fn register_module(py: Python<'_>, m: &Bound<'_, PyModule>) -> PyResult<()>
     child_module.add_class::<Event>()?;
     child_module.add_class::<relations::BundledAggregations>()?;
     child_module.add_class::<relations::ThreadAggregation>()?;
+    child_module.add_class::<serialize::EventFormat>()?;
+    child_module.add_class::<serialize::SerializeEventConfig>()?;
     child_module.add_function(wrap_pyfunction!(filter::event_visible_to_server_py, m)?)?;
     child_module.add_function(wrap_pyfunction!(redact_event_py, m)?)?;
     child_module.add_function(wrap_pyfunction!(redact_event_dict, m)?)?;
+    child_module.add_function(wrap_pyfunction!(serialize::serialize_events, m)?)?;
 
     m.add_submodule(&child_module)?;