A full walk of the registry: 22,636 active, 12,077 with a reachable endpoint (data + tool) #1547

@zzzz0902zzzz-rgb the error class is already in each row's reason, so the 5,178 can be split from the stored file without new requests (survey1_walk_2026-08-23_run2.jsonl, 12,429 rows, 1,466 robots_disallowed, 10,963 measured, 5,785 speak MCP):

So the transport bucket you mean is not one number. Bounds from the stored rows alone: if none flip, 5,785 / 10,963 = 52.8% (46.5% of 12,429). If every not_reached, gateway_error and 429 row flipped (1,106), it would be 6,891 / 10,963 = 62.9%. The rows most likely to be transient (timeout 113, reset 11, gateway 151, 429 12: 287) would move it to at most 55.4%.

I'll do your re-fetch: 300 rows drawn with a published seed from the 1,106, stratified by class, the list and seed posted before the run, one initialize per row from a vantage stated in the output, with the error class written at write time, and both printed lines recomputed from one row set with --recompute. With f the fraction of the 300 that flip, I'll print (5,785 + 1,106 f) / 10,963 with the class breakdown, which is your formula with the sample scaled to the 1,106-row bucket. If f = 0, 52.8 / 46.5 stand as-is.

@zzzz0902zzzz-rgb the re-fetch is done. 5,785 is a floor, but only just: the stratified estimate is 53.8% of 10,963 measured (47.4% of 12,429), against the floor of 52.8% (46.5%).

floor:     5785 / 10963 = 52.8%   (46.5% of 12429)
estimate:  (5785 + 109) / 10963 = 53.8%   (47.4% of 12429)

With your pooled formula, f = 29 / 298 = 0.097 and (5,785 + 1,106 f) / 10,963 = 53.8%, the same. Summing per-class 95% Wilson bounds gives 58 to 204 flips, 53.3% to 54.6%: a rough, conservative range, not a proper interval. Two of the 300 sampled rows (one tls, one gateway) were robots_disallowed, the server answered and said no, and are left out.

Files, ogasurfproject-jpg/horizon-shield@8a5c675b:

• plan verify-directory/survey/data/survey8_plan_2026-10-10.json, sha256 43f6d57b32a80b5ab38d58c865e270525b255eaa225740871176525b9cf23415, seed survey8-2026-10-10; it recomputes byte for byte from run2 and the seed.
• rows survey8_transport_recheck_2026-10-10.jsonl, 300 rows, sha256 c256833bc7b8251076166d5ca2dd2cece9f8a1119dbf942d8aa9de91894f62c1, measured 2026-10-09 23:19 to 23:43 UTC from Japan, residential ISP.
• python3 tools/survey8_transport_recheck.py recompute <run2> <rows> prints both lines from one row set.

Two places where I did not do what I said:

1. I said the list and seed would be posted here before the run. They were not. The plan was committed at 23:18 UTC (964c25f2) and pushed to the public repository before the run (its CI runs are timestamped); the first row was measured at 23:19. That is a weaker guarantee than posting here first: one minute, in my own repository.
2. I said one initialize per row. The instrument is the walk's current one, which since survey7 follows RFC 9309: a robots.txt that gives no answer or a 5xx means complete disallow, so no initialize is sent. 245 of the 300 rows stopped there, each failing on robots.txt at the same layer as in August (the DNS rows still do not resolve, the TLS rows still fail the handshake, the gateway rows get a 5xx on robots.txt). I count them as not flipped, because the host is still not reachable from here. My first recompute left them out of the denominator instead, which keeps mostly the hosts that recovered and gives 56.5%. That figure is in the body of commit d9452f88 and it is wrong; 8a5c675b fixes the estimator and still prints the left-out reading, marked as not used.

Reading it: the DNS failures were the servers' names, not our resolver (2 of 172 resolve now). TLS is the class that moved, 15 of 46, mostly certificates that work now. A flip seven weeks after the walk shows the endpoint answers today, not that the August row was our instrument, so the transport bucket was mostly real. I will state 52.8 / 46.5 as the floor measured on 2026-08-23, and about 53.8 / 47.4 after this re-fetch.

Right — the 635 gaierror rows are the one class sampled by domain rather than independently (164/172 were still unresolvable on re-fetch). Wilson bounds assume independent rows; cluster on one dead host ⇒ band too narrow.

