Skip to main content

hyprstream_pds_service/
federation_intake.rs

1//! Read-only intake of foreign ATProto identities into an inventory read model.
2//!
3//! Resolution delegates to the hardened `did:plc` and `did:web` resolvers in
4//! `hyprstream-rpc`. This service adds method dispatch, a final subject-binding
5//! check, and the projection into a queryable inventory. The projection is
6//! deliberately non-authoritative: a federated identity is discoverable but
7//! never acquires a local hosted-account tenant.
8
9use std::collections::BTreeMap;
10use std::sync::Arc;
11
12use anyhow::{bail, ensure, Result};
13use async_trait::async_trait;
14use hyprstream_rpc::admission::DidDocResolve;
15use hyprstream_rpc::auth::mac::{SecurityContext, SecurityLabel};
16use hyprstream_rpc::auth::Claims;
17use hyprstream_rpc::identity::UNAUTHENTICATED_DID_SENTINEL;
18use parking_lot::RwLock;
19use serde::{Deserialize, Serialize};
20use serde_json::Value;
21use thiserror::Error;
22
23/// Leak-safe failure from a direct identity-directory read.
24///
25/// Wire adapters must map this to HTTP 404 (or the transport's equivalent),
26/// never 403. Missing objects and objects above the caller's clearance are
27/// intentionally indistinguishable.
28#[derive(Clone, Copy, Debug, Error, PartialEq, Eq)]
29pub enum IdentityDirectoryReadError {
30    /// The identity does not exist or is not visible to this caller.
31    #[error("identity not found")]
32    NotFound,
33}
34
35/// Resolver for the two foreign ATProto DID methods accepted by intake.
36///
37/// Each arm is an existing resolver implementation. In particular, the PLC arm
38/// remains read-only and retains its configured egress boundary, audit
39/// verification, cache, and response validation.
40pub struct FederatedDidResolver {
41    plc: Arc<dyn DidDocResolve>,
42    web: Arc<dyn DidDocResolve>,
43}
44
45impl FederatedDidResolver {
46    /// Compose the existing `did:plc` and `did:web` document resolvers.
47    pub fn new(plc: Arc<dyn DidDocResolve>, web: Arc<dyn DidDocResolve>) -> Self {
48        Self { plc, web }
49    }
50}
51
52/// Injectable document-resolution boundary for federation intake.
53#[async_trait]
54pub trait FederatedDidDocumentResolver: Send + Sync {
55    /// Resolve a supported foreign DID to its subject-bound document.
56    async fn resolve_federated_document(&self, did: &str) -> Result<Value>;
57}
58
59#[async_trait]
60impl FederatedDidDocumentResolver for FederatedDidResolver {
61    async fn resolve_federated_document(&self, did: &str) -> Result<Value> {
62        ensure_real_identity_did(did)?;
63        let resolver = if hyprstream_rpc::did_plc::is_did_plc(did) {
64            &self.plc
65        } else if did.starts_with("did:web:") {
66            &self.web
67        } else {
68            bail!("unsupported federated DID method: {did}");
69        };
70        let document = resolver.resolve_doc(did).await?;
71        ensure!(
72            document.get("id").and_then(Value::as_str) == Some(did),
73            "resolved DID document id does not match requested DID {did}"
74        );
75        Ok(document)
76    }
77}
78
79/// Authority class represented by one derived inventory entry.
80#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
81#[serde(rename_all = "lowercase")]
82pub enum InventoryKind {
83    /// A DID with an authority-resolved local hosted-account binding.
84    Local,
85    /// A real foreign DID discovered read-only.
86    Federated,
87    /// The immutable credential-absence floor, never emitted as a real host.
88    Unauthenticated,
89}
90
91/// Derived AppView projection. It is an index, never identity authority.
92///
93/// Live discovery data is intentionally absent. In particular, this type
94/// cannot carry a QUIC URL or certificate hash; callers obtain rotating reach
95/// through [`FederationIntake::resolve`] at connect time.
96#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
97#[serde(rename_all = "camelCase")]
98pub struct InventoryEntry {
99    did: String,
100    handle: Option<String>,
101    kind: InventoryKind,
102    tenant: Option<String>,
103    pds_endpoint: Option<String>,
104}
105
106impl InventoryEntry {
107    fn federated(did: String, document: &Value) -> Result<Self> {
108        Self::indexed_federated(
109            did,
110            extract_handle(document)?,
111            extract_pds_endpoint(document)?,
112        )
113    }
114
115    /// Build a local projection from an authority-owned hosted-account source.
116    ///
117    /// This constructor validates the invariant at the read-model boundary:
118    /// only a local entry may carry a tenant, and a local entry must carry one.
119    pub fn local(
120        did: impl Into<String>,
121        handle: Option<String>,
122        tenant: impl Into<String>,
123        pds_endpoint: Option<String>,
124    ) -> Result<Self> {
125        let entry = Self {
126            did: did.into(),
127            handle,
128            kind: InventoryKind::Local,
129            tenant: Some(tenant.into()),
130            pds_endpoint,
131        };
132        entry.validate()?;
133        Ok(entry)
134    }
135
136    /// Build a foreign projection from already-resolved federation intake.
137    pub fn indexed_federated(
138        did: impl Into<String>,
139        handle: Option<String>,
140        pds_endpoint: Option<String>,
141    ) -> Result<Self> {
142        let entry = Self {
143            did: did.into(),
144            handle,
145            kind: InventoryKind::Federated,
146            tenant: None,
147            pds_endpoint,
148        };
149        entry.validate()?;
150        Ok(entry)
151    }
152
153    /// Revalidate a projection before a derived store accepts it.
154    pub fn validate(&self) -> Result<()> {
155        ensure_real_identity_did(&self.did)?;
156        ensure!(!self.did.is_empty(), "inventory DID must not be empty");
157        ensure!(
158            self.handle.as_deref().is_none_or(|value| !value.is_empty()),
159            "inventory handle must not be empty"
160        );
161        ensure!(
162            self.pds_endpoint
163                .as_deref()
164                .is_none_or(|value| !value.is_empty()),
165            "inventory PDS endpoint must not be empty"
166        );
167        match self.kind {
168            InventoryKind::Local => ensure!(
169                self.tenant
170                    .as_deref()
171                    .is_some_and(|value| !value.is_empty()),
172                "local inventory entry requires an authority-resolved tenant"
173            ),
174            InventoryKind::Federated => ensure!(
175                self.tenant.is_none(),
176                "only a local inventory entry may carry a tenant"
177            ),
178            InventoryKind::Unauthenticated => {
179                bail!("the unauthenticated floor is not a listable inventory host")
180            }
181        }
182        Ok(())
183    }
184
185    /// The indexed DID.
186    pub fn did(&self) -> &str {
187        &self.did
188    }
189
190    /// Optional ATProto handle derived from `alsoKnownAs`.
191    pub fn handle(&self) -> Option<&str> {
192        self.handle.as_deref()
193    }
194
195    /// Local, federated, or unauthenticated classification.
196    pub fn kind(&self) -> InventoryKind {
197        self.kind
198    }
199
200    /// Authority-resolved local tenant, always `None` for federation intake.
201    pub fn tenant(&self) -> Option<&str> {
202        self.tenant.as_deref()
203    }
204
205    /// PDS endpoint pointer. This is not live transport reach.
206    pub fn pds_endpoint(&self) -> Option<&str> {
207        self.pds_endpoint.as_deref()
208    }
209}
210
211/// Live connect-time discovery resolved from current DID authority.
212///
213/// This type is separate from [`InventoryEntry`] so rotating transport
214/// credentials cannot become stale AppView data.
215#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
216#[serde(rename_all = "camelCase")]
217pub struct ResolvedDiscovery {
218    quic_url: Option<String>,
219    cert_hash: Option<String>,
220}
221
222impl ResolvedDiscovery {
223    fn from_document(document: &Value) -> Result<Self> {
224        let Some(services) = document.get("service").and_then(Value::as_array) else {
225            return Ok(Self {
226                quic_url: None,
227                cert_hash: None,
228            });
229        };
230        let mut quic_entries = services
231            .iter()
232            .filter(|entry| entry.get("type").and_then(Value::as_str) == Some("QuicTransport"));
233        let Some(entry) = quic_entries.next() else {
234            return Ok(Self {
235                quic_url: None,
236                cert_hash: None,
237            });
238        };
239        ensure!(
240            quic_entries.next().is_none(),
241            "DID document contains ambiguous QuicTransport discovery entries"
242        );
243        hyprstream_rpc::service_entry::decode_service_entry(entry)?;
244        let endpoint = entry
245            .get("serviceEndpoint")
246            .and_then(Value::as_object)
247            .ok_or_else(|| anyhow::anyhow!("QuicTransport serviceEndpoint is not an object"))?;
248        let quic_url = endpoint
249            .get("uri")
250            .and_then(Value::as_str)
251            .map(str::to_owned);
252        let cert_hashes = endpoint
253            .get("certHashes")
254            .and_then(Value::as_array)
255            .map(|hashes| {
256                hashes
257                    .iter()
258                    .map(|hash| {
259                        hash.as_str()
260                            .map(str::to_owned)
261                            .ok_or_else(|| anyhow::anyhow!("QUIC cert hash is not a string"))
262                    })
263                    .collect::<Result<Vec<_>>>()
264            })
265            .transpose()?
266            .unwrap_or_default();
267        ensure!(
268            cert_hashes.len() <= 1,
269            "DID document contains ambiguous QUIC certificate hashes"
270        );
271        Ok(Self {
272            quic_url,
273            cert_hash: cert_hashes.into_iter().next(),
274        })
275    }
276
277    /// Current QUIC URL, if the DID document publishes one.
278    pub fn quic_url(&self) -> Option<&str> {
279        self.quic_url.as_deref()
280    }
281
282    /// Current certificate pin, if the DID document publishes one.
283    pub fn cert_hash(&self) -> Option<&str> {
284        self.cert_hash.as_deref()
285    }
286}
287
288#[derive(Clone)]
289struct StoredInventoryEntry {
290    entry: InventoryEntry,
291    label: SecurityLabel,
292}
293
294/// Non-authoritative inventory read model consumed by federation intake.
295///
296/// A pglite/Postgres implementation can replace the in-memory implementation
297/// without changing resolution or tenant-safety logic.
298#[async_trait]
299pub trait IdentityInventoryReadModel: Send + Sync {
300    /// Insert or refresh one derived projection and its trusted object label.
301    ///
302    /// The projection must already come from federation intake or an
303    /// authority-owned hosted-account source. Implementations must revalidate
304    /// tenant/kind invariants and reject [`UNAUTHENTICATED_DID_SENTINEL`].
305    async fn upsert_derived(&self, identity: InventoryEntry, label: SecurityLabel) -> Result<()>;
306
307    /// Query only entries dominated by the viewer's verified clearance.
308    ///
309    /// Filtering happens inside the read model before any response is built.
310    /// The return shape intentionally has no total/hidden-count field: callers
311    /// can observe only this post-filter vector's length. Implementations must
312    /// never return [`UNAUTHENTICATED_DID_SENTINEL`] as a real host.
313    async fn query(
314        &self,
315        viewer: &SecurityContext,
316        filter: Option<&str>,
317    ) -> Result<Vec<InventoryEntry>> {
318        self.query_page(viewer, filter, None, 200).await
319    }
320
321    /// Query one deterministic, post-clearance page.
322    ///
323    /// `after` is an exclusive DID cursor over the stable DID ordering. The
324    /// caller must enforce a finite `limit`; implementations apply it after
325    /// clearance and filter predicates and never compute a pre-filter total.
326    async fn query_page(
327        &self,
328        viewer: &SecurityContext,
329        filter: Option<&str>,
330        after: Option<&str>,
331        limit: usize,
332    ) -> Result<Vec<InventoryEntry>>;
333
334    /// List all entries visible to this viewer.
335    async fn list(&self, viewer: &SecurityContext) -> Result<Vec<InventoryEntry>> {
336        self.query(viewer, None).await
337    }
338
339    /// Fetch one entry without revealing whether a filtered object exists.
340    ///
341    /// `None` means absent, no caller clearance, or above caller clearance.
342    /// Wire adapters must map every `None` case to the same 404-style result.
343    async fn get(
344        &self,
345        viewer: Option<&SecurityContext>,
346        did: &str,
347    ) -> Result<Option<InventoryEntry>>;
348}
349
350/// Thin in-memory inventory read model, useful for embedded/demo deployments.
351#[derive(Default)]
352pub struct InMemoryIdentityInventory {
353    identities: RwLock<BTreeMap<String, StoredInventoryEntry>>,
354}
355
356#[async_trait]
357impl IdentityInventoryReadModel for InMemoryIdentityInventory {
358    async fn upsert_derived(&self, identity: InventoryEntry, label: SecurityLabel) -> Result<()> {
359        identity.validate()?;
360        let mut identities = self.identities.write();
361        if let Some(existing) = identities.get(identity.did()) {
362            ensure_safe_refresh(existing, &identity, &label)?;
363        }
364        identities.insert(
365            identity.did.clone(),
366            StoredInventoryEntry {
367                entry: identity,
368                label,
369            },
370        );
371        Ok(())
372    }
373
374    async fn query_page(
375        &self,
376        viewer: &SecurityContext,
377        filter: Option<&str>,
378        after: Option<&str>,
379        limit: usize,
380    ) -> Result<Vec<InventoryEntry>> {
381        ensure!(limit > 0, "inventory page limit must be positive");
382        let identities = self.identities.read();
383        Ok(identities
384            .values()
385            .filter(|stored| {
386                stored.entry.did() != UNAUTHENTICATED_DID_SENTINEL
387                    && viewer.can_access(&stored.label)
388                    && filter.is_none_or(|filter| matches_filter(&stored.entry, filter))
389                    && after.is_none_or(|after| stored.entry.did() > after)
390            })
391            .map(|stored| stored.entry.clone())
392            .take(limit)
393            .collect())
394    }
395
396    async fn get(
397        &self,
398        viewer: Option<&SecurityContext>,
399        did: &str,
400    ) -> Result<Option<InventoryEntry>> {
401        if did == UNAUTHENTICATED_DID_SENTINEL {
402            return Ok(None);
403        }
404        let identities = self.identities.read();
405        Ok(identities
406            .get(did)
407            .filter(|stored| viewer.is_some_and(|clearance| clearance.can_access(&stored.label)))
408            .map(|stored| stored.entry.clone()))
409    }
410}
411
412fn ensure_safe_refresh(
413    existing: &StoredInventoryEntry,
414    incoming: &InventoryEntry,
415    incoming_label: &SecurityLabel,
416) -> Result<()> {
417    ensure!(
418        existing.entry.kind == incoming.kind,
419        "inventory refresh cannot change authority kind for {}",
420        incoming.did()
421    );
422    ensure!(
423        existing.entry.tenant == incoming.tenant,
424        "inventory refresh cannot change authority-resolved tenant for {}",
425        incoming.did()
426    );
427    ensure!(
428        incoming_label.can_access(&existing.label),
429        "inventory refresh cannot lower the security label for {}",
430        incoming.did()
431    );
432    Ok(())
433}
434
435/// Resolve and project foreign identities without granting local authority.
436pub struct FederationIntake {
437    resolver: Arc<dyn FederatedDidDocumentResolver>,
438    inventory: Arc<dyn IdentityInventoryReadModel>,
439    local_issuers: Vec<String>,
440}
441
442impl FederationIntake {
443    /// Construct an intake service over a resolver and derived inventory sink.
444    pub fn new(
445        resolver: Arc<dyn FederatedDidDocumentResolver>,
446        inventory: Arc<dyn IdentityInventoryReadModel>,
447        local_issuers: Vec<String>,
448    ) -> Self {
449        Self {
450            resolver,
451            inventory,
452            local_issuers,
453        }
454    }
455
456    /// Resolve and index a foreign DID discovered without identity claims.
457    pub async fn intake(&self, did: &str) -> Result<InventoryEntry> {
458        self.intake_inner(did).await
459    }
460
461    /// Resolve and index a foreign DID carrying already-verified source claims.
462    ///
463    /// These claims describe the foreign identity, not the local caller
464    /// requesting discovery. A local issuer is rejected because it is not a
465    /// federated source. For a foreign issuer, `strip_federated_tenant` runs
466    /// before projection so even a signed tenant assertion cannot become a
467    /// local hosted-account binding.
468    pub async fn intake_with_verified_claims(
469        &self,
470        did: &str,
471        mut claims: Claims,
472    ) -> Result<InventoryEntry> {
473        let local_issuers: Vec<&str> = self.local_issuers.iter().map(String::as_str).collect();
474        ensure!(
475            !claims.is_local_to(&local_issuers),
476            "federation intake requires claims from a foreign issuer"
477        );
478        claims.strip_federated_tenant(&local_issuers);
479        ensure!(
480            claims.tenant.is_none(),
481            "federated identity retained a local tenant after sanitization"
482        );
483        self.intake_inner(did).await
484    }
485
486    /// Resolve current connect-time discovery for a visible inventory entry.
487    ///
488    /// The inventory lookup happens before resolver I/O. Missing, no-clearance,
489    /// and above-clearance identities all return the same 404-style error.
490    pub async fn resolve(
491        &self,
492        did: &str,
493        viewer: Option<&SecurityContext>,
494    ) -> Result<ResolvedDiscovery> {
495        if self.inventory.get(viewer, did).await?.is_none() {
496            return Err(IdentityDirectoryReadError::NotFound.into());
497        }
498        let document = self.resolver.resolve_federated_document(did).await?;
499        ResolvedDiscovery::from_document(&document)
500    }
501
502    async fn intake_inner(&self, did: &str) -> Result<InventoryEntry> {
503        ensure_real_identity_did(did)?;
504        let document = self.resolver.resolve_federated_document(did).await?;
505        let identity = InventoryEntry::federated(did.to_owned(), &document)?;
506        self.inventory
507            .upsert_derived(identity.clone(), SecurityLabel::bottom())
508            .await?;
509        Ok(identity)
510    }
511}
512
513fn matches_filter(entry: &InventoryEntry, filter: &str) -> bool {
514    let filter = filter.trim().to_lowercase();
515    filter.is_empty()
516        || entry.did.to_lowercase().contains(&filter)
517        || entry
518            .handle
519            .as_deref()
520            .is_some_and(|value| value.to_lowercase().contains(&filter))
521        || entry
522            .tenant
523            .as_deref()
524            .is_some_and(|value| value.to_lowercase().contains(&filter))
525        || entry
526            .pds_endpoint
527            .as_deref()
528            .is_some_and(|value| value.to_lowercase().contains(&filter))
529        || match entry.kind {
530            InventoryKind::Local => "local",
531            InventoryKind::Federated => "federated",
532            InventoryKind::Unauthenticated => "unauthenticated",
533        }
534        .contains(&filter)
535}
536
537fn extract_handle(document: &Value) -> Result<Option<String>> {
538    let Some(aliases) = document.get("alsoKnownAs").and_then(Value::as_array) else {
539        return Ok(None);
540    };
541    let handles = aliases
542        .iter()
543        .filter_map(Value::as_str)
544        .filter_map(|alias| alias.strip_prefix("at://"))
545        .filter(|handle| !handle.is_empty() && !handle.contains('/'))
546        .map(str::to_owned)
547        .collect::<Vec<_>>();
548    ensure!(
549        handles.len() <= 1,
550        "DID document contains ambiguous ATProto handles"
551    );
552    Ok(handles.into_iter().next())
553}
554
555fn extract_pds_endpoint(document: &Value) -> Result<Option<String>> {
556    let Some(services) = document.get("service").and_then(Value::as_array) else {
557        return Ok(None);
558    };
559    let endpoints = services
560        .iter()
561        .filter(|entry| {
562            entry.get("type").and_then(Value::as_str) == Some("AtprotoPersonalDataServer")
563        })
564        .map(|entry| {
565            entry
566                .get("serviceEndpoint")
567                .and_then(Value::as_str)
568                .map(str::to_owned)
569                .ok_or_else(|| anyhow::anyhow!("ATProto PDS serviceEndpoint is not a string"))
570        })
571        .collect::<Result<Vec<_>>>()?;
572    ensure!(
573        endpoints.len() <= 1,
574        "DID document contains ambiguous ATProto PDS endpoints"
575    );
576    Ok(endpoints.into_iter().next())
577}
578
579fn ensure_real_identity_did(did: &str) -> Result<()> {
580    ensure!(
581        did != UNAUTHENTICATED_DID_SENTINEL,
582        "{UNAUTHENTICATED_DID_SENTINEL} is reserved for the unauthenticated floor and is not a federated identity"
583    );
584    Ok(())
585}
586
587#[cfg(test)]
588mod tests {
589    #![allow(clippy::expect_used, clippy::unwrap_used)]
590
591    use super::*;
592    use hyprstream_rpc::auth::mac::{
593        CompartmentSet, Level, MacDecision, SecurityContext, VerifiedKeyMaterial,
594    };
595    use hyprstream_rpc::Subject;
596    use hyprstream_vfs::{SyntheticMount, SyntheticNode};
597
598    use crate::{AccountRecordReadAuthorizer, AccountRecordStore, OAUTH_ACCOUNT_RESOLVER_SUBJECT};
599
600    const FEDERATED_DID: &str = "did:plc:ewvi7nxzyoun6zhxrhs64oiz";
601    const FEDERATED_WEB_DID: &str = "did:web:alice.example";
602
603    struct FixtureResolver {
604        expected_did: &'static str,
605        document: Value,
606    }
607
608    #[async_trait]
609    impl DidDocResolve for FixtureResolver {
610        async fn resolve_doc(&self, did: &str) -> Result<Value> {
611            ensure!(did == self.expected_did, "unexpected DID {did}");
612            Ok(self.document.clone())
613        }
614    }
615
616    struct NeverResolver;
617
618    #[async_trait]
619    impl DidDocResolve for NeverResolver {
620        async fn resolve_doc(&self, did: &str) -> Result<Value> {
621            bail!("wrong resolver arm selected for {did}")
622        }
623    }
624
625    struct PermitAccountReads;
626
627    impl AccountRecordReadAuthorizer for PermitAccountReads {
628        fn check_read(
629            &self,
630            _subject: &Subject,
631            _verified_tenant: Option<&str>,
632            _security_context: Option<&SecurityContext>,
633            _object_id: &str,
634        ) -> MacDecision {
635            MacDecision::Permit
636        }
637    }
638
639    fn unauthenticated_viewer() -> SecurityContext {
640        SecurityContext::new(
641            Level::Public,
642            CompartmentSet::EMPTY,
643            VerifiedKeyMaterial::Unverified,
644        )
645    }
646
647    #[tokio::test]
648    async fn federated_did_resolves_lists_and_has_no_hosted_tenant() {
649        let resolver = Arc::new(FederatedDidResolver::new(
650            Arc::new(FixtureResolver {
651                expected_did: FEDERATED_DID,
652                document: serde_json::json!({
653                    "id": FEDERATED_DID,
654                    "alsoKnownAs": ["at://alice.example"],
655                    "service": [{
656                        "id": format!("{FEDERATED_DID}#atproto_pds"),
657                        "type": "AtprotoPersonalDataServer",
658                        "serviceEndpoint": "https://pds.alice.example"
659                    }]
660                }),
661            }),
662            Arc::new(NeverResolver),
663        ));
664        let inventory = Arc::new(InMemoryIdentityInventory::default());
665        let intake = FederationIntake::new(
666            resolver,
667            inventory.clone(),
668            vec!["https://local.example".to_owned()],
669        );
670        let foreign_claims = Claims::new(FEDERATED_DID.to_owned(), 1, 2)
671            .with_issuer("https://foreign.example".to_owned())
672            .with_tenant("acme".to_owned());
673
674        let resolved = intake
675            .intake_with_verified_claims(FEDERATED_DID, foreign_claims)
676            .await
677            .unwrap();
678        assert_eq!(resolved.did(), FEDERATED_DID);
679        assert_eq!(resolved.handle(), Some("alice.example"));
680        assert_eq!(resolved.kind(), InventoryKind::Federated);
681        assert_eq!(resolved.tenant(), None);
682        assert_eq!(resolved.pds_endpoint(), Some("https://pds.alice.example"));
683
684        let listed = inventory.list(&unauthenticated_viewer()).await.unwrap();
685        assert_eq!(listed.len(), 1);
686        assert_eq!(listed[0].did(), FEDERATED_DID);
687        assert_eq!(listed[0].tenant(), None);
688        let projected = serde_json::to_value(&listed[0]).unwrap();
689        assert!(projected.get("quicUrl").is_none());
690        assert!(projected.get("certHash").is_none());
691        assert!(projected.get("certHashes").is_none());
692        assert!(projected.get("document").is_none());
693
694        let account_store = AccountRecordStore::new(
695            Arc::new(SyntheticMount::new(SyntheticNode::dir())),
696            Arc::new(PermitAccountReads),
697        );
698        let tenant = account_store
699            .resolve_tenant_for_hosted_did(
700                &Subject::new(OAUTH_ACCOUNT_RESOLVER_SUBJECT),
701                FEDERATED_DID,
702            )
703            .await
704            .unwrap();
705        assert_eq!(tenant, None);
706    }
707
708    #[tokio::test]
709    async fn method_dispatch_rejects_document_subject_mismatch() {
710        let resolver = FederatedDidResolver::new(
711            Arc::new(FixtureResolver {
712                expected_did: FEDERATED_DID,
713                document: serde_json::json!({ "id": "did:plc:z23456723456723456723456" }),
714            }),
715            Arc::new(NeverResolver),
716        );
717
718        let error = resolver
719            .resolve_federated_document(FEDERATED_DID)
720            .await
721            .unwrap_err();
722        assert!(error.to_string().contains("does not match"));
723    }
724
725    #[tokio::test]
726    async fn did_web_arm_resolves_and_lists_without_a_tenant() {
727        let resolver = Arc::new(FederatedDidResolver::new(
728            Arc::new(NeverResolver),
729            Arc::new(FixtureResolver {
730                expected_did: FEDERATED_WEB_DID,
731                document: serde_json::json!({
732                    "id": FEDERATED_WEB_DID,
733                    "service": [{
734                        "id": format!("{FEDERATED_WEB_DID}#quic"),
735                        "type": "QuicTransport",
736                        "serviceEndpoint": {
737                            "uri": "https://alice.example:443",
738                            "webpki": true,
739                            "certHashes": []
740                        }
741                    }]
742                }),
743            }),
744        ));
745        let inventory = Arc::new(InMemoryIdentityInventory::default());
746        let intake = FederationIntake::new(resolver, inventory.clone(), Vec::new());
747
748        let resolved = intake.intake(FEDERATED_WEB_DID).await.unwrap();
749        assert_eq!(resolved.did(), FEDERATED_WEB_DID);
750        assert_eq!(resolved.tenant(), None);
751        assert_eq!(
752            inventory.list(&unauthenticated_viewer()).await.unwrap(),
753            vec![resolved]
754        );
755        let viewer = unauthenticated_viewer();
756        let discovery = intake
757            .resolve(FEDERATED_WEB_DID, Some(&viewer))
758            .await
759            .unwrap();
760        assert_eq!(discovery.quic_url(), Some("https://alice.example:443"));
761        assert_eq!(discovery.cert_hash(), None);
762        let projected = serde_json::to_value(discovery).unwrap();
763        assert!(projected.get("quicUrl").is_some());
764        assert!(projected.get("certHash").is_some());
765        assert!(projected.get("certHashes").is_none());
766    }
767
768    #[tokio::test]
769    async fn inventory_listing_prefilters_above_clearance_without_a_hidden_count() {
770        let inventory = InMemoryIdentityInventory::default();
771        let public =
772            InventoryEntry::indexed_federated("did:web:public.example", None, None).unwrap();
773        inventory
774            .upsert_derived(public.clone(), SecurityLabel::bottom())
775            .await
776            .unwrap();
777        inventory
778            .upsert_derived(
779                InventoryEntry::indexed_federated("did:web:hidden.example", None, None).unwrap(),
780                SecurityLabel::new(
781                    Level::Secret,
782                    hyprstream_rpc::auth::mac::Assurance::Unverified,
783                    CompartmentSet::EMPTY,
784                ),
785            )
786            .await
787            .unwrap();
788
789        let visible = inventory.list(&unauthenticated_viewer()).await.unwrap();
790        assert_eq!(visible, vec![public]);
791        assert_eq!(visible.len(), 1, "only the post-filter count is observable");
792    }
793
794    #[tokio::test]
795    async fn above_floor_direct_access_is_not_found_not_forbidden() {
796        const HIDDEN_DID: &str = "did:web:hidden.example";
797        const MISSING_DID: &str = "did:web:missing.example";
798
799        let inventory = Arc::new(InMemoryIdentityInventory::default());
800        inventory.identities.write().insert(
801            HIDDEN_DID.to_owned(),
802            StoredInventoryEntry {
803                entry: InventoryEntry {
804                    did: HIDDEN_DID.to_owned(),
805                    handle: None,
806                    kind: InventoryKind::Federated,
807                    tenant: None,
808                    pds_endpoint: None,
809                },
810                label: SecurityLabel::new(
811                    Level::Secret,
812                    hyprstream_rpc::auth::mac::Assurance::Unverified,
813                    CompartmentSet::EMPTY,
814                ),
815            },
816        );
817        let intake = FederationIntake::new(
818            Arc::new(FederatedDidResolver::new(
819                Arc::new(NeverResolver),
820                Arc::new(NeverResolver),
821            )),
822            inventory.clone(),
823            Vec::new(),
824        );
825        let viewer = unauthenticated_viewer();
826
827        assert_eq!(
828            inventory.get(Some(&viewer), HIDDEN_DID).await.unwrap(),
829            None
830        );
831        assert_eq!(
832            inventory.get(Some(&viewer), MISSING_DID).await.unwrap(),
833            None
834        );
835        assert_eq!(inventory.get(None, HIDDEN_DID).await.unwrap(), None);
836
837        for did in [HIDDEN_DID, MISSING_DID] {
838            let error = intake.resolve(did, Some(&viewer)).await.unwrap_err();
839            assert_eq!(
840                error.downcast_ref::<IdentityDirectoryReadError>(),
841                Some(&IdentityDirectoryReadError::NotFound),
842                "direct access to {did} must be 404-style, never forbidden: {error:#}"
843            );
844        }
845    }
846
847    #[tokio::test]
848    async fn federated_intake_cannot_demote_or_declassify_a_local_projection() {
849        let inventory = Arc::new(InMemoryIdentityInventory::default());
850        let local = InventoryEntry::local(
851            FEDERATED_WEB_DID,
852            Some("local.example".to_owned()),
853            "tenant-authority",
854            Some("https://local-pds.example".to_owned()),
855        )
856        .unwrap();
857        inventory
858            .upsert_derived(
859                local.clone(),
860                SecurityLabel::new(
861                    Level::Secret,
862                    hyprstream_rpc::auth::mac::Assurance::PqHybrid,
863                    CompartmentSet::single(3),
864                ),
865            )
866            .await
867            .unwrap();
868        let intake = FederationIntake::new(
869            Arc::new(FederatedDidResolver::new(
870                Arc::new(NeverResolver),
871                Arc::new(FixtureResolver {
872                    expected_did: FEDERATED_WEB_DID,
873                    document: serde_json::json!({
874                        "id": FEDERATED_WEB_DID,
875                        "alsoKnownAs": ["at://foreign.example"],
876                    }),
877                }),
878            )),
879            inventory.clone(),
880            Vec::new(),
881        );
882
883        let error = intake.intake(FEDERATED_WEB_DID).await.unwrap_err();
884        assert!(error.to_string().contains("cannot change authority kind"));
885        assert!(
886            inventory
887                .list(&unauthenticated_viewer())
888                .await
889                .unwrap()
890                .is_empty(),
891            "rejected federation refresh must not declassify the local row"
892        );
893        let privileged = SecurityContext::new(
894            Level::Secret,
895            CompartmentSet::single(3),
896            VerifiedKeyMaterial::PqHybrid,
897        );
898        assert_eq!(
899            inventory
900                .get(Some(&privileged), FEDERATED_WEB_DID)
901                .await
902                .unwrap(),
903            Some(local)
904        );
905    }
906
907    #[tokio::test]
908    async fn unauthenticated_sentinel_is_never_resolved_or_listed() {
909        let resolver = Arc::new(FederatedDidResolver::new(
910            Arc::new(NeverResolver),
911            Arc::new(NeverResolver),
912        ));
913        let inventory = Arc::new(InMemoryIdentityInventory::default());
914        let intake = FederationIntake::new(resolver, inventory.clone(), Vec::new());
915
916        let error = intake
917            .intake(UNAUTHENTICATED_DID_SENTINEL)
918            .await
919            .unwrap_err();
920        assert!(
921            error.to_string().contains("unauthenticated floor"),
922            "{error:#}"
923        );
924        assert!(inventory
925            .list(&unauthenticated_viewer())
926            .await
927            .unwrap()
928            .is_empty());
929        let error = intake
930            .resolve(
931                UNAUTHENTICATED_DID_SENTINEL,
932                Some(&unauthenticated_viewer()),
933            )
934            .await
935            .unwrap_err();
936        assert_eq!(
937            error.downcast_ref::<IdentityDirectoryReadError>(),
938            Some(&IdentityDirectoryReadError::NotFound)
939        );
940
941        inventory.identities.write().insert(
942            UNAUTHENTICATED_DID_SENTINEL.to_owned(),
943            StoredInventoryEntry {
944                entry: InventoryEntry {
945                    did: UNAUTHENTICATED_DID_SENTINEL.to_owned(),
946                    handle: None,
947                    kind: InventoryKind::Unauthenticated,
948                    tenant: None,
949                    pds_endpoint: None,
950                },
951                label: SecurityLabel::bottom(),
952            },
953        );
954        assert!(
955            inventory
956                .list(&unauthenticated_viewer())
957                .await
958                .unwrap()
959                .is_empty(),
960            "legacy/corrupt sentinel rows must be filtered from inventory listing"
961        );
962    }
963
964    #[tokio::test]
965    async fn local_identity_claims_cannot_enter_federation_intake() {
966        let resolver = Arc::new(FederatedDidResolver::new(
967            Arc::new(NeverResolver),
968            Arc::new(NeverResolver),
969        ));
970        let inventory = Arc::new(InMemoryIdentityInventory::default());
971        let intake = FederationIntake::new(
972            resolver,
973            inventory.clone(),
974            vec!["https://local.example".to_owned()],
975        );
976        let local_claims = Claims::new("alice".to_owned(), 1, 2)
977            .with_issuer("https://local.example".to_owned())
978            .with_tenant("acme".to_owned());
979
980        let error = intake
981            .intake_with_verified_claims(FEDERATED_DID, local_claims)
982            .await
983            .unwrap_err();
984        assert!(error.to_string().contains("foreign issuer"));
985        assert!(inventory
986            .list(&unauthenticated_viewer())
987            .await
988            .unwrap()
989            .is_empty());
990    }
991}