> ## Documentation Index
> Fetch the complete documentation index at: https://docs.presschain.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Trust Object

> Use the cross-domain structured model for identity, content, evidence, provenance, trust, risk and an optional PressChain Capsule.

# Trust Object

`presschain-models` defines `TrustObject` as a structured envelope that can carry information across identity, source, content, evidence, provenance and analysis domains without flattening them into a single score.

The current Rust model contains:

```rust theme={null}
pub struct TrustObject {
    pub version: String,
    pub identity: Identity,
    pub source: Source,
    pub content: Content,
    pub entities: Vec<Entity>,
    pub claims: Vec<Claim>,
    pub evidence: Vec<Evidence>,
    pub relationships: Vec<Relationship>,
    pub provenance: Provenance,
    pub trust: Trust,
    pub risk: Risk,
    pub visibility: Visibility,
    pub capsule: Option<CapsuleRecord>,
}
```

## Why the model is broad

A Capsule is a protocol publication record. A Trust Object is a broader structured record that can describe the context around content whether or not that content has already been published to PressChain.

Making `capsule` optional allows an application to normalize external or pre-publication information and later attach the canonical Capsule projection when one exists.

## Interoperability does not merge systems

PressChain can produce or consume structured trust-compatible objects, but PressChain and the separate TRUST Layer remain distinct systems. Shared data shapes do not merge governance, infrastructure, branding or legal authority.

If an application combines PressChain records with another analysis system, preserve source attribution for every externally produced field.

## Adapt at the boundary

A clean integration maps external data once at ingestion instead of teaching every UI component to understand several incompatible shapes.

```ts theme={null}
function toTrustObject(input: ExternalRecord): TrustObject {
  return {
    version: "1",
    identity: mapIdentity(input.identity),
    source: mapSource(input.source),
    content: mapContent(input.content),
    entities: mapEntities(input.entities),
    claims: mapClaims(input.claims),
    evidence: mapEvidence(input.evidence),
    relationships: mapRelationships(input.relationships),
    provenance: mapProvenance(input.provenance),
    trust: mapTrust(input.trust),
    risk: mapRisk(input.risk),
    visibility: mapVisibility(input.visibility),
    capsule: input.capsule ? mapCapsule(input.capsule) : null,
  };
}
```

Use source-backed generated types in production. The example illustrates the boundary pattern.

## Keep facts and interpretation separate

An extracted claim is not automatically an on-chain fact. A risk signal is not a Capsule status. An external confidence score is not evidence. The model remains useful because those concepts remain separate and can carry their own provenance.

Consumers can then decide which components they trust and why.

## Version the envelope

Treat `version` as compatibility data. A parser should explicitly adapt or reject an incompatible future major shape instead of silently ignoring fields it does not understand.

For exchanged objects, record both model version and producer identity. That makes debugging and audits far easier than relying on the receiving application’s deployment date.

## Use case: research workspace

A research application can ingest a web article, extract entities and claims, associate source records and evidence, calculate its own risk signals and keep all of that in a Trust Object. If the article later has a PressChain Capsule, the application adds the canonical Capsule record without rewriting the rest of the data model.

That is the value of the envelope: it connects domains while preserving their boundaries.