Code change:
2. <del> The HTTP fields listed in compatible-fields can usually have their values handled as Structured Fields according to the listed parsing and serialisation algorithms in STRUCTURED-FIELDS, subject to the listed caveats. </del> <ins> The HTTP fields listed in compatible-fields have values that can be handled as Structured Field Values according to the parsing and serialisation algorithms in STRUCTURED-FIELDS corresponding to the listed top-level type, subject to the caveats in compatible-caveats. </ins> <del> The listed types are chosen for compatibility with the defined syntax of the field as well as with actual internet traffic.  However, not all instances of these fields will successfully parse.  This might be because the field value is clearly invalid, or it might be because it is valid but not parseable as a Structured Field. </del> <ins> The top-level types are chosen for compatibility with the defined syntax of the field as well as with actual internet traffic. However, not all instances of these fields will successfully parse as a Structured Field Value.  This might be because the field value is clearly invalid, or it might be because it is valid but not parseable as a Structured Field. </ins> An application using this specification will need to consider how to handle such field values.  Depending on its requirements, it might be advisable to reject such values, treat them as opaque strings, or <del> attempt to recover a structured value from them in an ad hoc fashion. </del> <ins> attempt to recover a Structured Field Value from them in an ad hoc fashion. 2.1. </ins> Note the following caveats regarding compatibility: 3. Some HTTP field values have syntax that cannot be successfully parsed <del> as Structured Fields.  Instead, it is necessary to map them into a separate Structured Field with an alternative name. </del> <ins> as Structured Field values.  Instead, it is necessary to map them into a Structured Field value. </ins> For example, the Date HTTP header field carries a date: Its value would be mapped to: <del> As in compatible, these fields are unable to carry values that are not valid Structured Fields, and so an application using this specification will need to how to support such values.  Typically, handling them using the original field name is sufficient. Each field name listed below indicates a replacement field name and a means of mapping its original value into a Structured Field. </del> <ins> Unlike those listed in compatible, these representations are not compatible with the original fields' syntax, and MUST NOT be used unless they are explicitly and unambiguously supported.  For example, this means that sending them to a next-hop recipient in HTTP requires prior negotiation.  This specification does not define how to do so. </ins> 3.1. <del> The field names in url-fields (paired with their mapped field names) have values that can be mapped into Structured Fields by treating the original field's value as a String. </del> <ins> The field names in url-fields have values that can be mapped into Structured Field values by treating the original field's value as a String. </ins> <del> For example, this Location field </del> <ins> For example, this Location field: </ins> <del> could be mapped as: </del> <ins> would have a mapped value of: </ins> 3.2. <del> The field names in date-fields (paired with their mapped field names) have values that can be mapped into Structured Fields by parsing their payload according to HTTP and representing the result as a Date. </del> <ins> The field names in date-fields have values that can be mapped into Structured Field values by parsing their payload according to HTTP and representing the result as a Date. </ins> <del> For example, an Expires field could be mapped as: </del> <ins> For example, an Expires field's value could be mapped as: </ins> 3.3. <del> The field value of the ETag header field can be mapped into the SF- ETag Structured Field by representing the entity-tag as a String, and the weakness flag as a Boolean "w" parameter on it, where true </del> <ins> The field value of the ETag header field can be mapped into a Structured Field value by representing the entity-tag as a String, and the weakness flag as a Boolean "w" parameter on it, where true </ins> indicates that the entity-tag is weak; if 0 or unset, the entity-tag is strong. <del> For example, this: </del> <ins> For example, this ETag header field: would have a mapped value of: If-None-Match's field value can be mapped into a Structured Field value which is a List of the structure described above.  When a field value contains "*", it is represented as a Token. </ins> <del> If-None-Match's field value can be mapped into the SF-If-None-Match Structured Field, which is a List of the structure described above. When a field value contains "*", it is represented as a Token. </del> <ins> Likewise, If-Match's field value can be mapped into a Structured Field value in the same manner. </ins> <del> Likewise, If-Match's field value can be mapped into the SF-If-Match Structured Field in the same manner. </del> <ins> For example, this If-None-Match field: </ins> <del> For example: </del> <ins> would have a mapped value of: </ins> 3.4. The field values of the Cookie and Set-Cookie fields COOKIES can be <del> mapped into the SF-Cookie Structured Field (a List) and SF-Set-Cookie Structured Field (a List), respectively. </del> <ins> mapped into Structured Fields Lists. </ins> In each case, a cookie is represented as an Inner List containing two Items; the cookie name and value.  The cookie name is always a

Related discussion:
text: Sorry for noticing this so late. I don't think the security considerations of in retrofit work out. (Also CC NAME who is much better at web security than me.) If we introduce two ways to spell some field, we need to worry about whether this can allow various issues when sender and receiver don't agree on what's going on. The draft mostly leaves this to the future, but it does include some about this: This seems to put the onus on the sender, not the receiver. If you don't know the receiver accepts the alternate representation, you can't send it. It includes no corresponding receiver obligation, I guess on the assumption that if you see SF-Cookie, you can assume the sender meant it? I don't think that works. In a browser, the sender is a combination of browser logic (which has the final say) and JS (with a complex trust relationship). The browser logic specifies some which JS cannot set. Other HTTP systems have similar splits: an HTTP serving frontend may get fields from a CGI script or act as an intermediary, but it cannot allow the downstream code to specify fields like . These rules typically look like a blocklist with the default behavior to pass fields through. All this is to say, browsers won't let JS set the field directly, but setting is perfectly fine, up to CORS rules. A receiver may see that text and incorrectly assume that processing is fine, breaking some cookie invariants. Or vs , which will break some sites' CSRF processing. Beyond just blocklists, a retrofit-unaware HTTP cache that processes caching fields but passes through other fields will likely make a mess of the mapped caching fields. If we prefixed the names with , that would at least meet the browsers' rules, though I worry it'll still break other intermediaries. It's also a little unsatisfying of a fix. We could say that a receiver cannot process these either unless it's received some explicit negotiation that the sender knows about this. That's vague and unspecified, but probably would work, depending on what the intent is here. This is a bit handwaivy because I'm not sure what the use cases are here. But if we require explicit sender and receiver negotiation, it's unclear what we're getting out the parallel field names in the first place. It seems to me that's where all this risk comes from.