# V3 Diagram Atlas

This atlas provides the cross-cutting visual models for Lilith Metaverse. It
shows client-tier routing, room join, durable identity and consent, session
state, contract composition, tenant ownership, creator-to-live delivery, and
rollout evidence. Focused pages remain authoritative for detail and current
runtime/validation evidence determines support.

## Client, world, and tenant landscape

```mermaid
flowchart TB
  Member[Member device and eligibility] --> Router[Tier router]
  Router --> UE[Native UE5 client]
  Router --> Pixel[Pixel-streamed UE session]
  Router --> Web[Fallback web client]
  UE --> Gateway[Realtime gateway]
  Pixel --> Fleet[Pixel-streaming fleet]
  Fleet --> Gateway
  Web --> Gateway
  Gateway --> World[Authoritative world server]
  World --> Rooms[Rooms presence physics and interaction]
  Rooms --> Tara[Tara classes and coaching]
  Rooms --> Saraswati[Saraswati stage and artists]
  Rooms --> Commons[Lilith Commons and venues]
  Studio[Lilith Studio] --> Pipeline[Content asset rights and review pipeline]
  Pipeline --> Rooms
  World --> Shared[Identity data commerce safety provenance and audit]
```

Tier selection changes realization and capacity, not the governing member, room,
tenant, rights, and safety identities. Studio publishes governed content; it
does not write directly into a live authoritative world.

## Room join sequence

```mermaid
sequenceDiagram
  actor Member
  participant Surface as Client surface
  participant Router as Tier router
  participant Identity as Identity and policy
  participant Gateway as Realtime gateway
  participant World as World server
  participant Room as Room shard
  Member->>Surface: Open room
  Surface->>Router: Device network entitlement and preferences
  Router->>Identity: Resolve account tenant region consent and policy
  alt denied or unavailable
    Identity-->>Surface: Named refusal and recovery options
  else admitted
    Identity-->>Router: Scoped room capability
    Router-->>Surface: Tier endpoint asset and protocol versions
    Surface->>Gateway: Authenticated join envelope
    Gateway->>World: Reserve presence and route shard
    World->>Room: Spawn governed avatar and state
    Room-->>Surface: Snapshot peers capabilities and disclosures
    Surface-->>Member: Interactive room
  end
```

Admission, tier allocation, protocol compatibility, world presence, avatar
spawn, and visible readiness are separate. A reservation is not a completed
join, and a client frame is not proof that the authoritative presence exists.

## Identity, room, consent, and content records

```mermaid
erDiagram
  ACCOUNT ||--o{ IDENTITY_LINK : binds
  ACCOUNT ||--o{ MEMBERSHIP : holds
  TENANT ||--o{ MEMBERSHIP : grants
  TENANT ||--o{ ROOM : owns
  ROOM ||--o{ PRESENCE_SESSION : hosts
  ACCOUNT ||--o{ PRESENCE_SESSION : joins
  ACCOUNT ||--o{ AVATAR_PROFILE : controls
  AVATAR_PROFILE ||--o{ AVATAR_VERSION : versions
  ROOM ||--o{ RECORDING_CONSENT : requires
  ACCOUNT ||--o{ RECORDING_CONSENT : decides
  TENANT ||--o{ CONTENT_RELEASE : publishes
  CONTENT_RELEASE ||--o{ ASSET : contains
  ASSET ||--o{ PROVENANCE : records
  CONTENT_RELEASE ||--o{ RIGHTS_GRANT : requires
  PRESENCE_SESSION ||--o{ AUDIT_EVENT : produces
```

Account links, tenant membership, room presence, avatar versions, consent,
content versions, rights, provenance, and audit remain independently addressable
so unlinking, takedown, DSAR, and incident review can be correct.

## Presence session lifecycle