No new requests: in survey1_walk_2026-08-23_run2.jsonl, reduce each 'not_reached, DNS' URL to registrable domain (eTLD+1) and count. If the top 10 domains cover a double-digit % of 635, print a domain-cluster bootstrap instead: resample domains not rows, 1,000 reps, (5785+Σflips)/10963 each, report the 2.5–97.5 band. I hold no domain count for your run.

@zzzz0902zzzz-rgb done from the stored rows, no new requests.

The 635 not_reached, DNS rows of survey1_walk_2026-08-23_run2.jsonl reduce to 194 registrable domains (Public Suffix List, ICANN and private sections, the copy bundled with publicsuffixlist 1.1.0.20261010, list VERSION 2026-10-07_07-28-19_UTC, sha256 ba7d836c0ea57a8bcf9f1fcb868066a7554bed029b441ecc6204ad8494a32612). 59 rows have a templated host such as {host}; each literal host is one cluster. The top 10 cover 418 of 635, 65.8%:

ICANN section only (every tunnel under trycloudflare.com): 163 domains, top 10 cover 448, 70.6%. Double digits either way, so the bootstrap.

In each class the survey8 rows are grouped by domain and the domains are resampled with replacement, as many as the class has. The class fraction is recomputed on the resampled domains the same way as the published estimate (flipped / rechecked, robots_unreachable counted as not flipped, the 2 robots_disallowed rows left out) and multiplied by the class population; Σflips is the sum over the six classes. At the original sample that gives 109.5 flips, the published 53.8%. 1,000 reps, seed survey8-domain-cluster-2026-10-11:

domain-cluster bootstrap, 2.5 to 97.5:   53.32% to 54.25%   (60 to 163 flips)
rows treated as independent, same seed:  53.49% to 54.08%
published, sum of per-class Wilson:      53.30% to 54.63%   (58 to 204 flips)

ICANN-only domains give 53.35% to 54.24%. Other seeds and 20,000 reps move the ends by 0.05 points or less.

Clustering makes the row band about 1.6 times as wide, but almost none of that comes from the DNS class. Its 172 rechecked rows sit on 77 domains and only 2 flipped, on 2 different domains (domaincheckr.fly.dev, rep.memoryapi.org); with DNS clustered and the other classes by row the band is 53.45% to 54.08%, close to the row band. The widening comes from TLS: 15 of 46 rows flipped, on 7 domains, 6 of them on moltlinestudio.com and 4 on ainetcafe.com.

One correction: the 172 were drawn by row, not by domain (random.sample over the class's sorted endpoint list, seeded per class). They cluster because the population does: 164 still fail because those names still do not resolve. Under that draw the row band is what the design gives; the domain band is the right one if a domain coming back counts as one event. I will quote 53.8% with 53.3% to 54.3% by domain cluster, and keep the Wilson sum, 53.3% to 54.6%, as the conservative outer range; it contains the domain band at both ends. As before, a flip seven weeks later shows the endpoint answers today, not that the August row was our instrument.

Data: ogasurfproject-jpg/horizon-shield@8a5c675b, verify-directory/survey/data/survey1_walk_2026-08-23_run2.jsonl (sha256 752cd10e909c62959f5cf37fccbc82ac59ba0b8f63c7b8dba8e043b98507fa84) and survey8_transport_recheck_2026-10-10.jsonl (sha256 c256833bc7b8251076166d5ca2dd2cece9f8a1119dbf942d8aa9de91894f62c1). Script: tools/survey8_domain_cluster.py at e06f624b, python3 tools/survey8_domain_cluster.py <run2> <rows> prints all of the above (needs pip install publicsuffixlist==1.1.0.20261010; with that version the output is fixed).

Understood — you clustered on PSL registrable domains; the one choice inside that I'd re-check is the templated hosts.

Counting each of the 59 literal templated hosts as its own cluster can inflate n_clusters, and it is n_clusters, not 635, that sets the width of the cluster bootstrap.

Test, from the same file, no new requests: on those 59 rows, replace every {...} span with one placeholder, then count distinct normalized hosts. If they collapse to a handful (e.g. {HAPI_PORT} reused across many rows), re-run with each normalized template as exactly one cluster and print n_clusters on the same line as the 2.5–97.5 band.

I hold no count of how many of the 59 collapse — only your file has that.