Trilatic Desks

Work-acceptance record specification, schema 1.2 (profile 1.4.1)

What an acceptance record says, and exactly how anyone can verify it without our software or any proprietary service. An implementer can build a verifier from this page and the test vectors alone.

1. Status, scope and licence

Document version: profile 1.4.1, 2026-10-21. The schema identifier is unchanged; profiles 1.2.1, 1.3, 1.4 and 1.4.1 resolve ambiguities found by independent clean-room reviews (see the changelog).

This is the specification of the work-acceptance record (also called a receipt), schema identifier trilatic.acceptance-receipt/1.2. The record is a signed, timestamped statement: these criteria, fixed in advance, were checked on this exact delivered file, by this checker, and these are the per-criterion outcomes.

What this page covers: the record, and how to verify it. What it does not cover: how any check or any remediation is performed. A record states outcomes only; it never states methods, and a conforming verifier needs no knowledge of them.

The key words MUST, MUST NOT, SHOULD and MAY are used as in RFC 2119. A verifier is any program implementing section 10. A checker is the party that issues the record. A producer is the party that made the delivered file. A buyer is the party deciding whether to accept the delivered file.

Licence. The text of this specification is licensed under Creative Commons Attribution 4.0 International (CC BY 4.0): share and adapt with attribution to Trilatic Desks. The test vectors are dedicated to the public domain under CC0 1.0. Earlier schema versions (/1 and /1.1) are out of scope here; a verifier MAY support them.

2. The artefacts

Files that make up a verifiable acceptance record
ArtefactWhat it is
receipt.jsonThe record: a JSON object with three members, receipt (the signed body), signature and timestamp. Section 3.
receipt.tsrOptional. The RFC 3161 TimeStampResp covering the record digest. Section 6.
Criteria document and its .tsrThe buyer-facing requirements, published as canonical JSON, with an RFC 3161 timestamp over its SHA-256 made before any record cites it. Section 7.
Key listThe checker's public keys, published by the checker (for example at /.well-known/trilatic-receipt-key.json on the checker's own domain). Section 5.
The delivered fileThe exact bytes the record is about. The record binds to them by SHA-256.

3. Data model

All JSON is UTF-8. Numbers in a record are integers. Unknown members MUST be ignored for display but remain covered by the signature (the signature is over the whole receipt object, section 4).

3.1 Envelope (the top-level object of receipt.json)