```mermaid
stateDiagram-v2
  [*] --> Requested
  Requested --> Allocating: identity policy and tier admitted
  Requested --> Refused: entitlement region safety or capacity
  Allocating --> Loading: endpoint and compatible assets reserved
  Loading --> Present: authoritative snapshot applied
  Loading --> Failed: asset protocol or provider failure
  Present --> Degraded: quality capacity or modality fallback
  Degraded --> Present: target service restored
  Present --> Reconnecting: transient transport loss
  Reconnecting --> Present: bounded session resume
  Reconnecting --> Ended: resume budget expires
  Present --> Removed: leave kick ban or room closure
  Removed --> Ended: receipts and presence cleanup
  Failed --> [*]
  Refused --> [*]
  Ended --> [*]
```

The reader and telemetry should distinguish refusal, failure, degraded service,
reconnect, and governed removal. Cleanup must not leave ghost presence,
recording, voice, entitlement, or billing state.

## Shared contract composition

```mermaid
classDiagram
  class JoinEnvelope {
    accountId
    tenantId
    roomId
    protocolVersion
  }
  class TierDecision {
    tier
    endpoint
    obligations
  }
  class RoomCapability {
    role
    grants
    consentState
  }
  class PresenceSnapshot {
    sessionId
    avatarVersion
    peers
    worldRevision
  }
  class ContentManifest {
    releaseId
    assetVersions
    provenanceRefs
  }
  JoinEnvelope --> TierDecision : evaluated into
  JoinEnvelope --> RoomCapability : authorized as
  TierDecision --> PresenceSnapshot : realizes
  RoomCapability --> PresenceSnapshot : scopes
  ContentManifest --> PresenceSnapshot : pins assets
```

Concrete protocols are richer, but the roles must remain visible: routing does
not authorize, capability does not allocate capacity, and a snapshot pins the
content and avatar versions that produced the visible world.

## Tenant and platform estate

```mermaid
mindmap
  root((Lilith Metaverse))
    Shared world
      Rooms presence and multiplayer
      Avatars nameplates and spatial audio
      Client tiers and accessibility
      Identity safety and provenance
    Tara
      Instructor verification
      Class and sequence authoring
      Live sessions and Aja coaching
      Lineage tone and economics
    Saraswati
      Artist personas and discography
      Music voice genre and rights
      Stage performance and fan economy
      Collaboration remix and royalties
    Commons and creation
      Persistent venues and programming
      Lilith Studio and asset pipeline
      Commerce governance and takedown
      Operations rollout and live service
```

The map prevents tenant concepts from being mistaken for shared-world authority.
Each tenant composes platform services under its own product, content, rights,
and operator boundaries.

## Creator-to-live journey

```mermaid
journey
  title From V3 creator intent to live world content
  section Author
    Create room scene avatar class or performance: 5: Creator
    Pin sources rights consent and tenant ownership: 5: Creator, Rights
  section Review
    Validate assets accessibility policy and performance: 5: QA, Governance
    Approve immutable content release: 5: Tenant operator
  section Stage
    Bake tier variants and prewarm delivery: 4: Pipeline, SRE
    Verify clients world server and rollback: 5: QA, Release
  section Operate
    Publish cohort observe receipts and incidents: 5: SRE
    Takedown correct or roll back with audit: 5: Rights, Operators
```

The live result depends on authoring, rights, review, tier variants, runtime
compatibility, and operations. A Studio preview proves only one part.

## Rollout evidence order

```mermaid
timeline
  title V3 rollout evidence
  Contract : Tenant room identity consent and rights model
           : Client-tier and protocol compatibility
  Runtime : World authority presence avatar audio and interaction
          : Asset pipeline shared services and regional data
  Validation : Functional accessibility quality and reconnect journeys
             : Capacity latency security rights and provider evidence
  Certification : Platform store region staffing DR and day-zero patch
                : Staged cohort observability and rollback
  Support : Named tiers platforms tenants regions and capabilities
          : Current incidents regressions and operational proof
```

This is an evidence sequence rather than a date promise. Each tier, platform,
tenant, and region earns support through its own applicable gates.

## How to use this atlas

Use the landscape and estate to locate ownership, trace a join with the
sequence/state diagrams, review identity and content with the ER/class models,
and use the creator journey and rollout order at release review. Continue to the
[V3 guide](./README.md), [feature index](../features/README.md),
[architecture index](../architecture/README.md), and
[Lilith handbook](./lilith/README.md).
