T-RUE is a published open standard — and you can run it right now. This is a minimal, honest starting point for T-RUE: an example revocation envelope that answers the four movements — Traceable, Transparent, Timely and Trustworthy — a self-test you can walk through by hand, an interactive checker and envelope builder that run in your browser, and a validator you can paste into a project. Everything here checks the T1 · Declared floor for real; the higher tiers can be declared but need runtime evidence to be proven.
Paste a revocation envelope, upload a .json file, or load the worked example. The check runs entirely in your browser — nothing is sent anywhere.
A single JSON document that answers all four movements for one endorsement chain. It is an example, not a certificate — the shape is what matters.
T1 · Declared is verifiable from the document itself. T2 · Propagating and T3 · Provable are claims about what happens when trust is actually withdrawn — so an envelope can only declare them and point at where the runtime evidence lives. The checker labels those tiers accordingly.
T2 · Propagating
T3 · Provable
Traceable
Does the envelope carry the endorsement chain and resolve it to a named origin?
Pass when: chain is a non-empty array, trace.resolvesToOrigin is true and trace.originAnchor names the origin.
Transparent
Is the current endorsement state visible to any downstream party?
Pass when: transparency.statusEndpoint is set and transparency.queryableByDownstream is true.
Timely
Is there a measurable bound on how fast a revocation propagates?
Pass when: timeliness.propagationLatencyTargetMs is a positive number.
Trustworthy
Does a revoked endorsement read as invalid everywhere, fail-closed?
Pass when: trust.semantics is “fail-closed” and trust.revokedReadsInvalidEverywhere is true.
The same checks as the browser tool, as a script. Download it or paste it into a file and run it against an envelope. It confirms all four movements are answered at the T1 · Declared floor. It checks the document only — it cannot prove a revocation actually propagated, which is exactly why T2 and T3 need more than a file.
// true-check.js — minimal T1 (Declared) self-check, no dependencies
// Usage: node true-check.js envelope.json
const fs = require('fs');
const env = JSON.parse(fs.readFileSync(process.argv[2], 'utf8'));
const r = env.revocation || {};
const checks = {
Traceable: Array.isArray(r.chain) && r.chain.length > 0
&& r.trace && r.trace.resolvesToOrigin === true
&& typeof r.trace.originAnchor === 'string',
Transparent: r.transparency
&& typeof r.transparency.statusEndpoint === 'string'
&& r.transparency.queryableByDownstream === true,
Timely: r.timeliness
&& typeof r.timeliness.propagationLatencyTargetMs === 'number'
&& r.timeliness.propagationLatencyTargetMs > 0,
Trustworthy: r.trust && r.trust.semantics === 'fail-closed'
&& r.trust.revokedReadsInvalidEverywhere === true,
};
let ok = true;
for (const [dim, pass] of Object.entries(checks)) {
console.log((pass ? 'PASS ' : 'FAIL ') + dim);
if (!pass) ok = false;
}
console.log(ok ? '\nDeclared (T1): all four movements answered.'
: '\nDeclared (T1): incomplete — see FAIL lines above.');
process.exit(ok ? 0 : 1);
A published open standard
T-RUE is now a published open standard (1.0). The envelope shape is stable; future revisions follow the coalition's versioning and change process. What this kit does today is real: it checks that an envelope answers the four movements at the T1 · Declared tier. It does not prove T2 · Propagating or T3 · Provable, because those are claims about what happens when trust is withdrawn at runtime, not about a document. Being straight about that boundary is part of the standard being honest.
Test vectors
Canonical fixtures to prove your checker agrees.
Read the standard
The four movements and three tiers in full.
The four movements and three tiers, in full.