{
  "flavors": {
    "ok": "The control, fully correct: strong ETag, Last-Modified, cache-control: no-cache. If-Match (strong compare; * passes), If-Unmodified-Since, If-None-Match (weak compare, lists and * supported; match is 304), If-Modified-Since (ignored when If-None-Match is present, and ignored unless it is a valid HTTP-date). The 304 carries the ETag.",
    "weak": "The only validator is weak: W/\"…\". If-None-Match uses weak comparison, so revalidation works (304). If-Match requires strong comparison and a weak validator never strong-matches, so every If-Match gets 412 — except If-Match: *, which passes. Catches clients that treat W/ as part of the value.",
    "changing": "A different strong ETag on every response, and no Last-Modified (a changing resource with a frozen date would be a second lie). If-None-Match never matches, so a cache revalidates forever and re-downloads every time: thrash. Nondeterministic by design.",
    "ignore": "Sends a perfectly good ETag and Last-Modified, then ignores every conditional header: always 200, full body. (Violates a MUST. That is the point.) Your cache keeps asking; it keeps not listening.",
    "always-304": "Every GET is answered 304 — even the first, with no conditional headers at all. A cold cache is told \"you already have it\" about a body it has never seen. Broken proxies really do this.",
    "mismatch": "Revalidation \"succeeds\" — If-None-Match matches, 304 — but the 304 carries a different ETag than the one you sent. A cache that adopts it misses on its next revalidation (200, real validator restored) and then matches again: a permanent 304/200/304 thrash.",
    "no-validator-304": "If-None-Match matches and the 304 comes back bare: no ETag, no Last-Modified. A violation — RFC 9110 §15.4.5 says the 304 MUST carry the ETag its 200 would have — and hostile to caches that need the validator to know which stored response was confirmed.",
    "unquoted": "The ETag header is a bare token with no quotes (spec-invalid, common in the wild). The server matches If-None-Match sloppily — quoted, bare, weak-prefixed, anything goes — and If-Modified-Since works normally. What does your client send back, and does its parser cope?",
    "bad-date": "No ETag; Last-Modified is ISO 8601, not an HTTP-date (invalid). Revalidation is by exact string comparison of If-Modified-Since against that value — what a naive server does. Only a client that echoes the header back verbatim ever gets its 304; one that parses and reformats, or discards the unparseable date, refetches forever.",
    "future": "No ETag; Last-Modified is one year from today (a valid HTTP-date that is always in the future, moving at midnight UTC). The date comparison itself is honest, so a client that echoes today's header back verbatim still gets 304 — until the date rolls — while one that sends its own clock always gets 200. Which is yours? Nondeterministic across days by design."
  },
  "usage": "/etag/{flavor}",
  "caching": "Conditional requests over both validators, ETag and Last-Modified. Responses are cache-control: no-cache, no-transform (store, but revalidate every use), so a real cache can be pointed at these. Range and If-Range live at /range.",
  "witness": {
    "measured": "2026-10-12T19:44:05.856Z",
    "observations": 140,
    "control_rows": 21,
    "data": "https://badhttp.dev/clients.jsonl",
    "data_note": "Every observation is a row of /clients.jsonl with family \"etag\", joined to /corpus.jsonl by corpus_id; /clients indexes them with the class legend, the outcome, description, conditional and echo legends and the per-flavor disagreement. The findings below are a reading of those rows, not a second source.",
    "what_this_is": "14 real HTTP caches and conditional-request clients plus a raw-wire control (curl), one fresh working directory and one fresh cache per cell. Each cell asks the client to fetch GET /etag/{flavor} three times in a row through its cache (cold, warm, warm-again); the harness never sends a conditional header for a client, so every If-None-Match and If-Modified-Since is one the client chose from what it stored. It is a DATED CAPTURE, not a live measurement. Every request the client sent went through a local recording reverse proxy that forwarded it to this service over TLS and returned the response verbatim, so each row lists the exchanges the client actually made, attributed to the fetch that caused them. The reference for each flavor is what RFC 9111 implies a textbook cache would have sent and shown its caller, given what this server answered the control's textbook revalidation (RFC 9111 §4.3.1, §4.3.3, §4.3.4); where the specification defines nothing, the reference says so. An outcome describes what the caller received and what went upstream. RFC 9111 §5.2.2.4 forbids reusing a no-cache response without validation and does not forbid an unconditional refetch, so a client that revalidates and one that refetches are both allowed to, and \"differs\" is a description. Not every class is a cache in the RFC 9111 sense: curl --etag-compare, curl -z and wget -N are command-line clients that keep one saved validator, and each row names its class. The cache-control of every response is no-cache, so only the revalidation path is exercised. No client here is scored or ranked. Every figure, list and client name in this block is computed from the rows, never typed, except inside the gated explanations: each of those is written by hand from the client's source as docs/survey-etag-clients-2026-10-12.md read it, and renders only while the computed facts it names still hold. Re-run it and move the date rather than letting it stale.",
    "clients": [
      "CacheControl 0.14.4 (requests 2.34.2) (library-cache)",
      "curl --etag-compare / --etag-save 8.7.1 (cli-conditional)",
      "curl -z 8.7.1 (cli-conditional)",
      "got + cacheable-request 16.0.0 (library-cache)",
      "gregjones/httpcache v0.0.0-20190611155906-901d90724c79 (library-cache)",
      "hishel 1.4.0 (httpx 0.28.1) (library-cache)",
      "make-fetch-happen 16.0.1 (library-cache)",
      "nginx proxy_cache (proxy_ignore_headers Cache-Control, 1 s validity, revalidate) 1.31.6 (proxy-cache)",
      "requests-cache (cache_control=True) 1.3.3 (requests 2.34.2) (library-cache)",
      "Squid 7.7 (proxy-cache)",
      "Apache Traffic Server (required_headers 0) 10.2.0-0 (proxy-cache)",
      "undici 8.11.2 (library-cache)",
      "Varnish 9.1.0 (proxy-cache)",
      "GNU Wget -N 1.25.0 (cli-conditional)"
    ],
    "control": [
      "curl curl 8.7.1 (x86_64-apple-darwin26.0) libcurl/8.7.1 (SecureTransport) LibreSSL/3.3.6 zlib/1.2.12 nghttp2/1.69.0"
    ],
    "reference": "REFERENCE in the /clients etag family block: per flavor, the status and validators the control received cold and on a textbook revalidation (If-None-Match with the ETag it received, If-Modified-Since with the Last-Modified it received, as RFC 9111 §4.3.1 says), and what a cache that stores the first response and validates it that way would show its caller on the warm fetch",
    "findings": [
      "14 HTTP cache or conditional-request clients (CacheControl, curl --etag-compare / --etag-save, curl -z, got + cacheable-request, gregjones/httpcache, hishel, make-fetch-happen, nginx proxy_cache (proxy_ignore_headers Cache-Control, 1 s validity, revalidate), requests-cache (cache_control=True), Squid, Apache Traffic Server (required_headers 0), undici, Varnish, GNU Wget -N) were each pointed at /etag/{flavor} and asked for the same URL three times in a row through a fresh cache — 10 flavors, 140 rows in all. The harness never sends a conditional header for a client, so every If-None-Match and If-Modified-Since below is one the client chose from what it stored. By what the caller received on the second fetch: 78 document/stored-after-304, 45 document/fresh-200, 12 empty-304, 3 document/stored-despite-200, 1 other-status, 1 error. Against the reference (what RFC 9111 implies a textbook cache would have sent and shown, given what the control's textbook revalidation got), 104 rows match, 22 differ and 14 have no reference defined. RFC 9111 §5.2.2.4 forbids reusing a no-cache response without validation and does not forbid an unconditional refetch, so a row that differs is a description of a difference, not a finding about the client.",
      "ok (the control got, cold, 200 with ETag \"e-badhttp-1\", Last-Modified Sat, 01 Aug 2026 00:00:00 GMT and 307 body bytes; on a textbook revalidation, 304 with ETag \"e-badhttp-1\", no Last-Modified and 0 body bytes; reference: the document from the store after a 304, the 304 confirms the stored validators): on the warm fetch, CacheControl, got + cacheable-request, gregjones/httpcache, hishel, make-fetch-happen, nginx proxy_cache (proxy_ignore_headers Cache-Control, 1 s validity, revalidate), requests-cache (cache_control=True), Squid, Apache Traffic Server (required_headers 0), undici sent If-None-Match (verbatim) and If-Modified-Since (verbatim), got 304 and handed the caller the document from its store; curl --etag-compare / --etag-save sent If-None-Match (verbatim) but not the Last-Modified it had received, got 304 and left its stored file as the document and reported 304 to the caller; curl -z sent If-Modified-Since (as a date from its own clock) but not the ETag it had received, got 304 and left its stored file as the document and reported 304 to the caller; Varnish sent no conditional header, having received the ETag and the Last-Modified in an earlier 200, got 200 and handed the caller the document from the response; GNU Wget -N sent If-Modified-Since (verbatim) but not the ETag it had received, got 304 and left its stored file as the document and reported 304 to the caller. 13 of 14 rows match the reference and 1 differ.",
      "weak (the control got, cold, 200 with ETag W/\"e-badhttp-1\", Last-Modified Sat, 01 Aug 2026 00:00:00 GMT and 333 body bytes; on a textbook revalidation, 304 with ETag W/\"e-badhttp-1\", no Last-Modified and 0 body bytes; reference: the document from the store after a 304, the 304 confirms the stored validators): on the warm fetch, CacheControl, got + cacheable-request, gregjones/httpcache, hishel, make-fetch-happen, nginx proxy_cache (proxy_ignore_headers Cache-Control, 1 s validity, revalidate), requests-cache (cache_control=True), undici sent If-None-Match (verbatim) and If-Modified-Since (verbatim), got 304 and handed the caller the document from its store; curl --etag-compare / --etag-save sent If-None-Match (verbatim) but not the Last-Modified it had received, got 304 and left its stored file as the document and reported 304 to the caller; curl -z sent If-Modified-Since (as a date from its own clock) but not the ETag it had received, got 304 and left its stored file as the document and reported 304 to the caller; Squid sent If-Modified-Since (verbatim) but not the ETag it had received, got 304 and handed the caller the document from its store; Apache Traffic Server (required_headers 0) sent If-None-Match (with the W/ stripped) and If-Modified-Since (verbatim), got 304 and handed the caller the document from its store; Varnish sent no conditional header, having received the ETag and the Last-Modified in an earlier 200, got 200 and handed the caller the document from the response; GNU Wget -N sent If-Modified-Since (verbatim) but not the ETag it had received, got 304 and left its stored file as the document and reported 304 to the caller. 13 of 14 rows match the reference and 1 differ.",
      "changing (the control got, cold, 200 with ETag \"e-1791834252567568\", no Last-Modified and 332 body bytes; on a textbook revalidation, 200 with ETag \"e-179183425385602b\", no Last-Modified and 332 body bytes; reference: the document from the fresh 200 (the 200 carries a different ETag than the cold response, and a cache that stores it sends that tag next)): on the warm fetch, CacheControl, curl --etag-compare / --etag-save, got + cacheable-request, gregjones/httpcache, hishel, make-fetch-happen, nginx proxy_cache (proxy_ignore_headers Cache-Control, 1 s validity, revalidate), requests-cache (cache_control=True), Apache Traffic Server (required_headers 0) sent If-None-Match (verbatim), got 200 and handed the caller the document from the response; curl -z, GNU Wget -N sent If-Modified-Since (as a date from its own clock) but not the ETag it had received, got 200 and handed the caller the document from the response; Squid, undici sent If-None-Match (verbatim) and If-Modified-Since (as a date from its own clock), got 200 and handed the caller the document from the response; Varnish sent no conditional header, having received the ETag in an earlier 200, got 200 and handed the caller the document from the response. 14 of 14 rows match the reference and 0 differ.",
      "ignore (the control got, cold, 200 with ETag \"e-badhttp-1\", Last-Modified Sat, 01 Aug 2026 00:00:00 GMT and 306 body bytes; on a textbook revalidation, 200 with ETag \"e-badhttp-1\", Last-Modified Sat, 01 Aug 2026 00:00:00 GMT and 306 body bytes; reference: the document from the fresh 200): on the warm fetch, CacheControl, got + cacheable-request, gregjones/httpcache, hishel, make-fetch-happen, nginx proxy_cache (proxy_ignore_headers Cache-Control, 1 s validity, revalidate), requests-cache (cache_control=True), Squid, Apache Traffic Server (required_headers 0), undici sent If-None-Match (verbatim) and If-Modified-Since (verbatim), got 200 and handed the caller the document from the response; curl --etag-compare / --etag-save sent If-None-Match (verbatim) but not the Last-Modified it had received, got 200 and handed the caller the document from the response; curl -z sent If-Modified-Since (as a date from its own clock) but not the ETag it had received, got 200 and kept its stored copy and reported 304 to the caller, although the last answer was a 200 with a body; Varnish sent no conditional header, having received the ETag and the Last-Modified in an earlier 200, got 200 and handed the caller the document from the response; GNU Wget -N sent If-Modified-Since (verbatim) but not the ETag it had received, got 200 and kept its stored copy and reported 304 to the caller, although the last answer was a 200 with a body. 12 of 14 rows match the reference and 2 differ.",
      "always-304 (the control got, cold, 304 with ETag \"e-badhttp-1\", no Last-Modified and 0 body bytes; on a textbook revalidation, 304 with ETag \"e-badhttp-1\", no Last-Modified and 0 body bytes; reference: nothing defined (the cold request was answered 304 although it carried no conditional header, so no document exists for this flavor and no reference outcome is defined)): on the warm fetch, CacheControl, curl -z, hishel, make-fetch-happen, nginx proxy_cache (proxy_ignore_headers Cache-Control, 1 s validity, revalidate), requests-cache (cache_control=True), Squid, Apache Traffic Server (required_headers 0), undici sent no conditional header, got 304 and handed the caller a 304 with no body; curl --etag-compare / --etag-save, got + cacheable-request, gregjones/httpcache sent If-None-Match (a tag that no 200 it received carried), got 304 and handed the caller a 304 with no body; Varnish sent no conditional header, got 304 and handed the caller a response with status 503; GNU Wget -N sent no conditional header, got 304 and ended in an error (ServerError). 14 of 14 rows have no reference to match.",
      "mismatch (the control got, cold, 200 with ETag \"e-badhttp-1\", Last-Modified Sat, 01 Aug 2026 00:00:00 GMT and 311 body bytes; on a textbook revalidation, 304 with ETag \"e-badhttp-2\", no Last-Modified and 0 body bytes; reference: the document from the store after a 304, the 304's validators select no stored response, so the stored validator is kept (the 304 carries a different ETag than the one sent, so its validators select no stored response and a cache that keeps its stored validator sends the same tag again)): on the warm fetch, CacheControl, got + cacheable-request, gregjones/httpcache, make-fetch-happen, nginx proxy_cache (proxy_ignore_headers Cache-Control, 1 s validity, revalidate), requests-cache (cache_control=True), Squid, Apache Traffic Server (required_headers 0), undici sent If-None-Match (verbatim) and If-Modified-Since (verbatim), got 304 and handed the caller the document from its store; curl --etag-compare / --etag-save sent If-None-Match (verbatim) but not the Last-Modified it had received, got 304 and left its stored file as the document and reported 304 to the caller; curl -z sent If-Modified-Since (as a date from its own clock) but not the ETag it had received, got 304 and left its stored file as the document and reported 304 to the caller; hishel sent If-None-Match (verbatim) and If-Modified-Since (verbatim) on the first of 2 requests, the last of which got 200 and handed the caller the document from the response; Varnish sent no conditional header, having received the ETag and the Last-Modified in an earlier 200, got 200 and handed the caller the document from the response; GNU Wget -N sent If-Modified-Since (verbatim) but not the ETag it had received, got 304 and left its stored file as the document and reported 304 to the caller. 12 of 14 rows match the reference and 2 differ.",
      "no-validator-304 (the control got, cold, 200 with ETag \"e-badhttp-1\", Last-Modified Sat, 01 Aug 2026 00:00:00 GMT and 335 body bytes; on a textbook revalidation, 304 with no ETag, no Last-Modified and 0 body bytes; reference: the document from the store after a 304, the 304's validators select no stored response, so the stored validator is kept (the 304 carries no ETag, so its validators select no stored response and a cache keeps the stored validator)): on the warm fetch, CacheControl, got + cacheable-request, gregjones/httpcache, hishel, make-fetch-happen, nginx proxy_cache (proxy_ignore_headers Cache-Control, 1 s validity, revalidate), requests-cache (cache_control=True), Squid, Apache Traffic Server (required_headers 0), undici sent If-None-Match (verbatim) and If-Modified-Since (verbatim), got 304 and handed the caller the document from its store; curl --etag-compare / --etag-save sent If-None-Match (verbatim) but not the Last-Modified it had received, got 304 and left its stored file as the document and reported 304 to the caller; curl -z sent If-Modified-Since (as a date from its own clock) but not the ETag it had received, got 304 and left its stored file as the document and reported 304 to the caller; Varnish sent no conditional header, having received the ETag and the Last-Modified in an earlier 200, got 200 and handed the caller the document from the response; GNU Wget -N sent If-Modified-Since (verbatim) but not the ETag it had received, got 304 and left its stored file as the document and reported 304 to the caller. 13 of 14 rows match the reference and 1 differ.",
      "unquoted (the control got, cold, 200 with ETag e-badhttp-1, Last-Modified Sat, 01 Aug 2026 00:00:00 GMT and 322 body bytes; on a textbook revalidation, 304 with ETag e-badhttp-1, no Last-Modified and 0 body bytes; reference: the document from the store after a 304, the 304 confirms the stored validators (the ETag is a bare token without quotes; the reference echoes it as received)): on the warm fetch, CacheControl, got + cacheable-request, gregjones/httpcache, hishel, make-fetch-happen, nginx proxy_cache (proxy_ignore_headers Cache-Control, 1 s validity, revalidate), requests-cache (cache_control=True), Apache Traffic Server (required_headers 0) sent If-None-Match (verbatim) and If-Modified-Since (verbatim), got 304 and handed the caller the document from its store; Squid, undici sent If-Modified-Since (verbatim) but not the ETag it had received, got 304 and handed the caller the document from its store; curl --etag-compare / --etag-save sent If-None-Match (verbatim) but not the Last-Modified it had received, got 304 and left its stored file as the document and reported 304 to the caller; curl -z sent If-Modified-Since (as a date from its own clock) but not the ETag it had received, got 304 and left its stored file as the document and reported 304 to the caller; Varnish sent no conditional header, having received the ETag and the Last-Modified in an earlier 200, got 200 and handed the caller the document from the response; GNU Wget -N sent If-Modified-Since (verbatim) but not the ETag it had received, got 304 and left its stored file as the document and reported 304 to the caller. 13 of 14 rows match the reference and 1 differ.",
      "bad-date (the control got, cold, 200 with no ETag, Last-Modified 2026-08-01T00:00:00Z and 331 body bytes; on a textbook revalidation, 304 with no ETag, Last-Modified 2026-08-01T00:00:00Z and 0 body bytes; reference: the document from the store after a 304, the 304 confirms the stored validators (the Last-Modified value is not an HTTP-date; RFC 9111 §4.3.1 says to send the stored value, so this reference rests on echoing that value as received, and a cache that drops the unparseable date and refetches is described as differing from it for that reason)): on the warm fetch, got + cacheable-request, gregjones/httpcache, hishel, make-fetch-happen, requests-cache (cache_control=True) sent If-Modified-Since (the invalid value echoed back), got 304 and handed the caller the document from its store; CacheControl, nginx proxy_cache (proxy_ignore_headers Cache-Control, 1 s validity, revalidate), Apache Traffic Server (required_headers 0), Varnish sent no conditional header, having received the Last-Modified in an earlier 200, got 200 and handed the caller the document from the response; Squid, undici, GNU Wget -N sent If-Modified-Since (as a date from its own clock), got 200 and handed the caller the document from the response; curl --etag-compare / --etag-save sent If-None-Match (a tag that no 200 it received carried) but not the Last-Modified it had received, got 200 and handed the caller the document from the response; curl -z sent If-Modified-Since (as a date from its own clock), got 200 and kept its stored copy and reported 304 to the caller, although the last answer was a 200 with a body. 5 of 14 rows match the reference and 9 differ.",
      "future (the control got, cold, 200 with no ETag, Last-Modified Tue, 12 Oct 2027 00:00:00 GMT and 333 body bytes; on a textbook revalidation, 304 with no ETag, Last-Modified Tue, 12 Oct 2027 00:00:00 GMT and 0 body bytes; reference: the document from the store after a 304, the 304 confirms the stored validators): on the warm fetch, got + cacheable-request, gregjones/httpcache, hishel, make-fetch-happen, nginx proxy_cache (proxy_ignore_headers Cache-Control, 1 s validity, revalidate), requests-cache (cache_control=True), Squid, Apache Traffic Server (required_headers 0) sent If-Modified-Since (verbatim), got 304 and handed the caller the document from its store; CacheControl, undici, Varnish sent no conditional header, having received the Last-Modified in an earlier 200, got 200 and handed the caller the document from the response; curl --etag-compare / --etag-save sent If-None-Match (a tag that no 200 it received carried) but not the Last-Modified it had received, got 200 and handed the caller the document from the response; curl -z sent If-Modified-Since (as a date from its own clock), got 200 and handed the caller the document from the response; GNU Wget -N sent If-Modified-Since (verbatim), got 304 and left its stored file as the document and reported 304 to the caller. 9 of 14 rows match the reference and 5 differ.",
      "Validators: of 422 requests the clients sent over the three fetches, 161 carried If-None-Match (Apache Traffic Server (required_headers 0), CacheControl, Squid, curl --etag-compare / --etag-save, got + cacheable-request, gregjones/httpcache, hishel, make-fetch-happen, nginx proxy_cache (proxy_ignore_headers Cache-Control, 1 s validity, revalidate), requests-cache (cache_control=True), undici) and 183 carried If-Modified-Since (Apache Traffic Server (required_headers 0), CacheControl, GNU Wget -N, Squid, curl -z, got + cacheable-request, gregjones/httpcache, hishel, make-fetch-happen, nginx proxy_cache (proxy_ignore_headers Cache-Control, 1 s validity, revalidate), requests-cache (cache_control=True), undici). On the first request of the warm fetch, of 140 rows: 20 carried If-None-Match only (Apache Traffic Server (required_headers 0), CacheControl, curl --etag-compare / --etag-save, got + cacheable-request, gregjones/httpcache, hishel, make-fetch-happen, nginx proxy_cache (proxy_ignore_headers Cache-Control, 1 s validity, revalidate), requests-cache (cache_control=True)); 36 carried If-Modified-Since only (Apache Traffic Server (required_headers 0), GNU Wget -N, Squid, curl -z, got + cacheable-request, gregjones/httpcache, hishel, make-fetch-happen, nginx proxy_cache (proxy_ignore_headers Cache-Control, 1 s validity, revalidate), requests-cache (cache_control=True), undici); 59 carried both (Apache Traffic Server (required_headers 0), CacheControl, Squid, got + cacheable-request, gregjones/httpcache, hishel, make-fetch-happen, nginx proxy_cache (proxy_ignore_headers Cache-Control, 1 s validity, revalidate), requests-cache (cache_control=True), undici); 25 carried neither header (Apache Traffic Server (required_headers 0), CacheControl, GNU Wget -N, Squid, Varnish, curl -z, hishel, make-fetch-happen, nginx proxy_cache (proxy_ignore_headers Cache-Control, 1 s validity, revalidate), requests-cache (cache_control=True), undici); 0 carried no request at all. A validator held from the first 200 and not sent on the warm fetch: the ETag in 24 rows (GNU Wget -N, Squid, Varnish, curl -z, undici), the Last-Modified in 21 rows (Apache Traffic Server (required_headers 0), CacheControl, Varnish, curl --etag-compare / --etag-save, nginx proxy_cache (proxy_ignore_headers Cache-Control, 1 s validity, revalidate), undici).",
      "Echo: each If-None-Match or If-Modified-Since value is compared with the validator that client most recently received in a 200. Of the If-None-Match values sent on the warm and warm-again fetches, verbatim: 128 (Apache Traffic Server (required_headers 0), CacheControl, Squid, curl --etag-compare / --etag-save, got + cacheable-request, gregjones/httpcache, hishel, make-fetch-happen, nginx proxy_cache (proxy_ignore_headers Cache-Control, 1 s validity, revalidate), requests-cache (cache_control=True), undici); a tag that no 200 it received carried: 21 (Apache Traffic Server (required_headers 0), CacheControl, Squid, curl --etag-compare / --etag-save, got + cacheable-request, gregjones/httpcache, make-fetch-happen, requests-cache (cache_control=True)); with the W/ stripped: 2 (Apache Traffic Server (required_headers 0)). Of the If-Modified-Since values, verbatim: 143 (Apache Traffic Server (required_headers 0), CacheControl, GNU Wget -N, Squid, got + cacheable-request, gregjones/httpcache, hishel, make-fetch-happen, nginx proxy_cache (proxy_ignore_headers Cache-Control, 1 s validity, revalidate), requests-cache (cache_control=True), undici); as a date from its own clock: 30 (GNU Wget -N, Squid, curl -z, undici); the invalid value echoed back: 10 (got + cacheable-request, gregjones/httpcache, hishel, make-fetch-happen, requests-cache (cache_control=True)).",
      "On weak (the control got, cold, 200 with ETag W/\"e-badhttp-1\", Last-Modified Sat, 01 Aug 2026 00:00:00 GMT and 333 body bytes), the If-None-Match of the warm fetch was: verbatim (CacheControl, curl --etag-compare / --etag-save, got + cacheable-request, gregjones/httpcache, hishel, make-fetch-happen, nginx proxy_cache (proxy_ignore_headers Cache-Control, 1 s validity, revalidate), requests-cache (cache_control=True), undici); not sent (curl -z, Squid, Varnish, GNU Wget -N); with the W/ stripped (Apache Traffic Server (required_headers 0)).",
      "On unquoted (the control got, cold, 200 with ETag e-badhttp-1, Last-Modified Sat, 01 Aug 2026 00:00:00 GMT and 322 body bytes), the If-None-Match of the warm fetch was: verbatim (CacheControl, curl --etag-compare / --etag-save, got + cacheable-request, gregjones/httpcache, hishel, make-fetch-happen, nginx proxy_cache (proxy_ignore_headers Cache-Control, 1 s validity, revalidate), requests-cache (cache_control=True), Apache Traffic Server (required_headers 0)); not sent (curl -z, Squid, undici, Varnish, GNU Wget -N).",
      "On bad-date (the control got, cold, 200 with no ETag, Last-Modified 2026-08-01T00:00:00Z and 331 body bytes), the If-Modified-Since of the warm fetch was: not sent (CacheControl, curl --etag-compare / --etag-save, nginx proxy_cache (proxy_ignore_headers Cache-Control, 1 s validity, revalidate), Apache Traffic Server (required_headers 0), Varnish); the invalid value echoed back (got + cacheable-request, gregjones/httpcache, hishel, make-fetch-happen, requests-cache (cache_control=True)); as a date from its own clock (curl -z, Squid, undici, GNU Wget -N).",
      "On future (the control got, cold, 200 with no ETag, Last-Modified Tue, 12 Oct 2027 00:00:00 GMT and 333 body bytes), the If-Modified-Since of the warm fetch was: verbatim (got + cacheable-request, gregjones/httpcache, hishel, make-fetch-happen, nginx proxy_cache (proxy_ignore_headers Cache-Control, 1 s validity, revalidate), requests-cache (cache_control=True), Squid, Apache Traffic Server (required_headers 0), GNU Wget -N); not sent (CacheControl, curl --etag-compare / --etag-save, undici, Varnish); as a date from its own clock (curl -z).",
      "On mismatch (the control's revalidation sent If-None-Match \"e-badhttp-1\" and got 304 with ETag \"e-badhttp-2\", no Last-Modified and 0 body bytes, an ETag other than the one it sent), 6 of 14 clients sent, on a later fetch, a tag they had only ever received in that 304 (CacheControl, gregjones/httpcache, make-fetch-happen, requests-cache (cache_control=True), Squid, Apache Traffic Server (required_headers 0)). On their third fetch, CacheControl, gregjones/httpcache, make-fetch-happen, requests-cache (cache_control=True), Squid, Apache Traffic Server (required_headers 0) sent If-None-Match (a tag that no 200 it received carried) and If-Modified-Since (verbatim), got 200 and handed the caller the document from the response. The other 8 (curl --etag-compare / --etag-save, curl -z, got + cacheable-request, hishel, nginx proxy_cache (proxy_ignore_headers Cache-Control, 1 s validity, revalidate), undici, Varnish, GNU Wget -N) did not. On their third fetch, got + cacheable-request, undici, Varnish sent no conditional header, having received the ETag and the Last-Modified in an earlier 200, got 200 and handed the caller the document from the response; curl --etag-compare / --etag-save sent If-None-Match (a tag that no 200 it received carried) but not the Last-Modified it had received, got 200 and handed the caller the document from the response; curl -z sent If-Modified-Since (as a date from its own clock) but not the ETag it had received, got 304 and left its stored file as the document and reported 304 to the caller; hishel sent If-None-Match (verbatim) and If-Modified-Since (verbatim) on the first of 2 requests, the last of which got 200 and handed the caller the document from the response; nginx proxy_cache (proxy_ignore_headers Cache-Control, 1 s validity, revalidate) sent If-None-Match (verbatim) and If-Modified-Since (verbatim), got 304 and handed the caller the document from its store; GNU Wget -N sent If-Modified-Since (verbatim) but not the ETag it had received, got 304 and left its stored file as the document and reported 304 to the caller.",
      "On always-304 the control's very first request, with no conditional header, got 304 with ETag \"e-badhttp-1\", no Last-Modified and 0 body bytes. On the cold fetch, CacheControl, curl -z, got + cacheable-request, gregjones/httpcache, hishel, make-fetch-happen, nginx proxy_cache (proxy_ignore_headers Cache-Control, 1 s validity, revalidate), requests-cache (cache_control=True), Squid, Apache Traffic Server (required_headers 0), undici sent no conditional header, got 304 and handed the caller a 304 with no body; curl --etag-compare / --etag-save sent If-None-Match (a tag that no 200 it received carried), got 304 and handed the caller a 304 with no body; Varnish sent no conditional header, got 304 and handed the caller a response with status 503; GNU Wget -N sent no conditional header, got 304 and ended in an error (ServerError). Across all three fetches, by pattern: CacheControl, curl -z, hishel, make-fetch-happen, nginx proxy_cache (proxy_ignore_headers Cache-Control, 1 s validity, revalidate), requests-cache (cache_control=True), Squid, Apache Traffic Server (required_headers 0), undici →304 empty-304 | →304 empty-304 | →304 empty-304; got + cacheable-request, gregjones/httpcache →304 empty-304 | INM→304 empty-304 | INM→304 empty-304; curl --etag-compare / --etag-save INM→304 empty-304 | INM→304 empty-304 | INM→304 empty-304; Varnish →304 503 | →304 503 | →304 503; GNU Wget -N →304 error | →304 error | →304 error.",
      "On no-validator-304 the control's revalidation got 304 with no ETag, no Last-Modified and 0 body bytes. On the third fetch, after that bare 304, CacheControl, gregjones/httpcache, hishel, make-fetch-happen, nginx proxy_cache (proxy_ignore_headers Cache-Control, 1 s validity, revalidate), requests-cache (cache_control=True), Squid sent If-None-Match (verbatim) and If-Modified-Since (verbatim), got 304 and handed the caller the document from its store; got + cacheable-request, undici, Varnish sent no conditional header, having received the ETag and the Last-Modified in an earlier 200, got 200 and handed the caller the document from the response; curl --etag-compare / --etag-save sent If-None-Match (a tag that no 200 it received carried) but not the Last-Modified it had received, got 200 and handed the caller the document from the response; curl -z sent If-Modified-Since (as a date from its own clock) but not the ETag it had received, got 304 and left its stored file as the document and reported 304 to the caller; Apache Traffic Server (required_headers 0) sent If-Modified-Since (verbatim) but not the ETag it had received, got 304 and handed the caller the document from its store; GNU Wget -N sent If-Modified-Since (verbatim) but not the ETag it had received, got 304 and left its stored file as the document and reported 304 to the caller.",
      "No warm fetch was answered without a request going upstream: every client went to the server on the second and third fetch of every flavor.",
      "curl --etag-compare / --etag-save sent If-None-Match: \"\" on every cold fetch and again after every 304: when --etag-compare names a file that is missing or empty, curl 8.7.1 sends the literal empty tag (src/tool_operate.c, single_transfer), and --etag-save opens its file for writing before the transfer and writes an ETag line only for a 2xx response, so a 304 leaves the file empty. On ok, weak, mismatch, no-validator-304, unquoted the three fetches therefore went 200, 304, 200: the tag saved, matched once, lost with the 304, and saved again.",
      "curl -z never echoes a Last-Modified: libcurl rebuilds If-Modified-Since from the output file's modification time (lib/http.c, Curl_add_timecondition), which without -R is the time curl last wrote the file, so every date it sent here is its own clock. When a 200 then arrives whose Last-Modified is not newer than that time, or does not parse, libcurl discards the body and reports 304 itself (\"Simulate an HTTP 304 response\", Curl_http_readwrite_headers): the stored-despite-200 rows on ignore and bad-date.",
      "GNU Wget -N sends If-Modified-Since only when a local file exists, formatted from that file's modification time, which wget sets from a Last-Modified it can parse (src/http.c, gethttp): on ok the date went out as the server sent it, on bad-date (an ISO 8601 value its four strptime formats reject) as the download time; wget has no If-None-Match code at all. A 200 to its conditional request whose Last-Modified is not newer and whose Content-Length equals the file is dropped as \"Server ignored If-Modified-Since\" (the ignore row), and a cold 304 is \"ERROR 304: Not Modified.\" with exit 8.",
      "hishel made two requests inside each warm fetch of mismatch: its 304 handling (hishel/_core/_spec.py, freshening_stored_responses) matches a strong 304 ETag against the stored entry's tag, a 304 whose tag matches nothing deletes the entry, and the same call then sends a plain GET — so the caller got the fresh 200 and hishel never sent \"e-badhttp-2\".",
      "undici deletes the stored entry after a successful revalidation whose 304 carries a Cache-Control header (lib/interceptor/cache.js, revalidationResponseUpdatesCacheControl) — and this server's 304s all do — so its third fetch was a cold unconditional request on every flavor that answered the second with a 304, and what that 304 carried (a different ETag, or none) never reached its store.",
      "undici stored nothing on future (lib/handler/cache-handler.js, determineStaleAt returns early for a Last-Modified at or after now), sent If-Modified-Since alone on unquoted (only a quoted or W/-prefixed tag is a usable ETag to it) and, on bad-date, an If-Modified-Since built from the time it cached the entry rather than the ISO string (makeRevalidationHeaders falls back to cachedAt when the stored Last-Modified does not parse).",
      "got + cacheable-request stored the cold 304 on always-304 — http-cache-semantics gives a response without a status property the status 200 (index.js, CachePolicy constructor), so cacheable-request treats that 304 as storable — and revalidated it with the tag it carried on the next two fetches, handing the caller a 304 each time. On mismatch and no-validator-304 the 304 matched nothing stored (a different ETag; no validator against a stored Last-Modified), the policy rebuilt from the 304 is not storable, and cacheable-request deleted the entry (dist/index.js, cache.delete), so the third fetch was unconditional.",
      "gregjones/httpcache stores any response neither side marked no-store (httpcache.go, canStore), a cold 304 included, so on always-304 it revalidated that 304 with its tag on the next two fetches; and on a 304 it copies every header the 304 carries over the stored one (Transport.RoundTrip), so on mismatch its third fetch sent \"e-badhttp-2\" and got the 200 that restores the real tag.",
      "Six clients sent \"e-badhttp-2\" on their third fetch of mismatch — CacheControl, gregjones/httpcache, make-fetch-happen, requests-cache (cache_control=True), Squid, Apache Traffic Server (required_headers 0) — each because its 304 handling writes the 304's headers over the stored ones (cachecontrol/controller.py update_cached_response; requests_cache/policy/actions.py update_revalidated_response; make-fetch-happen's cache entry rewritten from the 304's headers; Squid's and Traffic Server's header merge on a 304). The server then answers 200 with the real tag, which is the 304/200/304 thrash the flavor describes. nginx proxy_cache (proxy_ignore_headers Cache-Control, 1 s validity, revalidate) takes nothing from a 304's headers, sent the stored tag again and got a second 304.",
      "Apache Traffic Server (required_headers 0) strips a leading W/ from the ETag it revalidates with (HttpTransact.cc, issue_revalidate), so the weak flavor's tag went out as a strong-looking quoted tag; a 304 without an ETag costs it the stored ETag (merge_and_update_headers_for_cache_update deletes the cached ETag unless the 304 carries one), so its third fetch of no-validator-304 sent If-Modified-Since alone; and a Last-Modified that does not parse is not sent, so on bad-date, with no ETag either, its revalidation was an unconditional request. With its shipped default (required_headers 2: an explicit lifetime required) it stores none of these responses; the roster entry sets required_headers 0 and the row's configuration says so.",
      "Squid sends If-None-Match only for a strong, quoted ETag as stored (client_side_reply.cc, processExpired), so weak and unquoted were revalidated with If-Modified-Since alone; its If-Modified-Since is rebuilt from the stored entry's parsed Last-Modified, or from the entry's Date when there is no usable Last-Modified (changing, bad-date); and every request it forwarded, the cold one included, carried Cache-Control: max-age=259200, the largest freshness of its default refresh_pattern (http.cc, httpBuildRequestHeader).",
      "CacheControl stores a response only when it carries an ETag (or a max-age or Expires) — cachecontrol/controller.py, cache_response — so bad-date and future, whose responses have a Last-Modified and no ETag, were never stored and all three fetches were unconditional; the response's no-cache is not what decided.",
      "nginx proxy_cache (proxy_ignore_headers Cache-Control, 1 s validity, revalidate) stores a no-cache response only under proxy_ignore_headers Cache-Control (ngx_http_upstream.c, ngx_http_upstream_process_cache_control marks any no-cache, no-store or private value uncacheable; there is no other way), which is why the roster entry carries that directive and a one-second validity. When it revalidates, If-None-Match is the stored ETag byte for byte and If-Modified-Since the stored Last-Modified parsed and printed again, so an unparseable date (bad-date) sends no If-Modified-Since and, with no ETag, the revalidation was an unconditional request.",
      "Varnish ran its built-in VCL, whose vcl_beresp_control treats a Cache-Control containing no-cache, no-store or private as uncacheable and creates a hit-for-miss object, so every request went to the origin with no conditional header; and a 304 to a request it did not make conditional is a backend fetch failure to it (cache_fetch.c), answered with its own 503 — the one other-status row.",
      "Five clients sent the ISO 8601 Last-Modified back verbatim on bad-date and got the 304 that only an exact echo earns from this flavor: got + cacheable-request, gregjones/httpcache, hishel, make-fetch-happen, requests-cache (cache_control=True) — hishel's make_conditional_request copies the stored header, requests-cache's _update_validation_headers likewise, make-fetch-happen and got through http-cache-semantics' revalidationHeaders (which copies the stored strings and never parses the date), gregjones/httpcache through Set(\"if-modified-since\", lastModified). The four that build the date from a parsed time or a clock (curl -z, Squid, undici, GNU Wget -N) sent a different value and got the 200.",
      "0 of 140 rows hit the harness's cap and 0 failed to land. Every other row is a response this server sent, read back from the wire with its x-badhttp-version on every exchange."
    ],
    "what_the_rows_cannot_say": "What a client does over HTTPS or HTTP/2 (every client spoke HTTP/1.1 to a loopback recorder, so TLS, ALPN and HTTP/2 are out of scope), how a browser cache revalidates (no browser is in the roster), what a cache does with max-age, heuristic freshness, Vary or stale-while-revalidate (every flavor is no-cache, so only the revalidation path is exercised), whether a 304 updated the headers a cache stored (not observable from outside; only the next request's validators are), and anything after the harness caps.",
    "not_in_roster": [
      {
        "client": "requests-cache",
        "reason": "Same library as the roster entry, configured with its default cache_control=False; measured in the survey of 2026-10-12: it stores the response and never revalidates."
      },
      {
        "client": "aiohttp-client-cache",
        "reason": "Measured in the survey of 2026-10-12: it stores every 200 and answers later fetches from the store with no request unless the caller sets refresh=True on the request."
      },
      {
        "client": "aiohttp-client-cache (cache_control=True)",
        "reason": "Measured in the survey of 2026-10-12: same wire as its defaults; a response no-cache is not read and a conditional request goes out only on refresh=True."
      },
      {
        "client": "axios-cache-interceptor",
        "reason": "Measured in the survey of 2026-10-12: with its defaults it sends its own request Cache-Control and Pragma and stores nothing from a no-cache response, so all three fetches are unconditional."
      },
      {
        "client": "bartventer/httpcache",
        "reason": "Measured in the survey of 2026-10-12: the wire is identical to the roster Go client on all ten flavors, so it adds no row of its own to the index."
      },
      {
        "client": "faraday-http-cache (Ruby)",
        "reason": "Measured in the survey of 2026-10-12: the wire matches the roster libraries that revalidate and a cold 304 is not stored; left out because the roster is capped at fourteen clients."
      },
      {
        "client": "curl -z -R",
        "reason": "Measured in the survey of 2026-10-12: it takes the file time from Last-Modified when that parses; left out because the roster is capped at fourteen clients."
      },
      {
        "client": "nginx proxy_cache (defaults)",
        "reason": "Measured in the survey of 2026-10-12: nginx with its defaults stores no response that carries no-cache; the roster entry ignores Cache-Control to make storage possible."
      },
      {
        "client": "Apache Traffic Server (shipped defaults)",
        "reason": "Measured in the survey of 2026-10-12: with its shipped configuration it stores nothing from these responses; the roster entry sets required_headers 0 so that it stores them."
      },
      {
        "client": "Varnish (custom VCL)",
        "reason": "A configuration, not a client: the roster entry uses the default VCL; other VCL variants were measured in the survey of 2026-10-12 and are not captured."
      },
      {
        "client": "Chromium and Firefox caches",
        "reason": "There is no browser harness, so a browser cache cannot be driven through the recording proxy; the rows say nothing about how a browser revalidates."
      },
      {
        "client": "pip downloader",
        "reason": "It uses CacheControl, which is a roster entry, so it would repeat that wire."
      }
    ],
    "reproduce": "Start a fresh cache and a fresh working directory, ask the row's client to fetch the row's url three times in a row through its cache with no conditional header of your own, and compare each fetch's requests and what the caller received with the row; for the reference, fetch the same url with curl -sS --http1.1, then again with If-None-Match set to the ETag and If-Modified-Since to the Last-Modified it returned. Pace the calls against the zone limit of 100 per 10 s, and treat a response without x-badhttp-version as no observation. The harnesses that produced the rows are in scripts/etag-witness/ in the source."
  }
}
