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: Giving alternate names interferes with pass-through logic across the pipeline. Maybe we can get a more robust story, inspired a bit by (I'm just assuming this is one of the main use cases here) is to say: The text representation of is what it is. If this part of the system uses the text form, use the existing syntax The structured field representation of is this mapped thing. If this part of the system uses structured fields, use that syntax At boundaries where forms change, convert. We need to be a bit careful about fallibility here, but perhaps: Conversion from text to other forms is allowed to fail, since you can just fallback to the text form. Conversion from other forms to text probably needs to be stricter? The difference between mapped and normal fields is the structured field and text representations don't directly align, so they need to be treated a bit special Like I said, this is handwaivy and definitely incomplete. But it feels to me like something in this might be more sound. It makes it more obvious we have to be sure what representation we're using at each layer and there's no risk of one side thinking something is a generic header and another thinking it's an alternative representation of a special header.
This seems like a plausible risk to me. I'm not as familiar with non-browser use cases, but I can certainly imagine confusion that would result from clients being able to create mismatches between and . I can imagine ways to deal with this in browsers (in addition to NAME suggestions, we could add as a , just as we've done for and ). It's unclear how helpful that would be for non-browser usecases.
Main nuisance with prefix is that, on the receiver side, you don't know a priori if the client is an updated browser, which knows about the prefix, or a preexisting browser which does not. I suppose you could do UA sniffing, but let's not design a system that requires UA sniffing to work if we can help it! :-)
That's fair. would be safe without a change to Fetch. Still, given my expectations about the current deployment of mapped fields, I think we could reasonably get ahead of them in the browser world. Not at all sure about the rest of the ecosystem...
I like the direction that if you've already negotiated support, you could just replace the legacy headers with their spiffy (SFfy?)