Envelope members
MemberTypeReq.Meaning
receiptobjectMUSTThe signed body, section 3.2.
signatureobjectMUSTalg: the string Ed25519. key_id: string naming the signing key in the key list. value: standard base64 (with padding) of the 64-byte Ed25519 signature over the canonical bytes of receipt.
timestampobjectMUSTNot signed. status: granted or none. When granted: tsa (string, host of the time-stamp authority), gen_time (the authority's time as ASN.1 GeneralizedTime YYYYMMDDHHMMSSZ), digest_sha256 (lowercase hex of the record digest, section 6), tsr_file (name of the companion file), covers (human-readable). When none: reason (string). The record is valid without a timestamp; it then carries no independent time evidence.

3.2 Body (receipt)

Members of the signed body
MemberTypeReq.Meaning
schemastringMUSTExactly trilatic.acceptance-receipt/1.2. A verifier MUST reject an unknown value for this member rather than guess.
canonicalizationstringMUSTExactly JCS-RFC8785. Verifiers MUST reject any other value. No silent fallback to another rule.
suiteobjectMUSTExactly {"digest":"sha-256","signature":"Ed25519"}. Declares the mechanisms; verifiers MUST reject anything else.
receipt_idstringMUSTIdentifier assigned by the checker. Unique per checker.
revisionintegerMUST1 for a first issue; incremented when the same receipt is re-issued (for example after a human review is added).
supersedes_sha256stringMAYPresent when revision > 1: lowercase hex of the record digest of the revision this one replaces.
issued_utcstringMUSTISO 8601 UTC with seconds and trailing Z, the checker's own clock. Used as the reference time when there is no timestamp (section 7).
issuerstringMUSTDisplay name of the issuing organisation.
key_idstringMUSTIdentifier of the signing key. MUST equal signature.key_id and parties.checker.key_id.
partiesobjectMUSTchecker and producer, each {"name": string, "key_id": string or null}. checker.key_id is the signing key. producer.key_id is the producer's own signing key if it has one, else null. Section 8.
independencestringMUSTOne of independent, self-checked, undeclared. Derived from parties by the rule in section 8; a verifier recomputes it.
criteriaobjectMUSTid (criteria set identifier), version (string), sha256 (lowercase hex of the committed criteria document), committed_at (ISO 8601 UTC: the time-stamp authority's time for that commitment), commitment (the string rfc3161). Section 7.
criteria_commitmentobjectMAYOptional binding to client-agreed terms: {"type":"signed_terms","digest":"<lowercase hex sha-256>"}. Verifiers display it; this specification defines no further check.
paymentobjectMAYThe payment the record concerns, inside the signed and timestamped body. For x402 exact on an EVM network: {"protocol":"x402","scheme":"exact","network":"eip155:<chain id>","asset":<token contract>,"payer":<address>,"pay_to":<address>,"amount":<atomic units, decimal string>,"nonce":<EIP-3009 nonce, 0x hex>}, optionally "settlement_tx". Every member is a string: network is eip155: and a decimal chain id without leading zeros (CAIP-2), amount a decimal string of atomic units, addresses 20 and nonce and settlement_tx 32 bytes of 0x hex; no other members. A member outside this form is still outcome-neutral (vector 55); a chain checker reports it unsupported. (network, asset, payer, nonce) names exactly one settlement. The member changes no outcome (section 10); a verifier with chain access MAY check it and report it separately.
client_refstringMUSTFree text reference chosen by the requester; may be empty. Do not put personal data in it: the record is public.
filesobjectMUSToriginal and remediated, each {"name": string, "sha256": hex, "bytes": integer, "pages": integer}. remediated describes the delivered file the record is about; original is informational (the file the delivery was derived from).
resultsarrayMUSTOne entry per criterion of the committed criteria document: id, title, required (boolean), result (section 9), finding (short plain-language statement of the outcome).
human_reviewobjectMUSTstatus: pending or complete; scope: array of strings stating what a human review covers. When complete: outcome (pass or fail), reviewer (string), reviewed_utc, notes_sha256 (hex SHA-256 of the reviewer's notes, which are not published).
verdictstringMUSTOne of pass, fail, incomplete. Derived by the rule in section 9; a verifier recomputes it.
toolsobjectMUSTInformational: names and versions of third-party validators whose output a result relies on, so a reader can reproduce it. States no method.
noticestringMUSTThe record's limitation statement: what it does not claim (for example, that it is not a compliance determination).

4. Canonicalization (JCS) and what is signed

The signed bytes are the JSON Canonicalization Scheme, RFC 8785 (JCS) serialisation of the receipt member only (not the envelope), encoded as UTF-8. Verifiers MUST parse receipt.json and re-canonicalize the receipt member; they MUST NOT rely on the bytes of the file, which may be re-wrapped, re-indented or have its line endings changed in transit.

  1. Object members are sorted by their names compared as sequences of UTF-16 code units (not code points, not UTF-8 bytes).
  2. No whitespace between tokens.
  3. Numbers use the ECMAScript number-to-string rule (RFC 8785 §3.2.2.3): for example 0.00001, 1e-7, 123456789012345680000, 1e+21. A JSON number is an IEEE double, so an integer beyond 253 is written as the double it parses to (vector 52).
  4. Strings are written in UTF-8 with only these escapes: \", \\, \b, \f, \n, \r, \t, and \u00xx (lower-case hex) for the other control characters below U+0020. All other characters, including U+007F and non-ASCII, are written literally.
  5. true, false and null are literal.

The record digest used for timestamping (section 6) and for citing a record elsewhere is sha256(JCS(receipt)), written as 64 lowercase hex characters.

Hexadecimal digests. A SHA-256 digest written in a record, such as criteria.sha256, MUST be exactly 64 lowercase hexadecimal digits (0-9, a-f). A verifier does not lower-case it: any other form, upper case included, matches no digest. For criteria.sha256 that means CRITERIA_HASH_MISMATCH when the criteria document is supplied and CRITERIA_TIMESTAMP_MISMATCH when a token is supplied (vector 67).

5. Signature and keys

  1. Take receipt.key_id, the key identifier inside the signed bytes. The envelope's signature.key_id MUST equal it, else SIGNATURE_INVALID (the envelope is not signed, so it cannot choose the key). Find the key with that identifier in the checker's published key list. If none: fail with SIGNATURE_INVALID. Whether the signer is the checker named in parties is a separate check (section 8, CHECKER_NOT_SIGNER).
  2. Key rule. The public key MUST be the canonical 32-byte encoding (y < p; no x = 0 with the sign bit set) of a point of prime order L: not the neutral point, not of small order, not of mixed order. A verifier MUST check this before verifying and, for a key that fails it, report KEY_REJECTED and run no signature check. KEY_REJECTED is a finding about the key list, not evidence that the record was altered. The rule applies to the key named by the signed receipt.key_id only: other entries in the key list do not change the outcome fields, and a verifier MAY report them separately (vector 28). (The cofactorless equation accepts a signature for any message under the neutral point, and common Ed25519 libraries accept such a key; vector 26.)
  3. The key list is a JSON object {"issuer": string, "keys": [{"key_id": string, "alg": "Ed25519", "public_key_base64": base64 of the 32-byte raw public key, "status": string, "created_utc": string}]}. How a verifier establishes that it is looking at the genuine key list (HTTPS to the checker's domain, a pinned key, an out-of-band exchange) is the verifier's trust decision and is outside the record.
  4. Verify the Ed25519 (RFC 8032) signature value over the JCS bytes of receipt with that public key. Any failure, including malformed base64 or a wrong-length value, is SIGNATURE_INVALID. When the signature fails, a verifier MUST NOT present the record's verdict or findings as results.
  5. A key with a retired status still verifies records issued while it was active; a verifier SHOULD show the status.
  6. Canonical base64. Every base64 value a verifier reads MUST be canonical: only the characters A-Z, a-z, 0-9, + and /; = padding, so that the length is a multiple of four; no whitespace or any other character; and re-encoding the decoded bytes MUST give the input string exactly, so a value with non-zero trailing bits is refused. A signature value that is not canonical is SIGNATURE_INVALID. A public key that is not canonical is KEY_REJECTED. A token or criteria file in a vector that is not canonical base64 matches nothing: its imprint or hash check fails, and it is reported as the corresponding mismatch (CRITERIA_HASH_MISMATCH, CRITERIA_TIMESTAMP_MISMATCH, or imprint_mismatch for the record's token), never as a refusal (vectors 60 to 63, 89 and 90).
  7. Repeated key identifier. In a schema 1.2 record, a key_id that appears more than once in the key list names no single key, whichever entry comes first: the verifier reports KEY_REJECTED (vectors 75 and 79). If the repeated identifier is the signing key's, no signature check is run. If it is the producer's or the checker's, independence is derived as self-checked (section 8).

6. RFC 3161 timestamp coverage

The checker sends the 32-byte record digest (section 4) to a public time-stamp authority as the messageImprint (SHA-256) of an RFC 3161 TimeStampReq. The authority's TimeStampResp is stored as receipt.tsr. The timestamp covers the record digest, and therefore every member of receipt; it does not cover the envelope's timestamp member itself.

A verifier checks, at increasing strength:

  1. Consistency (informative). timestamp.digest_sha256 equals sha256(JCS(receipt)). The envelope's timestamp member is not signed; a verifier MAY show a disagreement, but the outcome is decided by the token (step 2), never by this field.
  2. Imprint. The messageImprint of the token's signed TSTInfo (TimeStampResp or ContentInfo → SignedData → encapContentInfo of type id-ct-TSTInfo → TSTInfo) has hashAlgorithm SHA-256 (OID 2.16.840.1.101.3.4.2.1, parameters absent or NULL) and hashedMessage equal to that digest. An imprint under any other algorithm is not a match, even when its value has the same length and the same bytes (SHA-384, SHA3-256, SHA-512/256: vectors 23 to 25). (The reference verifier on this site stops here and says so.) genTime and accuracy are read from the same TSTInfo. Nothing outside the signed TSTInfo is read for imprint or time: bytes elsewhere in a response, such as PKIStatusInfo.statusString, are not signed by the authority (vectors 50 and 51). Likewise, unsigned attributes of the SignerInfo (unsignedAttrs) are not read, and their presence or content is not a ground for refusal (vector 83).
  3. Authority. The outcome fields of this profile cover imprint and time only; they do not say that the authority's signature was checked. A verifier that presents a time as evidence to a third party SHOULD also validate the CMS signature on the token and its certificate chain to an authority the relying party trusts, and report that result separately from the outcome fields. Which authorities are trusted is the relying party's decision, as for keys (section 5). timestamp.gen_time MUST equal the TSTInfo genTime.
  4. Accuracy and ordering. When a token states accuracy, its time is the interval genTime ± accuracy, and comparisons in section 7 use the end of the interval that is least favourable to "committed before". A token that states no accuracy is taken at its genTime. ordering is ignored: it orders tokens from one authority only, and the two tokens compared here may come from different authorities.
  5. Form of genTime. genTime MUST be a DER GeneralizedTime in UTC: YYYYMMDDHHMMSS, then optionally . and one or more digits of which the last is not 0, then Z. The letter Z is required: a time with an offset, such as +0100, is refused. The separator is . only; a comma, an empty fraction and a fraction with a trailing zero (.5000, .000) are refused. The calendar fields MUST be real: month 01 to 12, a day that exists in that month (leap years included), hour 00 to 23, minute 00 to 59, second 00 to 59. A genTime that fails any of this is no usable time: the token is then treated as one that gives no time (section 7.3 step 4; vectors 70 to 74 and 78). A verifier never fails on it. A fraction is kept to the millisecond. In the comparison of section 7.3 step 5 the commitment time is rounded up to the next millisecond and the reference time down, so that a fraction can never make "committed before" easier, and the comparison is strict (<) at millisecond resolution (vectors 66 and 68). The comparison of committed_at with genTime (CRITERIA_TIME_MISMATCH) is to the second.

Authority signature outcome (tsa_signature, profile 1.4). The outcome reports the authority's signature for each token present, under the keys criteria (the criteria token) and receipt (the record token), in a field separate from receipt_timestamp, which covers the imprint only. Without relying-party trust anchors (none supplied, or an empty list) the signature is not_evaluated; a verifier may omit the field, and an absent field is read as not_evaluated for each token present. With anchors the value is one of: verified (the CMS signature, the contentType signed attribute equal to an eContentType of id-ct-TSTInfo (RFC 5652 §5.3), the ESS signing-certificate binding (RFC 3161 §2.4.2, RFC 5816), id-kp-timeStamping, and a chain whose issuers are CAs reaching a supplied anchor (matched by subject name and public key, RFC 5280 §6.1.1, not by certificate bytes, so a cross-signed copy of the anchor in the token still reaches it, and an anchor with the issuer's name but another key is not that issuer: if only such anchors fail, no chain reaches a supplied anchor, vector 53), with the signer and every issuer other than the anchor valid at genTime, all check out); failed (any of those checks fails, or the token is malformed); untrusted (the signature is valid but no chain reaches a supplied anchor; a root carried inside the token is not an anchor); unsupported (an algorithm the verifier does not implement, e.g. a curve other than P-256/P-384; RSA PKCS#1 v1.5 and ECDSA P-256/P-384 are required, RSASSA-PSS is optional); no_signer (the token has no SignerInfo, or the signer certificate is neither in the token nor among the supplied certificates). Nothing is reported for an absent token: receipt_timestamp is already none for a missing record token, and CRITERIA_COMMITMENT_UNVERIFIED already flags a missing criteria token. tsa_signature never changes any other outcome member. When a token has more than one defect, the value is failed if any check that can run fails; otherwise no_signer, then unsupported, then untrusted. A check that cannot run (no signer certificate, an algorithm the verifier does not implement) does not stop the others. An issuer in the token that fails a check (for example, not valid at genTime) is failed whether or not the chain reaches a supplied anchor (vector 54).

If timestamp.status is none, or no token is supplied to the verifier, the record is still valid but carries no verified time; the reference time for section 7 is then issued_utc, the checker's own claim. If a token is supplied but its imprint is not the record digest (step 2), the verifier reports receipt_timestamp: imprint_mismatch, MUST NOT use that timestamp as evidence of time (the reference time falls back to issued_utc) and SHOULD show the mismatch prominently. This profile defines no problem code for it; the outcome field receipt_timestamp carries it.

7. The criteria commitment rule

Criteria are fixed by the buyer or by a published criteria set before the check, and the commitment is publicly timestamped, so no party can adjust the criteria after seeing the result.

7.1 The criteria document

A JSON object with members: criteria_set (string, equals receipt.criteria.id), version (string, equals receipt.criteria.version), title, result_vocabulary (the array ["pass","fail","not-evaluated","error"]), and criteria: an array of {"id", "title", "requirement", "required"} where requirement is a plain-language statement of what must be true and required is a boolean. The published file is the JCS serialisation of that object with no trailing newline, so the file bytes are the canonical bytes.

7.2 Commitment

The commitment digest is the SHA-256 of the exact file bytes. It is timestamped with RFC 3161 and the token is published beside the file. A criteria document is immutable once committed: any change is a new version.

7.3 Verification

  1. Criteria hash. If the criteria document is supplied, compute SHA-256 of its bytes; it MUST equal receipt.criteria.sha256, else CRITERIA_HASH_MISMATCH. When the hash matches, criteria_set and version in the document MUST equal criteria.id and criteria.version, and the set of (id, required) pairs in the document MUST equal the set of (id, required) pairs in results, else CRITERIA_RESULTS_MISMATCH.
  2. Token over the claimed hash. If a timestamp token is supplied, its messageImprint MUST equal criteria.sha256 (the hash the record claims, whether or not the document itself was supplied), with hashAlgorithm SHA-256 (section 6 step 2), else CRITERIA_TIMESTAMP_MISMATCH (a token over other bytes, or under another algorithm). The authority's time (genTime) in the token is authoritative for when the criteria were committed.
  3. committed_at against the token. receipt.criteria.committed_at is the checker's own claim. If a token that covers criteria.sha256 is supplied and committed_at differs from its genTime (ISO 8601 UTC, to the second), the problem is CRITERIA_TIME_MISMATCH, and the token's time is used from here on.
  4. No usable token. Without a token, or with a token that does not cover criteria.sha256 (step 2), or whose genTime is not usable (section 6 step 5), the verifier falls back to committed_at and MUST emit the warning CRITERIA_COMMITMENT_UNVERIFIED: the commitment time is then only the checker's own claim.
  5. Committed before the check. The commitment time is the token's genTime when a covering token was supplied, else committed_at. The reference time is the earlier of issued_utc and the genTime of the record's own token, when one was supplied that covers this record (section 6); else issued_utc. A covering token proves the record existed by its time, so it bounds the check from above; it never moves the signed issue time later (vector 22). The criteria were committed before the check iff the commitment time is strictly earlier than the reference time, after widening each token time by its stated accuracy (section 6 step 4). If not, the result is criteria_committed_before_check: no and CRITERIA_COMMITTED_AFTER_CHECK, which is a problem (it makes the record not acceptable as stated), never a warning. A verifier SHOULD display "criteria committed before check: yes/no".
  6. Stated times. committed_at and issued_utc MUST be RFC 3339 UTC times in the form YYYY-MM-DDTHH:MM:SS[.fff]Z: a fraction of one to three digits is optional, Z is required, and the calendar fields are real as in section 6 step 5. If one of them is present (not absent, null or empty) but is not in this form, and it is used in step 5, the verifier reports RECEIPT_TIME_UNREADABLE and criteria_committed_before_check: no. It is not reported as CRITERIA_COMMITTED_AFTER_CHECK, and no other comparison is made with that time. A malformed time never makes a verifier fail (vector 76). When a covering token supplies the commitment time, committed_at is not used in step 5 and its difference from the token is CRITERIA_TIME_MISMATCH as before, also when it is not in this form (vector 88).

8. Independence and self-checked

A check by the party that produced the file is a self-check, not an independent check. The record declares both parties.

  1. parties.checker.key_id MUST equal the key identifier the signature was checked under (section 5), else CHECKER_NOT_SIGNER.
  2. If parties.checker.key_id and parties.producer.key_id are both non-null and equal, the record is invalid for independence purposes: KEY_COLLISION.
  3. Derivation of independence (verifiers recompute it and report INDEPENDENCE_INCONSISTENT on mismatch): let p be the producer name trimmed and lower-cased. If p is empty, unspecified or unknown: undeclared. Else if p equals the checker name trimmed and lower-cased, or the producer's and the checker's key identifiers resolve to the same key (item 6): self-checked. Otherwise independent, subject to items 5 and 6.
  4. A verifier MUST show a prominent warning, SELF_CHECKED, for self-checked records, and SHOULD show PRODUCER_UNDECLARED for undeclared ones. A self-checked record is not an invalid record; it is a record that must not be read as independent.
  5. Independence is checked by key only when a key identifier is stated. A producer with no key_id (absent or null) is the normal form, because producers do not sign: the claim then rests on the party names alone (vector 82). When a party's key_id is stated and the record states independence: independent, that key_id MUST be non-empty and listed exactly once in the key list. Otherwise the derived independence is self-checked, which differs from the stated value and is reported as INDEPENDENCE_INCONSISTENT (vectors 80 and 81).
  6. An independence claim requires the producer's and the checker's key identifiers, when both are stated, to resolve through the key list to distinct keys. The keys are compared as decoded bytes, not as strings: two identifiers whose entries decode to the same public key are one key, and are treated exactly as equal identifiers (KEY_COLLISION, self-checked; vector 65). A key-list entry for a stated producer or checker identifier that is not canonical base64 is KEY_REJECTED, and independence is derived as self-checked (vector 69).
  7. This specification checks independence as declared and as bound to keys. It cannot detect two legally related parties that use different names and keys; a buyer's contract should address that.

9. Result vocabulary and the overall verdict

Per-criterion results
resultMeaning
passThe requirement was evaluated and met.
failThe requirement was evaluated and not met.
not-evaluatedThe requirement could not be evaluated for this file or has not been evaluated yet (for example no human review). Stated, never hidden.
errorAn evaluation was attempted and failed to complete. Not a pass, not a fail.

Any other value is RESULT_VOCABULARY.

Derivation of verdict

function verdict(results, human_review):
  if human_review.status == "complete" and human_review.outcome == "fail": return "fail"
  required = [r.result for r in results if r.required]
  if "fail" in required:                                        return "fail"
  if required is empty or any(x != "pass" for x in required):   return "incomplete"
  return "pass"

So the verdict is pass only if every required criterion is pass. A required criterion that is not-evaluated or error yields incomplete: incomplete is never pass. A non-required criterion that is not evaluated does not change the verdict. A required fail takes precedence over incomplete: if any required criterion is fail the verdict is fail whatever else is not-evaluated or error; otherwise any required not-evaluated or error gives incomplete; otherwise pass. A verifier recomputes the verdict from results and human_review; if it differs from the stated verdict, the problem is VERDICT_MISMATCH, and the stated verdict MUST NOT be presented as established.

10. Verification procedure and reported outcome

  1. Parse JSON. Require the members of section 3.1. Require schema, canonicalization and suite to be exactly the values in section 3.2; otherwise reject the record as unsupported. Every object, array and string the procedure reads MUST have the type this specification gives it (for example a result's id is a string and its required is a boolean or absent); a record or input of any other type is refused in the same way, with no outcome members, and never causes a verifier to fail (vector 77).
  2. Verify the signature (section 5). On failure report SIGNATURE_INVALID. A verifier SHOULD still run the remaining checks and report their outcome (they are diagnostics about an unsigned document), but MUST NOT present the record's verdict or findings to a reader as results.
  3. If the delivered file is in hand: its SHA-256 MUST equal files.remediated.sha256; otherwise the record is not about this file.
  4. Verify the timestamp if present (section 6).
  5. Verify the criteria commitment (section 7).
  6. Check parties and independence (section 8).
  7. Check the vocabulary and recompute the verdict (section 9).

The record is accepted as stated when the signature is valid and the list of problem codes is empty. Warnings do not make it invalid but MUST be shown.

Problem and warning codes
CodeKindRaised when
SIGNATURE_INVALIDproblemUnknown key id, or the signature does not verify.
CHECKER_NOT_SIGNERproblemparties.checker.key_id differs from signature.key_id.
KEY_REJECTEDproblemThe signing key is not a canonical, prime-order Ed25519 public key (section 5); no signature check was run. Also: a key identifier is listed more than once in the key list, or the key entry of a stated producer or checker identifier is not canonical base64.
KEY_COLLISIONproblemChecker and producer declare the same key.
INDEPENDENCE_INCONSISTENTproblemStated independence differs from the derived value.
RESULT_VOCABULARYproblemA result is not one of the four values.
VERDICT_MISMATCHproblemStated verdict differs from the verdict recomputed by the rule in section 9.
CRITERIA_HASH_MISMATCHproblemThe criteria document's SHA-256 differs from criteria.sha256.
CRITERIA_RESULTS_MISMATCHproblemResults do not correspond to the committed criteria (ids, required flags, set id or version).
CRITERIA_TIMESTAMP_MISMATCHproblemThe criteria token's imprint is not criteria.sha256 (a token over other bytes).
CRITERIA_TIME_MISMATCHproblemcriteria.committed_at differs from the genTime of the token over criteria.sha256 (the token is authoritative).
CRITERIA_COMMITTED_AFTER_CHECKproblemCommitment time is not strictly earlier than the reference time. A problem, not a warning.
RECEIPT_TIME_UNREADABLEproblemcommitted_at or issued_utc is present but is not an RFC 3339 UTC time YYYY-MM-DDTHH:MM:SS[.fff]Z with real calendar fields (section 7.3 step 6). criteria_committed_before_check is no.
SELF_CHECKEDwarningindependence is self-checked.
PRODUCER_UNDECLAREDwarningThe parties block declares no producer, so independence derives as undeclared, whatever the record states. A stated value that differs is also INDEPENDENCE_INCONSISTENT.
CRITERIA_COMMITMENT_UNVERIFIEDwarningNo usable timestamp token over criteria.sha256 was supplied (none, or one over other bytes), so committed_at (the checker's own claim) was used.

Payment (receipt.payment, profile 1.4.1). Optional and outcome-neutral: no member of the outcome depends on it. A verifier with access to the named network MAY report, separately: verified (the token's EIP-3009 authorizationState(payer, nonce) is used and, given settlement_tx, that transaction succeeded, emitted AuthorizationUsed(payer, nonce) and Transfer(payer, pay_to, amount) from asset, in a block no later than issued_utc); authorization_used (the nonce is used but no settlement_tx was given, so amount and payee are unchecked); not_found; mismatch; or unsupported. The reference implementation is check_payment.py.

11. SAR profile: how the record answers a Supplemental Accessibility Conformance Report

The GSA model language on defining accessibility criteria (Section508.gov, reviewed March 2026) already asks the contractor to validate conformance, to provide a Supplemental Accessibility Conformance Report (SAR) before acceptance, and reserves the agency's right to test independently. The record is a verifiable output for that step. It does not replace the buyer's decision or its independent testing right.

SAR needs mapped to record fields
SAR needWhere the record answers it
What was testedfiles.remediated: name, pages, bytes and sha256. The digest binds the statement to the exact delivered bytes.
Requirements tested againstcriteria.id, criteria.version, criteria.sha256, criteria.committed_at and the committed criteria document (each criterion's id, title, requirement, required); optionally criteria_commitment for client-agreed terms.
Results and limitationsresults[] (result, finding, required) including not-evaluated and error rows; human_review.scope and status; the notice statement. Limitations are the non-pass rows, the human-review scope and the notice.
Who checkedparties.checker (name, key identifier), tools (validator versions), independence relative to parties.producer.
Audit trailsignature, timestamp (RFC 3161), receipt_id, revision, supersedes_sha256, and the verification procedure in section 10 of this page.
Acceptance decisionNot in the record. The decision to accept or reject is the buyer's, made separately, and SHOULD cite the record digest sha256(JCS(receipt)) of the record it relied on.

12. EARL export (optional)

A record can be exported as W3C EARL (Evaluation and Report Language) in JSON-LD. The export is a convenience view; the signed record is authoritative.

EARL mapping
EARLSource in the record
earl:AssertionOne per entry of results.
earl:subject (earl:TestSubject)The delivered file: dct:identifier is sha256: followed by files.remediated.sha256.
earl:assertedByparties.checker (name, key identifier).
earl:testThe criterion, identified by criteria set, version, criteria.sha256 and the criterion id.
earl:outcomepass to earl:passed; fail to earl:failed; error to earl:cantTell; not-evaluated to earl:untested.
earl:modeearl:automatic, except the human-review criterion: earl:manual.

13. Test vectors (CC0)

Eighty-seven self-contained vectors let a clean-room verifier prove itself (01 to 05, 24 to 49, 51 to 55, 57 and 60 to 83 by Trilatic Desks; 06 to 11, 22 and 23 contributed by babyblueviper1; 12 to 21, 50, 58 and 59 contributed by Tetsurohhori; 56, a live receipt from another checker's key, by babyblueviper1; 84 to 87 contributed by actaseal; the cases in 60, 64 to 68 were proposed by actaseal). Each file holds the inputs (the record, a key list, the criteria document and its timestamp token as base64, and optionally the record's timestamp token) and the expected outcome. They are signed with a published test key; never trust a record signed by it. The timestamp tokens in the vectors are imprint-and-time fixtures, not valid RFC 3161 tokens: their SignedData carries no SignerInfo, so a CMS parser that requires a signer (OpenSSL does) refuses them. They exercise imprint and time handling (sections 6 and 7), not authority validation; the live record in the changelog's references carries real tokens. Licence: CC0 1.0.

Vector files
FileCaseExpected outcome
01-valid.jsonValid record, independent checker, criteria committed before the check, with a record timestamp.No problems, no warnings, verdict pass.
02-criteria-committed-after-issue.jsonCriteria timestamp later than the check.CRITERIA_COMMITTED_AFTER_CHECK; committed before check: no.
03-self-checked.jsonProducer is the checker.Warning SELF_CHECKED; independence self-checked; no problems.
04-required-not-evaluated.jsonA required criterion is not-evaluated.No problems; recomputed verdict incomplete, never pass.
05-checker-key-equals-producer-key.jsonProducer declares the checker's own key.KEY_COLLISION and warning SELF_CHECKED.
06-receipt-edited-after-signing.jsonA finding edited after signing. Contributed by babyblueviper1 (CC0).SIGNATURE_INVALID; the other checks still report; receipt timestamp imprint_mismatch.
07-criteria-file-swapped.jsonAnother criteria document is supplied. Contributed by babyblueviper1 (CC0).CRITERIA_HASH_MISMATCH only; the token over the claimed hash still gives committed before check: yes.
08-receipt-token-over-another-receipt.jsonThe record's timestamp token covers a different record. Contributed by babyblueviper1 (CC0).No problem code; receipt timestamp imprint_mismatch (see section 6).
09-stated-pass-recomputes-incomplete.jsonSigned verdict pass with a required criterion not-evaluated. Contributed by babyblueviper1 (CC0).VERDICT_MISMATCH; recomputed verdict incomplete.
10-committed-at-contradicts-token.jsoncommitted_at is before the check but the criteria token's genTime is after it. Contributed by babyblueviper1 (CC0).CRITERIA_TIME_MISMATCH and CRITERIA_COMMITTED_AFTER_CHECK.
11-required-criterion-fails.jsonA required criterion fails. Contributed by babyblueviper1 (CC0).No problems; verdict fail.
12-signer-is-not-the-checker.jsonThe signed receipt.key_id and the envelope both name test-2; parties.checker.key_id names test-1. Contributed by Tetsurohhori (CC0).CHECKER_NOT_SIGNER only.
13-independent-but-same-party.jsonStated independent, but producer and checker are the same party. Contributed by Tetsurohhori (CC0).INDEPENDENCE_INCONSISTENT.
14-results-not-in-criteria.jsonResults do not correspond to the criteria document. Contributed by Tetsurohhori (CC0).CRITERIA_RESULTS_MISMATCH.
15-criteria-token-over-other-bytes.jsonThe criteria token covers other bytes. Contributed by Tetsurohhori (CC0).CRITERIA_TIMESTAMP_MISMATCH; fallback to committed_at with warning CRITERIA_COMMITMENT_UNVERIFIED.
16-no-criteria-token.jsonNo criteria token. Contributed by Tetsurohhori (CC0).Warning CRITERIA_COMMITMENT_UNVERIFIED.
17-committed-at-equals-reference.jsonCommitment time equals the reference time. Contributed by Tetsurohhori (CC0).CRITERIA_COMMITTED_AFTER_CHECK (strictly earlier is required).
18-mismatching-record-token-later-time.jsonThe record token covers other bytes and states a later time. Contributed by Tetsurohhori (CC0).Not used as time; CRITERIA_COMMITTED_AFTER_CHECK.
19-result-outside-vocabulary.jsonA result passed. Contributed by Tetsurohhori (CC0).RESULT_VOCABULARY and VERDICT_MISMATCH.
20-producer-undeclared.jsonNo producer declared, stated independent. Contributed by Tetsurohhori (CC0); expectation amended, difference stated in the file.INDEPENDENCE_INCONSISTENT and warning PRODUCER_UNDECLARED.
21-unknown-schema.jsonAn unknown schema. Contributed by Tetsurohhori (CC0).Refused: {"refused": true, "reason": ...}.
22-matching-record-token-later-than-issued.jsonA covering record token later than issued_utc, criteria between the two. Contributed by babyblueviper1 (CC0).Reference time is issued_utc; CRITERIA_COMMITTED_AFTER_CHECK.
23-criteria-token-imprint-oid-sha384.jsonCriteria token imprint algorithm SHA-384, same length, same 32 bytes. Contributed by babyblueviper1 (CC0).CRITERIA_TIMESTAMP_MISMATCH and the fallback warning.
24-criteria-token-imprint-oid-sha3-256.jsonAs 23 with SHA3-256 (case from robertolocatelli81-dev).As 23.
25-criteria-token-imprint-oid-sha512-256.jsonAs 23 with SHA-512/256 (case from robertolocatelli81-dev).As 23.
26-key-small-order.jsonThe key list holds the neutral point; the signature (R = neutral, S = 0) satisfies the cofactorless equation for any message.KEY_REJECTED; signature not valid.
27-key-non-canonical-encoding.jsonThe key list holds a non-canonical encoding (y = p + 1) of the neutral point.KEY_REJECTED; signature not valid.
28-key-file-with-unrelated-bad-entry.jsonThe key list holds an unrelated small-order entry, listed before the valid signing key that the record names (case from robertolocatelli81-dev).As vector 01: no problems. The key rule applies to the named signing key only.
29-criteria-token-accuracy-flips-commitment.jsonThe criteria token's genTime is 30 s before the check, but the token states an accuracy of 60 s (case from robertolocatelli81-dev).CRITERIA_COMMITTED_AFTER_CHECK; committed before check: no. A verifier that ignores accuracy reports yes.
30-criteria-token-accuracy-millis-still-before.jsonControl for 29: the same times with an accuracy of 500 ms (the millis field).No problems; committed before check: yes.
31-tsa-freetsa-verified.jsonLive FreeTSA tokens over the criteria and the record; FreeTSA root as anchor.tsa_signature: criteria and receipt verified; no problems.
32-tsa-digicert-verified.jsonLive DigiCert tokens over the criteria and the record; DigiCert Trusted Root G4 as anchor.Both verified.
33-tsa-unrelated-root-untrusted.jsonVector 31's tokens with an unrelated anchor (DigiCert root).Both untrusted.
34-tsa-tampered-signature-failed.jsonVector 31 with one bit flipped in the criteria token's signature; imprint and time unchanged.Criteria failed, receipt verified; every other member as 31.
35-tsa-token-without-signer-certificate.jsonA live FreeTSA criteria token requested with certReq=false; no record token.Criteria no_signer.
36-tsa-no-anchors-not-evaluated.jsonVector 31's tokens with no anchors supplied.Both not_evaluated (an omitted field reads the same).
37-tsa-synthetic-control-verified.jsonA criteria token from a test-only PKI (root, intermediate, TSA), test root as anchor; control for 38 and 39.Criteria verified.
38-tsa-intermediate-expired-failed.jsonAs 37, but the intermediate CA expired before genTime; the TSA certificate is still valid.Criteria failed.
39-tsa-content-type-mismatch-failed.jsonAs 37, but the signed contentType attribute is id-ct-authData; the signature itself is valid.Criteria failed.
40-tsa-rsassa-pss-verified.jsonAs 37, signed with RSASSA-PSS (SHA-256, MGF1-SHA-256, salt 32).Criteria verified; unsupported also conforms (PSS is optional).
41-tsa-ecdsa-p256-verified.jsonAs 37, with an ECDSA P-256 TSA key.Criteria verified.
42-tsa-ecdsa-p521-unsupported.jsonAs 37, with an ECDSA P-521 TSA key.Criteria unsupported.
43-tsa-empty-anchor-list-not-evaluated.jsonVector 31's tokens with tsa_roots_base64 present but empty.Both not_evaluated, as 36.
44-tsa-unsupported-curve-and-bad-digest-failed.jsonAs 42 (P-521), with a messageDigest attribute that does not match.Criteria failed.
45-tsa-no-certificates-and-bad-digest-failed.jsonA test-PKI token without certificates (as 35), with a messageDigest attribute that does not match.Criteria failed.
46-tsa-unsupported-curve-and-ess-mismatch-failed.jsonAs 42 (P-521), with an ESS signing-certificate hash that does not match.Criteria failed.
47-receipt-payment-x402-exact.jsonA passing receipt whose signed body carries payment (x402 exact on Base, synthetic values).No problems; the same outcome as without the member.
48-tsa-signer-without-timestamping-eku-failed.jsonA test-PKI token (root B) whose signer certificate lacks id-kp-timeStamping; everything else holds.Criteria failed.
49-tsa-issuer-not-a-ca-failed.jsonA test-PKI token (root B) whose TSA certificate is issued by a certificate without the CA flag; everything else holds.Criteria failed.
50-criteria-token-imprint-only-in-status-string.jsonContributed by Tetsurohhori. Vector 31 with the criteria token replaced by the record token; the criteria imprint and time sit only in the unsigned statusString.CRITERIA_TIMESTAMP_MISMATCH, warning CRITERIA_COMMITMENT_UNVERIFIED; tsa_signature both verified.
51-record-token-imprint-only-in-status-string.jsonThe record-token side of 50: the receipt's imprint and time sit only in the unsigned statusString of the criteria token placed as the record token.receipt_timestamp imprint_mismatch; no problems.
52-receipt-non-integer-numbers.jsonA passing receipt whose signed body holds non-integer numbers.No problems (a canonicalizer outside RFC 8785's number form reports SIGNATURE_INVALID).
53-tsa-anchor-same-name-other-key-untrusted.jsonVector 37's token; the only anchor is root B, with root A's name and another key.Criteria untrusted.
54-tsa-expired-intermediate-no-anchor-failed.jsonVector 38's token (intermediate expired) with an unrelated anchor.Criteria failed.
55-receipt-payment-outside-the-form.jsonAs 47, with payment.amount a JSON number and an extra member.No problems; the same outcome as without the member.
56-third-party-checker-live-receipt.jsonContributed by babyblueviper1: a live receipt issued by their checker under its own key (a self-test, not a real job), kept as received.No problems.
57-receipt-integer-valued-doubles.jsonA passing receipt whose signed body holds 1.0, 100.0, -0.0 and 300.0.No problems; RFC 8785 writes them 1, 100, 0, 300.
58-criteria-token-imprint-only-in-unsigned-attribute.jsonAs 50, with the criteria imprint and time in an unsigned attribute of the token's SignerInfo instead of the statusString (a well-formed response); contributed by Tetsurohhori.CRITERIA_TIMESTAMP_MISMATCH; fallback with warning CRITERIA_COMMITMENT_UNVERIFIED.
59-record-token-imprint-only-in-unsigned-attribute.jsonThe record-token side of 58, as 51; contributed by Tetsurohhori.receipt_timestamp imprint_mismatch; no problems.
60-signature-base64-invalid-character.jsonA ! inside signature.value; a lax decoder discards it and the signature verifies.signature_valid false; SIGNATURE_INVALID.
61-signature-base64-internal-whitespace.jsonA space inside signature.value.signature_valid false; SIGNATURE_INVALID.
62-signature-base64-noncanonical-trailing-bits.jsonThe last base64 character of signature.value carries non-zero trailing bits: the same 64 bytes under a different string.signature_valid false; SIGNATURE_INVALID.
63-signature-base64-missing-padding.jsonsignature.value with its = padding removed.signature_valid false; SIGNATURE_INVALID.
64-envelope-key-id-differs-from-signed-key-id.jsonThe envelope signature.key_id names another key from the one inside the signed receipt; the key list holds both, with the same public key.signature_valid false; SIGNATURE_INVALID only.
65-one-public-key-under-two-key-ids.jsonThe producer's key identifier differs from the checker's, but both entries in the key list hold the same public key.KEY_COLLISION; warning SELF_CHECKED; independence self-checked.
66-criteria-gentime-fraction-makes-it-after-issue.jsonThe criteria token's genTime is 12:00:00.5; issued_utc is 12:00:00.250. Read to the second the criteria are earlier; with the fraction they are later.CRITERIA_COMMITTED_AFTER_CHECK; criteria_committed_before_check no.
67-criteria-sha256-upper-case.jsoncriteria.sha256 written in upper-case hex (re-signed).CRITERIA_HASH_MISMATCH, CRITERIA_TIMESTAMP_MISMATCH.
68-criteria-time-equals-issue-time-at-millisecond.jsonThe criteria genTime 12:00:00.2495 rounds up to .250, which equals issued_utc 12:00:00.250.CRITERIA_COMMITTED_AFTER_CHECK; no (strict <).
69-key-alias-noncanonical-base64-dodges-same-key.jsonThe producer's key entry is the checker's key with its last character changed (non-canonical base64).KEY_REJECTED; independence self-checked.
70-criteria-gentime-with-offset.jsonThe criteria token's genTime is 20260301010000+0100.No usable time: warning CRITERIA_COMMITMENT_UNVERIFIED; no problems.
71-criteria-gentime-month-13.jsonThe criteria token's genTime has month 13.No usable time: warning CRITERIA_COMMITMENT_UNVERIFIED; no problems.
72-criteria-gentime-feb-30.jsonThe criteria token's genTime is 30 February.No usable time: warning CRITERIA_COMMITMENT_UNVERIFIED; no problems.
73-criteria-gentime-comma-fraction.jsonThe criteria token's genTime uses a comma as the fraction separator.No usable time: warning CRITERIA_COMMITMENT_UNVERIFIED; no problems.
74-criteria-gentime-trailing-zero-fraction.jsonThe criteria token's genTime fraction ends in a zero (.5000).No usable time: warning CRITERIA_COMMITMENT_UNVERIFIED; no problems.
75-duplicate-key-id-in-keys-file.jsonThe checker's key identifier is listed twice in the key list.signature_valid false; KEY_REJECTED.
76-committed-at-malformed.jsoncommitted_at is 2026-13-01T00:00:00Z and no criteria token is supplied.RECEIPT_TIME_UNREADABLE; criteria_committed_before_check no; warning CRITERIA_COMMITMENT_UNVERIFIED.
77-result-id-is-an-object.jsonA result's id is an object, not a string.Refused, as for an unsupported schema.
78-token-imprint-matches-gentime-unusable.jsonThe criteria token covers criteria.sha256 but its genTime is month 13.As with no token: warning CRITERIA_COMMITMENT_UNVERIFIED; the time comes from committed_at; no problems.
79-unrelated-duplicate-key-id.jsonA key identifier that is neither the producer's nor the checker's is listed twice in the key list.KEY_REJECTED; the signature is still valid.
80-independent-claim-producer-key-id-empty.jsonIndependence is claimed; the producer's key_id is the empty string.INDEPENDENCE_INCONSISTENT (derived self-checked).
81-independent-claim-producer-key-id-unknown.jsonIndependence is claimed; the producer's key_id is not in the key list.INDEPENDENCE_INCONSISTENT (derived self-checked).
82-independent-claim-producer-key-id-absent.jsonIndependence is claimed; the producer states no key_id. The control for 80 and 81: independence rests on the names.No problems, no warnings; independence independent.
83-tsa-signer-info-unsigned-attributes-ignored.jsonVector 37's criteria token with an unsignedAttrs field holding one arbitrary attribute appended to its SignerInfo (DER lengths corrected; not covered by the signature).Identical to vector 37: tsa_signature.criteria verified.
84-receipt-exponent-numbers.jsonContributed by actaseal: a passing receipt whose signed body holds numbers that RFC 8785 writes in exponent form with more than one significant digit (1.5e-7, 1.25e+22, 1.234e-10, 9.87654321e-8, 2.5e+21).No problems.
85-receipt-key-outside-bmp.jsonContributed by actaseal: a passing receipt whose signed body has an object with keys z, U+1F600 and U+FF61. Sorting by UTF-16 code units puts U+1F600 before U+FF61; sorting by code point reverses them and breaks the signature.No problems.
86-envelope-key-id-differs-from-signed.jsonContributed by actaseal: signed with key A; the signed key_id and parties.checker.key_id name A; the unsigned envelope signature.key_id names B, which is also in the key list.signature_valid false; SIGNATURE_INVALID only.
87-same-key-under-two-ids.jsonContributed by actaseal: as 05, but the producer names a different key_id whose entry in the key list holds the same public key as the checker's.KEY_COLLISION; warning SELF_CHECKED; independence self-checked.
88-committed-at-malformed-with-token.jsonCase proposed by Tetsurohhori: committed_at is 2026-13-01T00:00:00Z and a valid criteria token is supplied, so step 5 takes the time from the token.CRITERIA_TIME_MISMATCH, not RECEIPT_TIME_UNREADABLE; criteria_committed_before_check yes.
89-criteria-file-base64-noncanonical.jsonThe criteria file's base64 has a space inside.It matches nothing: CRITERIA_HASH_MISMATCH; criteria_hash mismatch; not refused.
90-criteria-token-base64-noncanonical.jsonThe criteria token's base64 has a space inside.It matches nothing: CRITERIA_TIMESTAMP_MISMATCH; warning CRITERIA_COMMITMENT_UNVERIFIED; not refused.

The expected object has these members: signature_valid (boolean), problem_codes and warning_codes (sorted arrays of codes from section 10), independence, criteria_hash (match, mismatch or unavailable), criteria_committed_before_check (yes, no or unknown), verdict_stated, verdict_recomputed, optionally tsa_signature (an object with keys criteria and/or receipt, section 6; vectors 31 to 46, 48 and 49 carry relying-party anchors as inputs.tsa_roots_base64, a list of base64 DER certificates; where a vector's top-level tsa_signature_accepted lists other values for a token, any of them also conforms), and receipt_timestamp (none, imprint_match or imprint_mismatch). A vector whose record must be refused at step 1 (vector 21) instead expects {"refused": true, "reason": "unknown schema, canonicalization or suite"}. A conforming verifier reproduces every member for every vector. problem_codes and warning_codes are sets: compare them without regard to order. receipt_timestamp is none when the record has no timestamp or no token was supplied. The key list in a vector's inputs is the key that signed it; keys differ between vectors, and every one is a test key.

Implementations

Verifiers written from this text, each run by its implementer on the published vectors. Every row links that implementer's own run file at a fixed commit; the result and the disclosure are theirs, as posted.

Implementations and their posted runs
ImplementerCodeVectorsResultAs disclosed by the implementer
TetsurohhoriPython, cryptography01 to 87 at 85a310d87/87Written from the 1.4.2 rule text; reference verifier not opened; answer-exposed (the 1.4.1 verifier was scored on the 87 first); 66, 68 and 77 corrected after seeing them.
TetsurohhoriPython, cryptography01 to 57 at bc5a13857/57Written from the text; reference verifiers not opened; expected objects visible while the inputs were read.
babyblueviper1Python, cryptography01 to 55 at 6b2f73055/55Written from the text; reference not opened; expected objects visible while the inputs were read.
robertolocatelli81-devPython01 to 47 at 06d3b9447/47 (441/441 fields)Written from the text; reference verifiers not opened.
ReferencePython standard library; JavaScript (WebCrypto) on this page01 to 9090/90Written with the vectors.

The other direction: receipts issued by another checker under its own key (babyblueviper1's invinoveritas checker) pass the reference verifier unchanged, with the FreeTSA and DigiCert roots of vectors 31 and 32 as anchors (run); one of them is vector 56. To be listed, open an issue on the reference repository that links your code and a run file at a published commit.

15. Changelog

Profile 1.4.2, 2026-10-24 (schema identifier unchanged)

Closes readings that let a malformed or ambiguous input pass. Vectors 01 to 57 and their outcomes are unchanged; vectors 58 and 59 (contributed by Tetsurohhori) and 60 to 87 are added.

Profile 1.4.1, 2026-10-21 (schema identifier unchanged)

Settles readings raised by clean-room verifiers of 1.4 (Tetsurohhori; robertolocatelli81-dev) in x402-foundation/tsc#4. Vectors 01 to 36 and their outcomes are unchanged. Vectors 37 to 42 and 44 to 46 use tokens from a test-only PKI (provenance in VECTORS_PROVENANCE.md).

Not exercised by a live authority: RSASSA-PSS and ECDSA P-256 (the live vectors use RSA PKCS#1 v1.5 and ECDSA P-384). Revocation is not checked. No further outcome changes to profile 1.4.1 before 2026-11-21; reports of disagreement are collected and answered together.

Added 2026-10-21, outcome-neutral: the optional body member payment (section 3.2), so a record can carry the x402 payment it concerns inside the signed and timestamped bytes (asked for by babyblueviper1 in x402-foundation/tsc#4, from a live record paid on Base). Vector 47; chain check in check_payment.py.

Clarified 2026-10-21, outcome-neutral (from babyblueviper1's run in x402-foundation/tsc#4): the anchor is matched by subject name and public key, not by certificate bytes (vector 32 separates the two readings); vectors 48 and 49 exercise the id-kp-timeStamping and CA-flag rules, which no earlier vector isolated.

Clarified 2026-10-22, outcome-neutral for every earlier vector (from Tetsurohhori and robertolocatelli81-dev in x402-foundation/tsc#4): imprint, genTime and accuracy are read from the token's signed TSTInfo only, never from other bytes of a response (vectors 50 and 51); numbers follow RFC 8785's ECMAScript form, including non-integers (vector 52). Both reference verifiers follow these readings from this version.

Clarified 2026-10-22, outcome-neutral for every earlier vector (from robertolocatelli81-dev's run): an anchor with the issuer's name but another key does not match, so only such anchors failing is untrusted (53); an issuer in the token that fails a check is failed even when no chain reaches an anchor (54); the payment form is stated, and a member outside it changes no outcome (55). An anchor itself is not checked for validity at genTime, and keys outside RSA PKCS#1 v1.5, RSASSA-PSS and ECDSA P-256/P-384 (for example Ed25519) are unsupported.

Added 2026-10-23, outcome-neutral: vector 56, contributed by babyblueviper1, the first receipt in the set issued by another checker under its own key; vector 57, integer-valued doubles and negative zero, which RFC 8785 writes without a fraction or sign (from stillmarcus24's note in x402-foundation/tsc#4).

Edited 2026-10-23: the descriptions of vectors 37-42, 44-46, 48, 49, 53 and 54 now point to the provenance on the spec site; inputs and expected outcomes are unchanged.

Profile 1.4, 2026-10-20 (schema identifier unchanged)

Adds the authority-signature outcome requested in x402-foundation/tsc#4 (magentixai), as committed there: an additive outcome field tsa_signature per token present, not_evaluated without relying-party anchors (an absent field reads the same), so vectors 01 to 30 and existing verifiers are unchanged. With anchors: verified, failed, untrusted, unsupported or no_signer (section 6), including the ESS signing-certificate binding and a CA check on intermediate issuers. Vectors 31 to 36 are built from live FreeTSA and DigiCert tokens; their provenance is in VECTORS_PROVENANCE.md.

Profile 1.3, 2026-10-18 (schema identifier unchanged)

Resolves the questions raised by two more clean-room verifiers (Tetsurohhori; robertolocatelli81-dev) and a second run by babyblueviper1, in x402-foundation/tsc#4. Vectors 12 to 21 contributed by Tetsurohhori, 22 and 23 by babyblueviper1 (CC0); 24 to 27 added from robertolocatelli81-dev's cases.

Profile 1.2.1, 2026-10-17 (schema identifier unchanged)

Resolves ambiguities reported by an independent clean-room verifier, written from this specification alone and run against the first five vectors; credit to babyblueviper1, who also contributed vectors 06 to 11 (CC0).

Profile 1.2, 2026-10-17

First published profile, with vectors 01 to 05.

14. Security considerations and limits

See also the in-browser verifier (nothing is uploaded), the model acceptance clause, and the acceptance criteria. Specification text © Trilatic Desks, CC BY 4.0. Test vectors CC0 1.0.