[types] use Did for did's in event types

src/backfill/mod.rs

···
 use crate::types::{AccountEvt, BroadcastEvent, RepoState, RepoStatus, ResyncState, StoredEvent};
 use futures::TryFutureExt;
 use jacquard::api::com_atproto::sync::get_repo::{GetRepo, GetRepoError};
-use jacquard::prelude::*;
 use jacquard::types::did::Did;
+use jacquard::{prelude::*, IntoStatic};
 use jacquard_common::xrpc::XrpcError;
 use jacquard_repo::mst::Mst;
 use jacquard_repo::MemoryBlockStore;
···
 
         let emit_identity = |status: &RepoStatus| {
             let evt = AccountEvt {
-                did: did.as_str().into(),
+                did: did.clone(),
                 active: !matches!(
                     status,
                     RepoStatus::Deactivated | RepoStatus::Takendown | RepoStatus::Suspended
···
                                 app_state.db.next_event_id.fetch_add(1, Ordering::SeqCst);
                             let evt = StoredEvent::Record {
                                 live: false,
-                                did: did.as_str().into(),
+                                did: did.clone().into_static(),
                                 rev: rev.as_str().into(),
                                 collection: collection.into(),
                                 rkey: rkey.into(),

src/buffer/processor.rs

···
         let mut to_remove: Vec<Did<'static>> = Vec::new();
 
         loop {
-            // receive new messages (non-blocking drain)
             while let Ok(msg) = self.rx.try_recv() {
                 queues.entry(msg.did.clone()).or_default().push_back(msg);
             }
 
-            // process unblocked DIDs
             for (did, queue) in &mut queues {
                 if self.state.blocked_dids.contains_sync(did) {
                     continue;
···
                 debug!("processing buffered identity for {did}");
                 let handle = identity.handle.as_ref().map(|h| h.as_str().to_smolstr());
                 let evt = IdentityEvt {
-                    did: did.to_smolstr(),
+                    did: did.clone(),
                     handle,
                 };
                 ops::emit_identity_event(&self.state.db, evt);
···
             SubscribeReposMessage::Account(account) => {
                 debug!("processing buffered account for {did}");
                 let evt = AccountEvt {
-                    did: did.to_smolstr(),
+                    did: did.clone(),
                     active: account.active,
                     status: account.status.as_ref().map(|s| s.to_smolstr()),
                 };
                 ops::emit_account_event(&self.state.db, evt);
 
+                let did = did.clone();
                 let state = self.state.clone();
-                let did = did.clone();
-                let account = account.clone(); // Account is 'static in BufferedMessage
+                let account = account.clone();
 
                 tokio::task::spawn_blocking(move || -> Result<()> {
-                    // handle status updates
                     if !account.active {
                         use jacquard::api::com_atproto::sync::subscribe_repos::AccountStatus;
                         if let Some(status) = &account.status {
···
         .flatten()
     }
 
-    async fn remove_from_db_buffer(&self, did: &str, buffered_at: i64) -> Result<()> {
+    async fn remove_from_db_buffer(&self, did: &Did<'_>, buffered_at: i64) -> Result<()> {
         let key = keys::buffer_key(did, buffered_at);
         self.state.db.buffer.remove(key).into_diagnostic()?;
         Ok(())

src/db/keys.rs

···
 }
 
 // key format: {DID}\x00{timestamp} (for buffer entries)
-pub fn buffer_key(did: &str, timestamp: i64) -> Vec<u8> {
+pub fn buffer_key(did: &Did, timestamp: i64) -> Vec<u8> {
     let mut key = Vec::with_capacity(did.len() + 1 + 8);
-    key.extend_from_slice(did.as_bytes());
+    key.extend_from_slice(did_prefix(did).as_bytes());
     key.push(SEP);
     key.extend_from_slice(&timestamp.to_be_bytes());
     key

src/ingest/mod.rs

···
 use n0_future::StreamExt;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
+use std::time::Duration;
 use tracing::{debug, error, info};
 use url::Url;
 
···
                 Ok(s) => s,
                 Err(e) => {
                     error!("failed to connect to firehose: {e}, retrying in 5s...");
-                    tokio::time::sleep(std::time::Duration::from_secs(5)).await;
+                    tokio::time::sleep(Duration::from_secs(5)).await;
                     continue;
                 }
             };
···
             }
 
             error!("firehose disconnected, reconnecting in 5s...");
-            tokio::time::sleep(std::time::Duration::from_secs(5)).await;
+            tokio::time::sleep(Duration::from_secs(5)).await;
         }
     }
 

src/ops.rs

···
 use crate::types::{AccountEvt, BroadcastEvent, IdentityEvt, MarshallableEvt, StoredEvent};
 use jacquard::api::com_atproto::sync::subscribe_repos::Commit;
 use jacquard::cowstr::ToCowStr;
+use jacquard::IntoStatic;
 use jacquard_repo::car::reader::parse_car_bytes;
 use miette::{IntoDiagnostic, Result};
 use smol_str::{SmolStr, ToSmolStr};
···
 
 // emitting identity is ephemeral
 // we dont replay these, consumers can just fetch identity themselves if they need it
-pub fn emit_identity_event(db: &Db, evt: IdentityEvt) {
+pub fn emit_identity_event(db: &Db, evt: IdentityEvt<'static>) {
     let event_id = db.next_event_id.fetch_add(1, Ordering::SeqCst);
     let marshallable = MarshallableEvt {
         id: event_id,
···
     let _ = db.event_tx.send(BroadcastEvent::Ephemeral(marshallable));
 }
 
-pub fn emit_account_event(db: &Db, evt: AccountEvt) {
+pub fn emit_account_event(db: &Db, evt: AccountEvt<'static>) {
     let event_id = db.next_event_id.fetch_add(1, Ordering::SeqCst);
     let marshallable = MarshallableEvt {
         id: event_id,
···
 
         let evt = StoredEvent::Record {
             live,
-            did: did.as_str().into(),
+            did: did.clone().into_static(),
             rev: commit.rev.as_str().into(),
             collection: collection.into(),
             rkey: rkey.into(),

src/types.rs

···
 // from src/api/event.rs
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
-pub struct MarshallableEvt {
+pub struct MarshallableEvt<'i> {
     pub id: u64,
     #[serde(rename = "type")]
     pub event_type: SmolStr,
+    #[serde(borrow)]
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub record: Option<RecordEvt>,
+    pub record: Option<RecordEvt<'i>>,
+    #[serde(borrow)]
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub identity: Option<IdentityEvt>,
+    pub identity: Option<IdentityEvt<'i>>,
+    #[serde(borrow)]
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub account: Option<AccountEvt>,
+    pub account: Option<AccountEvt<'i>>,
 }
 
 #[derive(Clone, Debug)]
 pub enum BroadcastEvent {
     Persisted(u64),
-    Ephemeral(MarshallableEvt),
+    Ephemeral(MarshallableEvt<'static>),
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
-pub struct RecordEvt {
+pub struct RecordEvt<'i> {
     pub live: bool,
-    pub did: SmolStr,
+    #[serde(borrow)]
+    pub did: Did<'i>,
     pub rev: SmolStr,
     pub collection: SmolStr,
     pub rkey: SmolStr,
···
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
-pub struct IdentityEvt {
-    pub did: SmolStr,
+pub struct IdentityEvt<'i> {
+    #[serde(borrow)]
+    pub did: Did<'i>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub handle: Option<SmolStr>,
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
-pub struct AccountEvt {
-    pub did: SmolStr,
+pub struct AccountEvt<'i> {
+    #[serde(borrow)]
+    pub did: Did<'i>,
     pub active: bool,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub status: Option<SmolStr>,
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
-pub enum StoredEvent {
+pub enum StoredEvent<'i> {
     Record {
         live: bool,
-        did: SmolStr,
+        #[serde(borrow)]
+        did: Did<'i>,
         rev: SmolStr,
         collection: SmolStr,
         rkey: SmolStr,
         action: SmolStr,
         cid: Option<SmolStr>,
     },
-    Identity(IdentityEvt),
-    Account(AccountEvt),
+    #[serde(borrow)]
+    Identity(IdentityEvt<'i>),
+    #[serde(borrow)]
+    Account(AccountEvt<'i>),
 }