Reports are taken only as application/json (closes #126 )

A page on another origin can POST text/plain or a form without a CORS preflight, so its visitors' browsers could store reports although the server sends no CORS headers. decodeJSON now refuses a request whose Content-Type is not application/json (parameters such as charset allowed), and the report handler answers it 415 with the usual error body, storing nothing. A JSON POST waits for the preflight, which only an origin in CORS_ALLOWED_ORIGINS passes; the page already sends application/json. Model: opus-5-5
2026-10-14 10:36:10 +00:00
22 changed files with 253 additions and 1780 deletions
@@ -5,11 +5,11 @@
 #
 # The lint and test phases are the gates: `make lint` (script/lint)
 # builds the lint stage alone and `make test` (script/test) the test
-# stage alone, and the two build stages, frontend-build and builder,
+# stage alone, and the builder stage depends on both, so the image
-# depend on both, so the image cannot be built unless they pass. Each
+# cannot be built unless they pass. Each covers the frontend as well,
-# phase covers the frontend as well, through a copy from a node stage.
+# through a copy from a node stage. Inside them each tool is invoked
-# Inside them each tool is invoked directly, never through make or
+# directly, never through make or script/, whose lint and test are
-# script/, whose lint and test are themselves docker builds.
+# themselves docker builds.
 # Frontend lint stage: eslint with the rules in eslint.config.js. The
 # lint phase below runs it.
@@ -35,26 +35,30 @@ RUN golangci-lint run --config .golangci.yml ./...
 # phase run it.
 COPY --from=frontend-lint /app/yarn.lock /dev/null
-# Frontend test stage: the unit tests in test/unit/. The test phase
+# Frontend stage: the unit tests in test/unit/, then the production
-# below runs it, and the frontend-build stage starts from it. The tests
+# build into dist/, which the runtime stage serves. The test phase below
-# print a dot each; if any fails, they run again with every test listed,
+# runs it. The tests print a dot each; if any fails, they run again with
-# and the step fails even if that run passes. NODE_OPTIONS chooses the
+# every test listed, and the step fails even if that run passes.
-# reporter because yarn adds its arguments after the test files, where
+# NODE_OPTIONS chooses the reporter because yarn adds its arguments
-# node would take a reporter option for one more file.
+# after the test files, where node would take a reporter option for one
 # more file.
 # node:22-alpine as of 2026-02-22
-FROM node@sha256:e4bf2a82ad0a4037d28035ae71529873c069b13eb0455466ae0bc13363826e34 AS frontend-test
+FROM node@sha256:e4bf2a82ad0a4037d28035ae71529873c069b13eb0455466ae0bc13363826e34 AS frontend
 WORKDIR /app
 COPY package.json yarn.lock ./
 RUN yarn install --frozen-lockfile
 # vite.config.js reads the commit for the page's footer with git.
 RUN apk add --no-cache git
 COPY . .
 RUN NODE_OPTIONS=--test-reporter=dot timeout 90 yarn --silent run test || \
    { echo "--- Rerunning with every test listed for details ---"; \
      NODE_OPTIONS=--test-reporter=spec timeout 90 yarn --silent run test; \
      exit 1; }
 RUN yarn build
 # Test phase: the backend's tests with the race detector and coverage,
-# and the frontend's through the copy from the frontend-test stage at
+# and the frontend's through the copy from the frontend stage at the
-# the end. -race needs cgo and so a C compiler, which the Debian Go image
+# end. -race needs cgo and so a C compiler, which the Debian Go image
 # ships and the alpine one does not. -timeout 90s is a backstop above
 # the 60-second cap on the suite. The rerun with -v only shows details:
 # the step fails however it ends, because the first run already failed.
@@ -71,21 +75,9 @@ RUN --mount=type=tmpfs,target=/go/pkg/mod \
    go test -timeout 90s -race -cover ./... || \
    { echo "--- Rerunning with -v for details ---"; \
      go test -timeout 90s -race -v ./...; exit 1; }
-# Nothing is wanted from the frontend-test stage; the copy is what makes
+# Nothing is wanted from the frontend stage; the copy is what makes
 # this phase run its tests.
-COPY --from=frontend-test /app/yarn.lock /dev/null
+COPY --from=frontend /app/yarn.lock /dev/null
 # Frontend build stage: the production build into dist/, which the
 # runtime stage serves, on the yarn packages and source of the
 # frontend-test stage. Nothing is wanted from the two phases; the copies
 # are what make BuildKit build them first, so this stage cannot run
 # unless lint and test passed.
 FROM frontend-test AS frontend-build
 COPY --from=lint /src/go.sum /dev/null
 COPY --from=test /src/go.sum /dev/null
 # vite.config.js reads the commit for the page's footer with git.
 RUN apk add --no-cache git
 RUN yarn build
 # Backend build stage. Nothing is wanted from the two phases; the copies
 # are what make BuildKit build them first, so this stage cannot run
@@ -139,7 +131,7 @@ RUN addgroup -g 1000 -S netwatch && \
 RUN rm /etc/nginx/conf.d/default.conf
 COPY configs/nginx.conf /etc/nginx/templates/netwatch.conf.template
 COPY configs/security-headers.conf /etc/nginx/security-headers.conf
-COPY --from=frontend-build /app/dist /usr/share/nginx/html
+COPY --from=frontend /app/dist /usr/share/nginx/html
 COPY --from=builder /src/netwatch-server /usr/local/bin/netwatch-server
 COPY bin/entrypoint.sh /usr/local/bin/entrypoint.sh
@@ -59,9 +59,8 @@ either one is broken. We provide:
 - `script/clean` — remove what `script/build` writes
 - `script/projectname` — print the project name (used for the Docker image tag)
 - `script/test` — build the `test` phase of `Dockerfile` without the cache: the
-  frontend's unit tests in its `frontend-test` stage, and the backend's Go tests
+  frontend's unit tests and production build in its `frontend` stage, and the
-  with the race detector and coverage. The frontend's production build is left
+  backend's Go tests with the race detector and coverage
  to the image build, in the `frontend-build` stage
 - `script/lint` — build the `lint` phase of `Dockerfile` without the cache:
  eslint in its `frontend-lint` stage, and golangci-lint over the Go packages
 - `script/fmt` — format all files (writes): prettier over the JavaScript, CSS,
@@ -79,16 +78,14 @@ either one is broken. We provide:
 - `script/frontend-test` — run the unit tests in `test/unit/` on the host with
  Node's built-in test runner, through the `test` script in `package.json`, and
  if any fails, run them again listing every test, and fail; then the production
-  build. Each test run has a 90-second timeout. `make test` runs the same tests
+  build. Each test run has a 90-second timeout. `make test` runs the same in
-  in Docker, without the production build
+  Docker
 - `script/frontend-fmt` — format the JavaScript, CSS, HTML and Markdown with
  prettier (writes)
 - `script/frontend-fmt-check` — check prettier formatting (read-only)
 - `script/frontend-viewport-test` — responsive-layout verification of the built
  frontend in a containerised headless Chrome (see
-  [test/viewport/README.md](test/viewport/README.md)). Before the browser
+  [test/viewport/README.md](test/viewport/README.md)). Not part of
  starts, it checks that the page, and a path that falls back to it, are served
  with `Cache-Control: no-cache` and `Content-Security-Policy`. Not part of
  `script/check`: it takes minutes.
 - `script/docker` — build the image from `Dockerfile` without the build cache,
  tagged `netwatch` via `script/projectname`
@@ -155,26 +152,8 @@ report a delta, so only new samples are sent; the mark advances only on a
 delivered report, and while paused nothing is sent. Changing the interval clears
 each host's history on the page; the samples in it not yet reported still go in
 the next report. Delivery failure is quiet — one debug-log line per outage,
-never blocking probing. The report-building step is a pure function of host
+retried at the next interval, never blocking probing. The report-building step
-state.
+is a pure function of host state.
 A sample in the history that no report has delivered is sent only as long as the
 history holds it, so after a refused or failed report the next report carries
 the samples the history still has. Samples an interval change cleared from the
 history are kept apart, the last 100 per host, until they are delivered. The
 history keeps each host's last 100 rounds: 100 seconds at the 1-second interval,
 200 seconds at 2 seconds, 5 minutes at the default of 3 seconds and 100 minutes
 at 60 seconds. At 1 second, one refused or failed report loses the oldest 20
 seconds of each host's samples, as the next delivered report comes 2 minutes
 after the last. At 2 seconds and longer one loses nothing; samples are lost from
 the third refused report in a row at 2 seconds, from the fifth at 3 seconds, and
 later still at the longer intervals.
 No report is sent while the page is paused, but each paused round still adds an
 entry to the history, so each report due during a pause counts as a refused one.
 A pause longer than the history spans loses the samples in the history recorded
 between the last delivered report and the pause: up to a minute's worth for each
 host if the report before the pause was delivered.
 ### Backend
@@ -220,32 +199,23 @@ image, `make run` builds it and runs it on port 8080.
 | `DATA_DIR`             | `./data/reports`     | Directory for compressed reports                                                                         |
 | `DATA_DIR_MAX_BYTES`   | `1073741824` (1 GiB) | Most bytes of report files kept in `DATA_DIR`, oldest deleted first; see [Report limits](#report-limits) |
 | `DEBUG`                | `false`              | Enable debug logging                                                                                     |
-| `TRUSTED_PROXIES`      | RFC 1918 ranges      | Comma-separated CIDRs whose `X-Forwarded-For` / `X-Real-IP` headers are trusted for client IP resolution |
+| `TRUSTED_PROXIES`      | loopback + RFC1918   | Comma-separated CIDRs whose `X-Forwarded-For` / `X-Real-IP` headers are trusted for client IP resolution |
 | `REPORTS_PER_MINUTE`   | `60`                 | Reports each client address may send a minute; see [Report limits](#report-limits)                       |
 | `CORS_ALLOWED_ORIGINS` | empty                | Comma-separated origins whose pages may call the API; see [CORS](#cors)                                  |
 | `METRICS_USERNAME`     | empty                | Basic auth user name for `/metrics`; see [Metrics](#metrics)                                             |
 | `METRICS_PASSWORD`     | empty                | Basic auth password for `/metrics`; see [Metrics](#metrics)                                              |
 | `SENTRY_DSN`           | empty                | DSN of the Sentry project to send errors to; see [Sentry](#sentry)                                       |
-`TRUSTED_PROXIES` defaults to `10.0.0.0/8,172.16.0.0/12,192.168.0.0/16`. A list
+`TRUSTED_PROXIES` defaults to
-replaces the default; set and empty, the server trusts no proxy. Loopback is not
+`127.0.0.1/32,::1/128,10.0.0.0/8,172.16.0.0/12,192.168.0.0/16`. The loopback
-in the default, so a reverse proxy on the same host has to be named, as in
+entries cover a reverse proxy on the same host. A request whose direct peer is
-`TRUSTED_PROXIES=127.0.0.1/32`. A request whose direct peer is outside this set
+outside this set has its forwarded headers ignored, and the direct peer is
-has its forwarded headers ignored, and the direct peer is logged and
+logged and rate-limited instead. The container image does not use this default;
-rate-limited instead. From a direct peer inside the set, the client address is
+see [Deployment](#deployment).
 the right-most `X-Forwarded-For` entry that is not in the set: each proxy
 appends the address it took the request from, so the entries further left were
 written by the client and are not used. An entry written as an address with a
 port, such as `198.51.100.7:5000` or `[2001:db8::1]:443`, is read as that
 address. If the search from the right finds only addresses in the set, or meets
 an entry that is not an address at all, such as `unknown`, the direct peer is
 used. `X-Real-IP` is read only when `X-Forwarded-For` is missing or empty. The
 container image does not use this default; see [Deployment](#deployment).
 A variable set to a value the server cannot use, such as `PORT=abc`,
 `DEBUG=maybe` or a `BIND_ADDRESS` that is not an IP address, stops it from
-starting, with an error naming the variable. An empty variable counts as unset,
+starting, with an error naming the variable. An empty variable counts as unset.
 except `TRUSTED_PROXIES`.
 #### Report storage
@@ -258,21 +228,11 @@ the numbers: its file, if it was created, is removed. The file stays, counted
 toward `DATA_DIR_MAX_BYTES` from the next start, only if removing it fails too.
 Files are created with `O_EXCL` to prevent overwrites.
 The reports of a failed write stay in memory, and the next flush, within a
 minute, tries again to write them. From the failed write until a write succeeds,
 `POST /api/v1/reports` refuses every report with 500 and keeps nothing of it.
 The page sends the refused samples again in its next report, as long as it still
 holds them: at the 1-second interval one refused report already loses some of
 those in the history (see [Reporting](#reporting)). Reports already answered 200
 are lost only if the server stops before a write succeeds; the final flush at
 stop tries them too, and if it fails, the process exits non-zero.
 #### Report limits
 `POST /api/v1/reports` takes reports from anyone who can reach it, without
 credentials, so it is bounded instead. Each refusal below answers with the same
-`{"status":"error"}` body as any other error, except nginx's refusal of a body
+`{"status":"error"}` body as any other error.
 over the limit in the image.
 - **JSON only.** A report must be sent with `Content-Type: application/json`,
  parameters such as `charset` allowed, as the page sends it; any other is
@@ -280,16 +240,6 @@ over the limit in the image.
  send a `text/plain` POST, or a form, without a CORS preflight; refusing them
  keeps any site from making its visitors' browsers store reports (see
  [CORS](#cors)).
 - **Body limit.** A report body may be at most 1 MiB, the backend's limit for
  any request. Run on its own, the backend answers 413 before the route to a
  request that declares a longer body. Without a declared length, the route
  answers 413 only when the report it reads runs past 1 MiB; nothing after the
  end of the report is read, so a longer body whose report ends sooner is
  stored, and one that stops being valid JSON sooner is answered 400. In the
  image, nginx refuses a body over 1 MiB first, with or without a declared
  length, as its `client_max_body_size`, which `configs/nginx.conf` does not
  set, is 1 MiB by default. nginx answers 413 with its own HTML error page, and
  the backend never sees the request.
 - **Rate limit.** Each client address, resolved through `TRUSTED_PROXIES`, may
  send `REPORTS_PER_MINUTE` reports a minute; past that it gets 429 with
  `Retry-After: 60`. The minute slides: reports from the minute before still
@@ -302,22 +252,16 @@ over the limit in the image.
  `X-RateLimit-Reset` headers.
 - **Size cap.** The report files in `DATA_DIR` may total at most
  `DATA_DIR_MAX_BYTES`, counting the files already there at start. Reports
-  waiting in memory count at their uncompressed size until they are written,
+  waiting in memory count at their uncompressed size until they are written;
-  those of a failed write included; the part of its file written is removed.
+  those lost to a failed write stop counting, and the part of its file written
-  When a report would take the total past the cap, the oldest report files are
+  is removed. When a report would take the total past the cap, the oldest report
-  deleted to make room, and each deletion is logged with the file's name and
+  files are deleted to make room, and each deletion is logged with the file's
-  size; a file still being written is never deleted. A report is refused with
+  name and size; a file still being written is never deleted. A report is
-  507, and nothing of it is stored, only when the reports waiting to be written
+  refused with 507, and nothing of it is stored, only when the reports waiting
-  fill the cap on their own, and then no file is deleted. At start, report files
+  to be written fill the cap on their own, and then no file is deleted. At
-  past the cap, as after lowering it, are deleted the same way. So the cap is
+  start, report files past the cap, as after lowering it, are deleted the same
-  how much of the newest reports is kept: the default of 1 GiB is small enough
+  way. So the cap is how much of the newest reports is kept: the default of 1
-  for any host; set it to the space you can give `DATA_DIR`.
+  GiB is small enough for any host; set it to the space you can give `DATA_DIR`.
 At the defaults, one address may send 60 reports of up to 1 MiB a minute, and a
 report made up to compress badly takes about as much room in the report files as
 its request body, so in about 17 minutes one address can fill the 1 GiB cap with
 its own reports, every report stored before them deleted to make room. Lowering
 `REPORTS_PER_MINUTE` or raising `DATA_DIR_MAX_BYTES` makes that take longer.
 #### CORS
@@ -340,16 +284,12 @@ the metrics record its duration and response size, labelled with its path,
 method and status; they also count those requests in progress, and include Go's
 runtime and process metrics. No other request is recorded: not those to
 `/metrics` itself, and not those answered before they reach either route, such
-as a CORS preflight, or a request refused with 404 for a path no route has or
+as a CORS preflight, or a request refused with 404 for a path no route has, 405
-405 for a method its route does not take. Run on its own, the backend also
+for a method its route does not take, or 413 for declaring a body length over
-answers 413 before the route to a request declaring a body length over the 1 MiB
+the 1 MiB limit. A report whose body goes over the limit without declaring its
-limit, which is not recorded. A body over the limit sent without a declared
+length reaches the route, is answered 413 there, and is recorded with that
-length reaches the route and is recorded with the status the route answers,
+status. Clients can make up any number of paths and methods, and each would add
-which is 413 only when the report it reads runs past the limit: nothing after
+labels to the metrics for as long as the server runs.
 the end of the report is read. In the image neither reaches the backend: nginx
 answers both with 413 itself (see [Report limits](#report-limits)), and nothing
 of them is recorded. Clients can make up any number of paths and methods, and
 each would add labels to the metrics for as long as the server runs.
 `/metrics` is rate limited, so that its password cannot be guessed quickly: each
 client address, resolved through `TRUSTED_PROXIES`, may make 60 requests to it a
@@ -472,15 +412,11 @@ address nginx passes on and no other. The image:
 - Listens on port 8080 by default (override with `PORT` env var)
 - Takes the client address from `X-Forwarded-For` only on requests from the
-  reverse proxies named in `TRUSTED_PROXIES`, by default from any address in
+  reverse proxies named in `TRUSTED_PROXIES`, and by default from none.
-  `10.0.0.0/8`, `172.16.0.0/12` or `192.168.0.0/16`. `bin/entrypoint.sh` checks
+  `bin/entrypoint.sh` checks each entry with `netwatch-server check-cidr`, which
-  each entry with `netwatch-server check-cidr`, which parses it as the backend
+  parses it as the backend parses its own `TRUSTED_PROXIES`
  parses its own `TRUSTED_PROXIES`
 - Sends access logs to stdout
- Sends the page with `Cache-Control: no-cache`, so a browser that keeps a copy
+- Caches static assets with immutable headers
  checks with the server that it is current before using it again; only the
  files under `/assets/`, whose names change whenever their contents do, are
  cached as immutable
 - Sends the security headers `REPO_POLICIES.md` requires on every response, as
  `configs/security-headers.conf` sets them, in place of the backend's own
 - Stores reports in `DATA_DIR`, `/data/reports` by default, on the `/data`
@@ -497,9 +433,9 @@ What the [upaas](https://git.eeqj.de/sneak/upaas) app for netwatch needs:
 - **Port:** container port `8080`.
 - **Volume:** container path `/data`; the reports are kept in `/data/reports`.
- **Environment variables:** none is required. An empty one counts as unset,
+- **Environment variables:** none is required. An empty one counts as unset, and
-  except `TRUSTED_PROXIES`, and one set to a value netwatch cannot use stops the
+  one set to a value netwatch cannot use stops the container at start, with the
-  container at start, with the reason in its log.
+  reason in its log.
    - `PORT`, default `8080`: the container port, from 1 to 65535. `8081` cannot
      be used: the backend listens on it inside the container
    - `REPORTS_PER_MINUTE`, default `60`: reports each client address may send a
@@ -513,17 +449,16 @@ What the [upaas](https://git.eeqj.de/sneak/upaas) app for netwatch needs:
      in: `/data` or a path below it, with no `.` or `..` part and no extra `/`.
      The container also stops if the path goes through a symbolic link that
      leads out of `/data` or is written as a full path
-    - `TRUSTED_PROXIES`, default `10.0.0.0/8,172.16.0.0/12,192.168.0.0/16`: the
+    - `TRUSTED_PROXIES`, default empty: set it to the address the reverse proxy
-      addresses the reverse proxy in front of the container connects from, as IP
+      in front of the container connects from, as an IP address or CIDR; several
-      addresses or CIDRs separated by commas. nginx takes the client address
+      are separated by commas. nginx takes the client address from
-      from `X-Forwarded-For` only on a request from one of them, and the rate
+      `X-Forwarded-For` only on a request from one of them, and the rate limit
-      limit counts that address. A list replaces the default. Set and empty,
+      counts that address. Unset, `X-Forwarded-For` is ignored and every client
-      `X-Forwarded-For` is ignored and every client behind the proxy shares the
+      behind the proxy shares the proxy's one allowance of `REPORTS_PER_MINUTE`.
-      proxy's one allowance of `REPORTS_PER_MINUTE`. Any client that connects
+      Name only addresses nothing but the proxy connects from: any client that
-      from one of these addresses can write its own `X-Forwarded-For`, and
+      connects from one can write its own `X-Forwarded-For`, and through a port
-      through a port Docker publishes, every client may connect from the Docker
+      Docker publishes, every client may connect from the Docker network's
-      network's gateway, such as `172.17.0.1`, which the default includes; where
+      gateway, such as `172.17.0.1`.
      that matters, name only the addresses nothing but the proxy connects from.
    - `METRICS_USERNAME` and `METRICS_PASSWORD`, default empty: with both set,
      the backend records Prometheus metrics of its requests and serves them at
      `/metrics` on the container port, to requests with this user name and
@@ -21,157 +21,6 @@ Run `make frontend-viewport-test` in CI as its own step; it is not part of
 # Completed Steps
 - 2026-10-18: when the backend runs on its own, a `DATA_DIR` that cannot be
  created or read, or where no file can be created, stops the start with an
  error naming `DATA_DIR` and its value, as the other settings' errors do
  ([#148](https://git.eeqj.de/sneak/netwatch/issues/148)); the first two named
  only the path, and the third was found only at the first write of a report
  file. At start the server creates a file in `DATA_DIR` and removes it. Unit
  tests start the buffer with `DATA_DIR` below a regular file and with
  `DATA_DIR` set to `/proc`, and check the error. The report file number is an
  `atomic.Int64`, as the Go style guide asks for int types
  ([#161](https://git.eeqj.de/sneak/netwatch/issues/161)); file names are
  unchanged
 - 2026-10-18: the image's nginx sends the page with `Cache-Control: no-cache`
  ([#141](https://git.eeqj.de/sneak/netwatch/issues/141)), so a browser that
  keeps a copy checks with the server that it is current before using it again.
  The page went out with no `Cache-Control`, so a browser could keep it after a
  deploy and ask for files under `/assets/` that the new build no longer has,
  and show an empty page. A path that `location /` answers with the page through
  its `try_files` fallback gets the same header. `location /` now includes the
  security headers again, as `/assets/` does, since its own `add_header` drops
  the server's. `/assets/` keeps its immutable caching.
  `make frontend-viewport-test` fails unless `/` and a path that falls back to
  the page carry `Cache-Control: no-cache` and `Content-Security-Policy`, which
  comes from the same file as the other security headers
 - 2026-10-18: `README.md` says what the page loses while reports are refused or
  the page is paused ([#145](https://git.eeqj.de/sneak/netwatch/issues/145)),
  how fast one address can replace the stored reports
  ([#146](https://git.eeqj.de/sneak/netwatch/issues/146)), and that in the image
  nginx answers a body over 1 MiB itself
  ([#147](https://git.eeqj.de/sneak/netwatch/issues/147)). A sample in the
  history that no report has delivered is sent only as long as the history holds
  it: at the 1-second interval one refused or failed report loses the oldest 20
  seconds of each host's samples, and a pause longer than the history loses
  every sample between the last delivered report and the pause. Samples an
  interval change cleared are kept apart, the last 100 per host, until they are
  delivered. At the defaults, one address sending 1 MiB reports made up to
  compress badly can fill the 1 GiB cap in about 17 minutes. nginx's
  `client_max_body_size` is also 1 MiB by default, so in the image it answers a
  larger body with 413 and its own HTML page, and the backend never sees or
  records it; the backend's own 413 sentences now say they apply to it run on
  its own. The reporter, the body limit and nginx are unchanged
 - 2026-10-18: a browser that cannot format the header's clocks still probes
  ([#149](https://git.eeqj.de/sneak/netwatch/issues/149)). The clocks name the
  local time zone through `Intl.DateTimeFormat`'s `shortGeneric` option, which
  Chrome before 95, Firefox before 91 and Safari before 15.4 reject with an
  error; it came before the first round started, so such a browser never checked
  a target. The clocks now start last, after the rounds, and an error formatting
  them leaves both blank. The footer's color legend reads `>=500ms` for red,
  where it read `>500ms`, so 500 ms, which is red, is in one of its colors
  ([#152](https://git.eeqj.de/sneak/netwatch/issues/152)). Unit tests check the
  clocks with a working `Intl.DateTimeFormat` and with one that rejects
  `shortGeneric`, and draw the page and check the legend against every entry of
  `CONFIG.latencyColors`
 - 2026-10-18: `netwatch-server prepare-data-dir` no longer changes the owner of
  a file outside `/data` through a hard link in the volume
  ([#143](https://git.eeqj.de/sneak/netwatch/issues/143)). A file with a second
  name (hard link) keeps its owner, and the start logs its path. Owners are now
  set on the opened directory, file or link, never by name, so a hard link
  swapped in after the check is caught too; a symbolic link is opened without
  following it and given to the netwatch user itself, so the server can still
  follow one in a sticky directory that anyone can write to. Devices, named
  pipes and sockets keep their owner. Setting the owner on an open file that is
  not a directory is built only for Linux: `prepare-data-dir` runs only in the
  Linux image, and macOS, where the backend is also built for development, has
  neither `O_PATH` nor `AT_EMPTY_PATH`. On any other system the package still
  builds, and `prepare-data-dir` fails at the first file that is not a
  directory. The test that runs as root hard-links a file, a symbolic link and a
  named pipe from outside the volume into it and finds their owners unchanged
 - 2026-10-18: from a trusted proxy, the backend takes the client address from
  the right-most `X-Forwarded-For` entry that is not in `TRUSTED_PROXIES`
  ([#144](https://git.eeqj.de/sneak/netwatch/issues/144)). It took the left-most
  entry, which the client writes itself behind a proxy that appends to the
  header, so a client could choose the address the rate limit counts and the
  request log records. An entry written as an address with a port is read as
  that address. With only trusted addresses in the header, or an entry that is
  not an address at all (such as `unknown`) met on the way, the direct peer is
  used. `X-Real-IP` is read only without `X-Forwarded-For`, and every
  `X-Forwarded-For` header line is read, not only the first. The image's nginx,
  and the `TRUSTED_PROXIES=127.0.0.1/32` it starts the backend with, are
  unchanged; the comment in `configs/nginx.conf` that said the backend takes the
  first entry now says it takes the one address nginx passes on. Unit tests
  resolve the address from chains ending in an untrusted address, in trusted
  ones, of only trusted ones, with ports, with an entry that is not an address,
  and split over two header lines
 - 2026-10-18: after an interval change, the summary's Reachable slot reads
  `--/--` in white, as at page load, until the second round since the change
  ends ([#140](https://git.eeqj.de/sneak/netwatch/issues/140)). It used to read
  0/26 in red from the change on, as no WAN host had a check recorded, for up to
  two intervals with the network fine. The summary update now writes `--/--`
  while every WAN host still waits for its first check. A unit test resets the
  hosts as the interval menu does and checks the slot; another checks that it
  reads 0/26 in red once every WAN host's check has failed
 - 2026-10-14: stopping the server waits for a report file write already under
  way, the periodic flush's or the one `Append` starts when 10 MiB are waiting,
  before the final flush
  ([#122](https://git.eeqj.de/sneak/netwatch/issues/122)). It used to return at
  once, and the process exiting cut the write off, losing its reports. A write
  under way that fails puts its reports back in memory, so the final flush
  writes them; the stop fails, and the process exits non-zero, only if that
  flush fails too. Two tests hold the periodic write and the one at 10 MiB open
  and find the stop waiting until each is released; a third makes the held write
  fail and finds its report written by the final flush. They run in a
  `testing/synctest` bubble, so the periodic flush comes without waiting a
  minute
 - 2026-10-14: `make test` no longer runs the frontend's production build, which
  the tests do not need ([#118](https://git.eeqj.de/sneak/netwatch/issues/118)).
  `yarn build` moved out of the stage that runs the frontend's unit tests, now
  named `frontend-test`, into a new `frontend-build` stage, which starts from it
  and, like the `builder` stage, waits on the lint and test phases, so the image
  still cannot be built unless they pass. The runtime stage copies `dist/` from
  it, and the `git` that `vite.config.js` reads the commit with is installed
  there. No build cache was added
 - 2026-10-14: opening the debug log no longer raises the measured latencies
  ([#131](https://git.eeqj.de/sneak/netwatch/issues/131)). With the panel open,
  each line written drew the panel again with every line before it, up to 1000,
  and a check that ends while the page draws is timed only when the drawing is
  done. Each line is now added at the end of the open panel, its first line is
  dropped once it holds more than 1000, and it scrolls to its newest line once a
  frame rather than once a line; the whole panel is drawn only when it is
  opened. A unit test writes more lines than the panel keeps and checks that the
  lines already shown are left as they are
 - 2026-10-14: unset, the backend's own `TRUSTED_PROXIES` trusts `10.0.0.0/8`,
  `172.16.0.0/12` and `192.168.0.0/16`, and no longer loopback; a list replaces
  that; set and empty, it trusts no proxy, where it used to get the default, as
  viper reads an empty environment variable as unset
  ([#129](https://git.eeqj.de/sneak/netwatch/issues/129)). A value it cannot
  parse still stops the start, and the image still starts the backend with
  `TRUSTED_PROXIES=127.0.0.1/32`. Tests load the config with it unset, empty and
  set to a list
 - 2026-10-14: while report files cannot be written, `POST /api/v1/reports`
  answers 500, and storing recovers once writing works again, with no restart
  ([#123](https://git.eeqj.de/sneak/netwatch/issues/123)). A failed write puts
  its reports back in the report buffer, still counted against
  `DATA_DIR_MAX_BYTES`, where they used to be lost; the next flush, within a
  minute, tries them again. Until a write succeeds, every report is refused and
  nothing of it is kept, so the buffer does not grow while writes fail. A test
  posts reports through the report handler before, during and after a failure;
  others check that a report appended while a write runs is kept, behind that
  write's own, when the write fails, and that the cap still holds exactly once a
  failed write's reports are written
 - 2026-10-14: a request whose handler panics is logged with status 500 and
  counted with `code` 500 in the metrics
  ([#125](https://git.eeqj.de/sneak/netwatch/issues/125)), not 200. `Recoverer`
  is still the first middleware; `Write500OnPanic`, after the request log and
  after the metrics, writes the 500 as the panic passes and lets it go on to
  Sentry and `Recoverer`, which now writes a 500 only when no status was written
 - 2026-10-14: with `TRUSTED_PROXIES` unset, the container's nginx trusts the
  three private ranges of RFC 1918, `10.0.0.0/8`, `172.16.0.0/12` and
  `192.168.0.0/16` ([#119](https://git.eeqj.de/sneak/netwatch/issues/119)), as
  sneak ruled on 2026-09-22 for every app; it trusted no proxy before. A list
  replaces them, and set and empty it trusts none. The backend inside the
  container still trusts only `127.0.0.1/32`
 - 2026-10-14: `POST /api/v1/reports` takes only a report sent with
  `Content-Type: application/json`, parameters such as `charset` allowed, and
  refuses any other with 415 and the usual error body, storing nothing
@@ -614,9 +463,3 @@ Run `make frontend-viewport-test` in CI as its own step; it is not part of
 - A configurable host list (an environment variable or a config file)
 - Export of the latency history (CSV or JSON)
 - A notification when the health status changes to DEGRADED
 - `make test` within the 20-second target
  ([#118](https://git.eeqj.de/sneak/netwatch/issues/118)): every run compiles
  the Go standard library and every dependency with the race detector from
  nothing. Whether test builds may keep Go's compiled packages between runs
  waits on sneak's ruling in
  [prompts#113](https://git.eeqj.de/sneak/prompts/issues/113)
@@ -34,11 +34,9 @@ fi
 # TRUSTED_PROXIES names the reverse proxies in front of the container,
 # as IP addresses or CIDRs separated by commas. nginx takes the client
-# address from X-Forwarded-For only on a request from one of them.
+# address from X-Forwarded-For only on a request from one of them, so
-# Unset, they are the three private ranges of RFC 1918; set and empty,
+# unset or empty, it trusts no one. configs/nginx.conf includes the file
-# nginx trusts no one, which is why the default below follows - and not
+# written here, one set_real_ip_from line per entry.
 # :-. configs/nginx.conf includes the file written here, one
 # set_real_ip_from line per entry.
 #
 # nginx looks up an entry it cannot read as an address as a hostname,
 # and trusts what it finds (1.2.3 is found as 1.2.0.3). So each entry
@@ -47,7 +45,7 @@ fi
 # TRUSTED_PROXIES. Its error, naming the CIDR, is dropped for the one
 # below, naming the entry as written. set -f keeps a * in an entry from
 # becoming a list of file names.
-TRUSTED_PROXIES="${TRUSTED_PROXIES-10.0.0.0/8,172.16.0.0/12,192.168.0.0/16}"
+TRUSTED_PROXIES="${TRUSTED_PROXIES:-}"
 set -f
 for proxy in $(printf '%s' "$TRUSTED_PROXIES" | tr ',' ' '); do
    case "$proxy" in
@@ -66,13 +64,10 @@ done > /etc/nginx/trusted-proxies.conf
 # netwatch-server keeps its report files in DATA_DIR, on the /data
 # volume, which may be a host directory owned by root or by another
 # uid. Here, as root, netwatch-server prepare-data-dir creates DATA_DIR
-# and gives /data and the directories, regular files and symbolic links
+# and gives /data and everything in it to the netwatch user, so the
-# in it to the netwatch user, so the host directory needs no preparing.
+# host directory needs no preparing. It stops the start, naming
-# A file with a second name (hard link) keeps its owner, as that name
+# DATA_DIR, unless DATA_DIR is /data or a path below it, and it acts on
-# could be outside /data, and its path is logged. It stops the start,
+# nothing outside /data, whatever symbolic links it meets there.
 # naming DATA_DIR, unless DATA_DIR is /data or a path below it, and it
 # acts on nothing outside /data, whatever symbolic or hard links it
 # meets there.
 export DATA_DIR="${DATA_DIR:-/data/reports}"
 netwatch-server prepare-data-dir "$DATA_DIR" || exit 1
@@ -18,10 +18,9 @@ server {
    # The client address comes from X-Forwarded-For only on a request
    # from the reverse proxies in TRUSTED_PROXIES: bin/entrypoint.sh
-    # writes one set_real_ip_from line for each into this file. Unset,
+    # writes one set_real_ip_from line for each into this file, and
-    # TRUSTED_PROXIES is the three private ranges of RFC 1918; set and
+    # leaves it empty when TRUSTED_PROXIES is unset, so that by default
-    # empty, the file is empty and the client address is the one each
+    # the client address is the one each request comes from.
    # request comes from.
    include /etc/nginx/trusted-proxies.conf;
    real_ip_header X-Forwarded-For;
    real_ip_recursive on;
@@ -30,13 +29,8 @@ server {
    access_log /dev/stdout combined;
    error_log  /dev/stderr warn;
    # With no-cache, a browser never uses a copy of the page that names
    # assets a newer build no longer has without first checking with the
    # server that it is current.
    location / {
        try_files $uri $uri/ /index.html;
        add_header Cache-Control no-cache;
        include /etc/nginx/security-headers.conf;
    }
    # Cache static assets aggressively
@@ -51,9 +45,7 @@ server {
    # 127.0.0.1:8081. These headers go with every request passed to it.
    # X-Forwarded-For carries only the client address, as resolved by
    # the real IP settings above, and not the chain the request came
-    # with. bin/entrypoint.sh starts the backend with
+    # with: the backend takes the first entry, which a client can write.
    # TRUSTED_PROXIES=127.0.0.1/32, the address nginx connects from, so
    # the backend takes that one entry as the client address.
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $remote_addr;
@@ -17,7 +17,6 @@ require (
 	github.com/slok/go-http-metrics v0.13.0
 	github.com/spf13/viper v1.21.0
 	go.uber.org/fx v1.24.0
 	golang.org/x/sys v0.47.0
 )
 require (
@@ -42,6 +41,7 @@ require (
 	go.uber.org/multierr v1.10.0 // indirect
 	go.uber.org/zap v1.26.0 // indirect
 	go.yaml.in/yaml/v3 v3.0.4 // indirect
 	golang.org/x/sys v0.47.0 // indirect
 	golang.org/x/text v0.40.0 // indirect
 	google.golang.org/protobuf v1.36.11 // indirect
 )
@@ -9,7 +9,6 @@ import (
 	"math"
 	"net/netip"
 	"net/url"
 	"os"
 	"strconv"
 	"strings"
@@ -22,11 +21,13 @@ import (
 )
 // defaultTrustedProxies lists the networks whose forwarded
-// headers are honoured when TRUSTED_PROXIES is unset: the
+// headers are honoured by default: IPv4 and IPv6 loopback,
-// RFC 1918 ranges. The container image does not use it:
+// for a reverse proxy on the same host, and the RFC1918
 // ranges. The container image does not use it:
 // bin/entrypoint.sh gives the server 127.0.0.1/32, since
 // nginx is its only client there.
-const defaultTrustedProxies = "10.0.0.0/8,172.16.0.0/12,192.168.0.0/16"
+const defaultTrustedProxies = "127.0.0.1/32,::1/128," +
 	"10.0.0.0/8,172.16.0.0/12,192.168.0.0/16"
 // Default limits on stored reports; README.md gives the reasons for
 // these values.
@@ -134,14 +135,6 @@ func New(
 			viper.GetString("DEBUG"), errNotBool)
 	}
 	// An empty TRUSTED_PROXIES trusts no proxy, but viper reads an
 	// empty environment variable as unset and would give the default,
 	// so the environment is read first.
 	trustedProxies, set := os.LookupEnv("TRUSTED_PROXIES")
 	if !set {
 		trustedProxies = viper.GetString("TRUSTED_PROXIES")
 	}
 	s := &Config{
 		BindAddress:        viper.GetString("BIND_ADDRESS"),
 		CORSAllowedOrigins: splitList(viper.GetString("CORS_ALLOWED_ORIGINS")),
@@ -153,7 +146,7 @@ func New(
 		Port:               port,
 		ReportsPerMinute:   viper.GetInt("REPORTS_PER_MINUTE"),
 		SentryDSN:          viper.GetString("SENTRY_DSN"),
-		TrustedProxies:     splitList(trustedProxies),
+		TrustedProxies:     splitList(viper.GetString("TRUSTED_PROXIES")),
 		log:                log,
 		params:             &params,
 	}
@@ -1,8 +1,6 @@
 package config_test
 import (
 	"os"
 	"slices"
 	"strings"
 	"testing"
@@ -31,62 +29,6 @@ func requireConfigError(t *testing.T, setting string) {
 	}
 }
 // requireTrustedProxies builds the config as main does and fails the
 // test unless its TrustedProxies are want.
 func requireTrustedProxies(t *testing.T, want []string) {
 	t.Helper()
 	var cfg *config.Config
 	app := fx.New(
 		fx.NopLogger,
 		fx.Provide(globals.New, logger.New, config.New),
 		fx.Populate(&cfg),
 	)
 	err := app.Err()
 	if err != nil {
 		t.Fatalf("config error = %v", err)
 	}
 	if !slices.Equal(cfg.TrustedProxies, want) {
 		t.Fatalf("TrustedProxies = %q, want %q", cfg.TrustedProxies, want)
 	}
 }
 // TestTrustedProxiesUnsetTrustsRFC1918: unset, the server trusts the
 // RFC 1918 ranges and nothing else, loopback included.
 func TestTrustedProxiesUnsetTrustsRFC1918(t *testing.T) {
 	// t.Setenv first, so the variable is put back as it was after the
 	// test.
 	t.Setenv("TRUSTED_PROXIES", "")
 	err := os.Unsetenv("TRUSTED_PROXIES")
 	if err != nil {
 		t.Fatal(err)
 	}
 	requireTrustedProxies(t,
 		[]string{"10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16"})
 }
 // TestTrustedProxiesEmptyTrustsNothing: set and empty, the server
 // trusts no proxy. viper alone would read the empty variable as unset
 // and give the default.
 func TestTrustedProxiesEmptyTrustsNothing(t *testing.T) {
 	t.Setenv("TRUSTED_PROXIES", "")
 	requireTrustedProxies(t, []string{})
 }
 // TestTrustedProxiesListReplacesDefault: a list is used as given, with
 // none of the default ranges added.
 func TestTrustedProxiesListReplacesDefault(t *testing.T) {
 	t.Setenv("TRUSTED_PROXIES", "172.17.0.1/32, 2001:db8::/32")
 	requireTrustedProxies(t, []string{"172.17.0.1/32", "2001:db8::/32"})
 }
 // TestSettingsLoadAsGiven: valid values pass the checks and are used
 // as given. bin/entrypoint.sh starts the server with these
 // BIND_ADDRESS and PORT values.
@@ -93,7 +93,7 @@ func (s *Handlers) decodeErrorStatus(err error) int {
 // appendErrorStatus logs a failure to store a report and returns
 // the status to send: 507 when the reports waiting to be written fill
-// the size cap, otherwise 500, as when report files cannot be written.
+// the size cap, otherwise 500.
 func (s *Handlers) appendErrorStatus(err error) int {
 	if errors.Is(err, reportbuf.ErrFull) {
 		s.log.Warn("report refused: " +
@@ -11,7 +11,6 @@ import (
 	"net/http"
 	"net/netip"
 	"runtime/debug"
 	"slices"
 	"strings"
 	"time"
@@ -134,17 +133,6 @@ func ipFromHostPort(hostPort string) string {
 // X-Real-IP are honoured only when the direct peer is a
 // trusted proxy; otherwise the direct peer is returned so a
 // spoofed header cannot forge the logged address.
 //
 // Each proxy appends to X-Forwarded-For the address it took the
 // request from, so the entries on the right are written by the
 // trusted proxies and those further left by the client. The
 // client's address is therefore the right-most entry that is not
 // a trusted proxy. An entry written as an address with a port is
 // read as that address, both for the trust check and as the
 // result. When every entry is a trusted proxy, or the walk from
 // the right meets an entry that is not an address at all (such as
 // "unknown"), the peer is used. X-Real-IP is read only when there
 // is no X-Forwarded-For entry at all.
 func clientIP(
 	remoteAddr string,
 	header http.Header,
@@ -156,49 +144,28 @@ func clientIP(
 		return peer
 	}
-	forwarded := forwardedFor(header)
+	if xff := firstForwardedFor(header.Get("X-Forwarded-For")); xff != "" {
-
+		return xff
 	if len(forwarded) == 0 {
 		if xr := strings.TrimSpace(header.Get("X-Real-IP")); validIP(xr) {
 			return xr
 		}
 		return peer
 	}
-	for _, entry := range slices.Backward(forwarded) {
+	if xr := strings.TrimSpace(header.Get("X-Real-IP")); validIP(xr) {
-		if !validIP(entry) {
+		return xr
 			return peer
 		}
 		if !addrInAny(entry, trusted) {
 			return entry
 		}
 	}
 	return peer
 }
-// forwardedFor returns the entries of X-Forwarded-For in order,
+// firstForwardedFor returns the left-most valid address in an
-// leaving out blank ones. A proxy may add its entry as a header
+// X-Forwarded-For list (the original client), or "" if none.
-// line of its own rather than append it to the line the client
+func firstForwardedFor(value string) string {
 // sent, so every line is read, not only the first. Some proxies
 // write an entry as an address with a port, such as
 // 198.51.100.7:5000 or [2001:db8::1]:443; the port is removed so
 // that the entry is read as its address.
 func forwardedFor(header http.Header) []string {
 	value := strings.Join(header.Values("X-Forwarded-For"), ",")
 	var entries []string
 	for part := range strings.SplitSeq(value, ",") {
-		entry := strings.TrimSpace(part)
+		candidate := strings.TrimSpace(part)
-		if entry != "" {
+		if validIP(candidate) {
-			entries = append(entries, ipFromHostPort(entry))
+			return candidate
 		}
 	}
-	return entries
+	return ""
 }
 func validIP(s string) bool {
@@ -330,16 +297,12 @@ func (s *Middleware) MaxBodyBytes(
 // Recoverer returns middleware that recovers from a panic in a
 // downstream handler, logs the panic and stack trace through
-// slog, and responds 500 with no body, unless a status was already
+// slog, and responds 500 with no body. http.ErrAbortHandler is
-// written, as Write500OnPanic writes one for a handler's panic.
+// re-panicked so the server can abort the response as intended.
 // http.ErrAbortHandler is re-panicked so the server can abort the
 // response as intended.
 func (s *Middleware) Recoverer() func(http.Handler) http.Handler {
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(
 			func(w http.ResponseWriter, r *http.Request) {
 				ww := middleware.NewWrapResponseWriter(w, r.ProtoMajor)
 				defer func() {
 					rec := recover()
 					if rec == nil {
@@ -357,43 +320,10 @@ func (s *Middleware) Recoverer() func(http.Handler) http.Handler {
 						"stack", string(debug.Stack()),
 					)
-					if ww.Status() == 0 {
+					w.WriteHeader(http.StatusInternalServerError)
 						ww.WriteHeader(http.StatusInternalServerError)
 					}
 				}()
-				next.ServeHTTP(ww, r)
+				next.ServeHTTP(w, r)
 			},
 		)
 	}
 }
 // Write500OnPanic returns middleware that writes 500 when a downstream
 // handler panics before writing a status, and lets the panic go on to
 // Sentry and Recoverer. Recoverer, which comes first, would write its
 // 500 only after the request log and the metrics had recorded the
 // status they saw; placed after each of them, this makes them record
 // the 500.
 func (s *Middleware) Write500OnPanic() func(http.Handler) http.Handler {
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(
 			func(w http.ResponseWriter, r *http.Request) {
 				ww := middleware.NewWrapResponseWriter(w, r.ProtoMajor)
 				defer func() {
 					rec := recover()
 					if rec == nil {
 						return
 					}
 					if ww.Status() == 0 {
 						ww.WriteHeader(http.StatusInternalServerError)
 					}
 					panic(rec)
 				}()
 				next.ServeHTTP(ww, r)
 			},
 		)
 	}
@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"encoding/json"
 	"errors"
 	"log"
 	"log/slog"
 	"net/http"
 	"net/http/httptest"
@@ -17,24 +16,16 @@ import (
 	"sneak.berlin/go/netwatch/internal/logger"
 	"sneak.berlin/go/netwatch/internal/middleware"
 	"github.com/go-chi/chi/v5"
 	chimiddleware "github.com/go-chi/chi/v5/middleware"
 	"github.com/prometheus/client_golang/prometheus"
 )
 const (
 	// loopbackPeer is a remote address inside the trusted-proxy allowlist.
 	loopbackPeer = "127.0.0.1:5000"
 	// loopbackIP is the address of loopbackPeer, which ClientIP returns
 	// when it uses the peer.
 	loopbackIP = "127.0.0.1"
 	// forwardedIP is the client address presented via X-Forwarded-For.
 	forwardedIP = "203.0.113.7"
 	// realIP is the client address presented via X-Real-IP.
 	realIP = "203.0.113.9"
 	// appendedIP is the X-Forwarded-For entry a trusted proxy appended
 	// after the entries the client wrote.
 	appendedIP = "198.51.100.7"
 )
 func mustPrefixes(t *testing.T, cidrs ...string) []netip.Prefix {
@@ -91,35 +82,10 @@ func clientIPCases() []clientIPCase {
 			want:       forwardedIP,
 		},
 		{
-			name:       "trusted proxy uses right-most of chain",
+			name:       "trusted proxy uses left-most of chain",
-			remoteAddr: loopbackPeer,
+			remoteAddr: "10.1.2.3:5000",
-			xff:        "203.0.113.9, " + appendedIP,
+			xff:        forwardedIP + ", 10.1.2.3",
-			want:       appendedIP,
+			want:       forwardedIP,
 		},
 		{
 			name:       "trusted proxy entries are skipped from the right",
 			remoteAddr: loopbackPeer,
 			xff:        "203.0.113.9, 10.0.0.5",
 			want:       "203.0.113.9",
 		},
 		{
 			name:       "chain of only trusted proxies uses peer",
 			remoteAddr: loopbackPeer,
 			xff:        "10.0.0.5, 10.1.2.3",
 			want:       loopbackIP,
 		},
 		{
 			name:       "entry that is not an address uses peer",
 			remoteAddr: loopbackPeer,
 			xff:        "203.0.113.9, unknown",
 			want:       loopbackIP,
 		},
 		{
 			name:       "x-real-ip ignored when forwarded-for has entries",
 			remoteAddr: loopbackPeer,
 			xff:        "10.0.0.5",
 			xRealIP:    realIP,
 			want:       loopbackIP,
 		},
 		{
 			name:       "trusted proxy falls back to x-real-ip",
@@ -148,7 +114,7 @@ func clientIPCases() []clientIPCase {
 			name:       "trusted proxy with garbage header uses peer",
 			remoteAddr: loopbackPeer,
 			xff:        "not-an-ip",
-			want:       loopbackIP,
+			want:       "127.0.0.1",
 		},
 	}
 }
@@ -179,47 +145,6 @@ func TestClientIP(t *testing.T) {
 	}
 }
 // TestClientIPReadsEveryForwardedForLine checks that an entry a proxy
 // adds as an X-Forwarded-For line of its own is read, and the line the
 // client sent before it is not taken.
 func TestClientIPReadsEveryForwardedForLine(t *testing.T) {
 	t.Parallel()
 	header := http.Header{}
 	header.Add("X-Forwarded-For", "203.0.113.9")
 	header.Add("X-Forwarded-For", appendedIP)
 	got := middleware.ClientIP(loopbackPeer, header,
 		mustPrefixes(t, "127.0.0.1/32"))
 	if got != appendedIP {
 		t.Errorf("ClientIP() = %q, want %q", got, appendedIP)
 	}
 }
 // TestClientIPReadsAddressWithPort checks that an X-Forwarded-For entry
 // written as an address with a port is read as that address, both for
 // the trust check and as the result.
 func TestClientIPReadsAddressWithPort(t *testing.T) {
 	t.Parallel()
 	trusted := mustPrefixes(t, "127.0.0.1/32", "10.0.0.0/8")
 	for xff, want := range map[string]string{
 		"203.0.113.9, " + appendedIP + ":5000": appendedIP,
 		"203.0.113.9, [2001:db8::1]:443":       "2001:db8::1",
 		"203.0.113.9, 10.0.0.5:5000":           "203.0.113.9",
 	} {
 		header := http.Header{}
 		header.Set("X-Forwarded-For", xff)
 		got := middleware.ClientIP(loopbackPeer, header, trusted)
 		if got != want {
 			t.Errorf("X-Forwarded-For %q: ClientIP() = %q, want %q",
 				xff, got, want)
 		}
 	}
 }
 func TestSecurityHeaders(t *testing.T) {
 	t.Parallel()
@@ -398,172 +323,6 @@ func TestRecovererRepanicsOnAbortHandler(t *testing.T) {
 	}
 }
 // TestHandlerPanicIsLoggedAndCountedAs500 sends a request to a handler
 // that panics through the middleware SetupRoutes puts around a route
 // with metrics, in its order, leaving out those that write no status
 // for a panic and Sentry, which TestSentry covers. The request log line
 // and the metrics must give the 500 the client gets, and the panic must
 // still reach Recoverer, which logs it.
 func TestHandlerPanicIsLoggedAndCountedAs500(t *testing.T) {
 	t.Parallel()
 	var logbuf bytes.Buffer
 	mw := middleware.NewWithLogger(
 		slog.New(slog.NewJSONHandler(&logbuf, nil)),
 	)
 	registry := prometheus.NewRegistry()
 	handler := chi.Chain(
 		mw.Recoverer(),
 		chimiddleware.RequestID,
 		mw.Logging(),
 		mw.Write500OnPanic(),
 		mw.Metrics(registry),
 		mw.Write500OnPanic(),
 	).HandlerFunc(func(http.ResponseWriter, *http.Request) {
 		panic("boom")
 	})
 	rec := httptest.NewRecorder()
 	req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/", http.NoBody)
 	handler.ServeHTTP(rec, req)
 	if rec.Code != http.StatusInternalServerError {
 		t.Fatalf("status = %d, want %d",
 			rec.Code, http.StatusInternalServerError)
 	}
 	request := findLogLine(t, logbuf.Bytes(), "request")
 	if request.Status != http.StatusInternalServerError {
 		t.Errorf("request log status = %d, want %d",
 			request.Status, http.StatusInternalServerError)
 	}
 	recovered := findLogLine(t, logbuf.Bytes(), "panic recovered")
 	if recovered.Panic != "boom" {
 		t.Errorf("panic recovered line has panic %q, want %q",
 			recovered.Panic, "boom")
 	}
 	for _, name := range []string{
 		"http_request_duration_seconds", "http_response_size_bytes",
 	} {
 		codes := metricCodes(t, registry, name)
 		if len(codes) != 1 || codes[0] != "500" {
 			t.Errorf("%s code labels = %v, want [500]", name, codes)
 		}
 	}
 }
 // loggedLine holds the fields the tests read from a JSON log line.
 type loggedLine struct {
 	Msg    string `json:"msg"`
 	Status int    `json:"status"`
 	Panic  string `json:"panic"`
 }
 // findLogLine returns the first of the JSON log lines in logged whose
 // message is msg.
 func findLogLine(t *testing.T, logged []byte, msg string) loggedLine {
 	t.Helper()
 	dec := json.NewDecoder(bytes.NewReader(logged))
 	for {
 		var line loggedLine
 		err := dec.Decode(&line)
 		if err != nil {
 			t.Fatalf("no %q line in the log: %v (%q)", msg, err, logged)
 		}
 		if line.Msg == msg {
 			return line
 		}
 	}
 }
 // metricCodes returns the code label of each series of the metric
 // family name in registry.
 func metricCodes(
 	t *testing.T,
 	registry *prometheus.Registry,
 	name string,
 ) []string {
 	t.Helper()
 	families, err := registry.Gather()
 	if err != nil {
 		t.Fatalf("gather metrics: %v", err)
 	}
 	var codes []string
 	for _, family := range families {
 		if family.GetName() != name {
 			continue
 		}
 		for _, metric := range family.GetMetric() {
 			for _, label := range metric.GetLabel() {
 				if label.GetName() == "code" {
 					codes = append(codes, label.GetValue())
 				}
 			}
 		}
 	}
 	return codes
 }
 // TestRecovererWritesNoSecondStatus checks, on a real server, that
 // Recoverer does not write its 500 again after Write500OnPanic has
 // written one, which the server would log as a superfluous
 // WriteHeader call.
 func TestRecovererWritesNoSecondStatus(t *testing.T) {
 	t.Parallel()
 	var serverLog bytes.Buffer
 	mw := middleware.NewWithLogger(slog.New(slog.DiscardHandler))
 	server := httptest.NewUnstartedServer(chi.Chain(
 		mw.Recoverer(),
 		mw.Write500OnPanic(),
 	).HandlerFunc(func(http.ResponseWriter, *http.Request) {
 		panic("boom")
 	}))
 	server.Config.ErrorLog = log.New(&serverLog, "", 0)
 	server.Start()
 	req, err := http.NewRequestWithContext(t.Context(),
 		http.MethodGet, server.URL, http.NoBody)
 	if err != nil {
 		t.Fatalf("new request: %v", err)
 	}
 	resp, err := server.Client().Do(req)
 	if err != nil {
 		t.Fatalf("request: %v", err)
 	}
 	_ = resp.Body.Close()
 	// Close waits for the handler to return, so whatever the server
 	// logs for this request is in serverLog after it.
 	server.Close()
 	if resp.StatusCode != http.StatusInternalServerError {
 		t.Errorf("status = %d, want %d",
 			resp.StatusCode, http.StatusInternalServerError)
 	}
 	if serverLog.Len() != 0 {
 		t.Errorf("server logged %q", serverLog.String())
 	}
 }
 // TestLoggingCutsRequestStringsToBound sends an over-long URL and
 // over-long header values, and checks the request log writes each
 // one cut to logger.MaxLoggedFieldBytes.
@@ -18,15 +18,9 @@ var ErrDataDirOutsideVolume = errors.New(
 // PrepareDataDir gets dir, the server's DATA_DIR, ready for owner, the
 // user the server runs as, so that a host directory mounted at volume,
 // /data in the image, needs no preparing: it creates dir, gives volume
-// and the directories, regular files and symbolic links in it to
+// and everything in it to owner, and gives volume and dir the mode the
-// owner, and gives volume and dir the mode the server gives a directory
+// server gives a directory it creates. dir must be volume or a path
-// it creates. It leaves a file with a second name (hard link) as it
+// below it, with no '.', '..', empty part or '/' at the end.
 // is, as that name could be outside volume, and logs its path; it
 // leaves a device, named pipe or socket as it is too (see chownFile).
 // dir must be volume or a path below it, with no '.', '..', empty part
 // or '/' at the end. On any system but Linux, the system of the image, it
 // fails at the first file in volume that is not a directory (see
 // chownFile).
 //
 // bin/entrypoint.sh runs this as root, which would follow a symbolic
 // link anywhere, so every step goes through an os.Root opened on
@@ -38,9 +32,10 @@ var ErrDataDirOutsideVolume = errors.New(
 // open, never following a link at the name it creates, and follows a
 // link on the path only as the os.Root allows, so a relative link
 // inside volume can lead it to create directories elsewhere inside
-// volume. The owners and modes are set on files already opened (see
+// volume. Lchown never changes what a link points to, and the modes
-// chownAll and chmodDir), so the most that process can do is make a
+// are set on directories already opened (see chmodDir), so the most
-// step fail or wait, or act on something else inside volume.
+// that process can do is make a step fail or wait, or act on
 // something else inside volume.
 func PrepareDataDir(volume, dir string, owner *user.User) error {
 	// rel is dir as a path from volume; IsLocal is false for one that
 	// leads out of it.
@@ -71,7 +66,7 @@ func PrepareDataDir(volume, dir string, owner *user.User) error {
 		return err
 	}
-	err = chownAll(root, ".", uid, gid)
+	err = lchownAll(root, ".", uid, gid)
 	if err != nil {
 		return err
 	}
@@ -84,23 +79,28 @@ func PrepareDataDir(volume, dir string, owner *user.User) error {
 	return chmodDir(root, rel)
 }
-// chownAll gives name, a directory inside root, and the directories,
+// lchownAll gives name, a directory inside root, and everything in it
-// regular files and symbolic links in it to uid and gid, but not the
+// to uid and gid. It reads each directory opened through root, not
-// files chownFile leaves. It opens each through root and gives the
+// through root.FS(), which refuses a name that is not valid UTF-8, and
-// open file to them, as chmodDir sets a mode on the open directory.
+// calls Lchown on every entry, which gives a symbolic link itself to
-// Root.Lchown would not hold: it acts on whatever is at the name by
+// them, not what it points to. It goes into an entry only when the
-// then, and a hard link swapped in there shares its owner with a file
+// read found a directory there, so it follows no link it finds; one
-// that could be outside root. A symbolic link is given to them itself,
+// swapped in for that directory afterwards is followed only as the
-// never what it points to, because in a directory that anyone can
+// os.Root allows.
-// write to and that has the sticky bit set, as /tmp has, the kernel
+func lchownAll(root *os.Root, name string, uid, gid int) error {
-// follows a link only for the link's owner or when the link and the
+	err := root.Lchown(name, uid, gid)
-// directory have the same owner. chownAll goes into an entry only when
+	if err != nil {
-// the read found a directory there, so it follows no link it finds;
+		return err
-// one swapped in afterwards for a directory is followed only as the
+	}
-// os.Root allows, and one swapped in for any other file is not
+
-// followed at all (see chownFile).
+	dir, err := root.Open(name)
-func chownAll(root *os.Root, name string, uid, gid int) error {
+	if err != nil {
-	entries, err := chownDir(root, name, uid, gid)
+		return err
 	}
 	entries, err := dir.ReadDir(-1)
 	_ = dir.Close()
 	if err != nil {
 		return err
 	}
@@ -108,9 +108,9 @@ func chownAll(root *os.Root, name string, uid, gid int) error {
 	for _, entry := range entries {
 		entryName := filepath.Join(name, entry.Name())
 		if entry.IsDir() {
-			err = chownAll(root, entryName, uid, gid)
+			err = lchownAll(root, entryName, uid, gid)
 		} else {
-			err = chownFile(root, entryName, uid, gid)
+			err = root.Lchown(entryName, uid, gid)
 		}
 		if err != nil {
@@ -121,36 +121,6 @@ func chownAll(root *os.Root, name string, uid, gid int) error {
 	return nil
 }
 // chownDir gives name, a directory inside root, to uid and gid, and
 // returns what it holds. Like chmodDir, it opens name through root and
 // refuses anything but a directory, which has no second name (hard
 // link). It reads the open directory, not root.FS(), which refuses a
 // name that is not valid UTF-8.
 func chownDir(root *os.Root, name string, uid, gid int) ([]fs.DirEntry, error) {
 	dir, err := root.Open(name)
 	if err != nil {
 		return nil, err
 	}
 	defer func() { _ = dir.Close() }()
 	info, err := dir.Stat()
 	if err != nil {
 		return nil, err
 	}
 	if !info.IsDir() {
 		return nil, &fs.PathError{Op: "chown", Path: name, Err: syscall.ENOTDIR}
 	}
 	err = dir.Chown(uid, gid)
 	if err != nil {
 		return nil, err
 	}
 	return dir.ReadDir(-1)
 }
 // chmodDir gives name, a directory inside root, the mode the server
 // gives a directory it creates. Root.Chmod would not hold: on Linux it
 // checks that name is not a symbolic link, then sets the mode by name,
@@ -1,65 +0,0 @@
 //go:build linux
 package reportbuf
 import (
 	"io/fs"
 	"log/slog"
 	"os"
 	"syscall"
 	"golang.org/x/sys/unix"
 )
 // chownFile gives name, a file inside root that is not a directory, to
 // uid and gid if it is a regular file or symbolic link with one name.
 // It leaves, and logs, a file of any kind with a second name (hard
 // link): all the names of a file share its owner, and the other could
 // be outside root. It leaves any other file with one name, such as a
 // device, named pipe or socket: the server needs to own none of them.
 // It opens name through root with O_PATH, which reads nothing from the
 // file, so opening a device or named pipe neither waits nor acts on
 // it; os.Root adds O_NOFOLLOW, and the two together open a symbolic
 // link itself, never what it points to. It reads the kind of file and
 // its number of names from the open file and gives that file to them,
 // so a hard link swapped in at name is caught too.
 //
 // This file is built only on Linux: prepare-data-dir runs only in the
 // Linux image, and macOS, where the backend is also built for
 // development, has neither O_PATH nor AT_EMPTY_PATH. On any other
 // system chownFile returns an error (see datadir_other.go).
 func chownFile(root *os.Root, name string, uid, gid int) error {
 	file, err := root.OpenFile(name, unix.O_PATH, 0)
 	if err != nil {
 		return err
 	}
 	defer func() { _ = file.Close() }()
 	info, err := file.Stat()
 	if err != nil {
 		return err
 	}
 	stat, ok := info.Sys().(*syscall.Stat_t)
 	if !ok || stat.Nlink > 1 {
 		slog.Warn("owner not changed: file has a second name (hard link)",
 			"path", file.Name())
 		return nil
 	}
 	if !info.Mode().IsRegular() && info.Mode().Type() != fs.ModeSymlink {
 		return nil
 	}
 	// File.Chown would fail: fchown refuses a file opened with O_PATH.
 	// Fchownat with an empty name and AT_EMPTY_PATH acts on the open
 	// file instead.
 	err = unix.Fchownat(int(file.Fd()), "", uid, gid, unix.AT_EMPTY_PATH)
 	if err != nil {
 		return &fs.PathError{Op: "chown", Path: file.Name(), Err: err}
 	}
 	return nil
 }
@@ -1,21 +0,0 @@
 //go:build !linux
 package reportbuf
 import (
 	"errors"
 	"io/fs"
 	"os"
 )
 // chownFile returns an error on every system but Linux. Opening a file
 // that is not a directory without reading it or following it, and
 // giving it to a user on the open file, never by name, is built only
 // for Linux (see datadir_linux.go): prepare-data-dir runs only in the
 // Linux image, and macOS, where the backend is also built for
 // development, has neither O_PATH nor AT_EMPTY_PATH. This file lets
 // the package build elsewhere, such as on macOS, where a developer
 // runs make build and make run.
 func chownFile(_ *os.Root, name string, _, _ int) error {
 	return &fs.PathError{Op: "chown", Path: name, Err: errors.ErrUnsupported}
 }
@@ -254,13 +254,10 @@ func TestPrepareDataDirTakesDirectoryNamedInLatin1(t *testing.T) {
 	requireOwner(t, filepath.Join(latin1, "f"), uint32(uid), uint32(gid))
 }
-// TestPrepareDataDirGivesVolumeToOwner gives the directories, regular
+// TestPrepareDataDirGivesVolumeToOwner gives everything in the volume
-// files and symbolic links in the volume to a uid and gid that own
+// to a uid and gid that own nothing, which only root can do. A
-// nothing, which only root can do. A symbolic link in the volume to a
+// symbolic link in the volume to a directory outside it is given to
-// directory outside it is given to them itself; what it points to is
+// them itself; what it points to is left as it was.
 // left as it was. A hard link to a file outside the volume, one to a
 // symbolic link outside it and one to a named pipe outside it are left
 // as they were, and so is a named pipe in the volume.
 func TestPrepareDataDirGivesVolumeToOwner(t *testing.T) {
 	t.Parallel()
@@ -277,16 +274,6 @@ func TestPrepareDataDirGivesVolumeToOwner(t *testing.T) {
 		t.Fatal(err)
 	}
 	err = os.Symlink("f", filepath.Join(outside, "link"))
 	if err != nil {
 		t.Fatal(err)
 	}
 	err = syscall.Mkfifo(filepath.Join(outside, "fifo"), 0o600)
 	if err != nil {
 		t.Fatal(err)
 	}
 	err = os.Mkdir(old, 0o700)
 	if err != nil {
 		t.Fatal(err)
@@ -302,21 +289,6 @@ func TestPrepareDataDirGivesVolumeToOwner(t *testing.T) {
 		t.Fatal(err)
 	}
 	err = syscall.Mkfifo(filepath.Join(old, "fifo"), 0o600)
 	if err != nil {
 		t.Fatal(err)
 	}
 	// os.Link does not follow a symbolic link: it gives the link itself
 	// a second name.
 	for _, name := range []string{"f", "link", "fifo"} {
 		err = os.Link(filepath.Join(outside, name),
 			filepath.Join(old, "hardlink-to-"+name))
 		if err != nil {
 			t.Fatal(err)
 		}
 	}
 	err = reportbuf.PrepareDataDir(volume, filepath.Join(volume, reports),
 		&user.User{Uid: "4242", Gid: "4343"})
 	if err != nil {
@@ -324,16 +296,12 @@ func TestPrepareDataDirGivesVolumeToOwner(t *testing.T) {
 	}
 	for _, path := range []string{
-		volume, filepath.Join(volume, reports), old, filepath.Join(old, "f"),
+		volume, filepath.Join(volume, reports), old,
-		filepath.Join(old, "link"),
+		filepath.Join(old, "f"), filepath.Join(old, "link"),
 	} {
 		requireOwner(t, path, 4242, 4343)
 	}
-	for _, path := range []string{
+	requireOwner(t, outside, 0, 0)
-		outside, filepath.Join(outside, "f"), filepath.Join(outside, "link"),
+	requireOwner(t, filepath.Join(outside, "f"), 0, 0)
 		filepath.Join(outside, "fifo"), filepath.Join(old, "fifo"),
 	} {
 		requireOwner(t, path, 0, 0)
 	}
 }
@@ -1,9 +1,6 @@
 // Package reportbuf accumulates telemetry reports in memory
 // and periodically flushes them to zstd-compressed JSONL files,
-// deleting the oldest files to keep them under a size cap. Before the
+// deleting the oldest files to keep them under a size cap.
 // server starts, PrepareDataDir gets the directory those files are
 // kept in, DATA_DIR, ready for the user the server runs as: it creates
 // it and gives it and the volume it is on to that user.
 package reportbuf
 import (
@@ -88,21 +85,12 @@ type Buffer struct {
 	now func() time.Time
 	// seq numbers the report files, so that two named in the same
 	// millisecond still get different names.
-	seq      atomic.Int64
+	seq      atomic.Uint64
 	stopOnce sync.Once
 	// usedBytes is what Append checks against maxBytes: the size
 	// of the report files in dataDir, plus the reports waiting to
 	// be written to one at their uncompressed size.
 	usedBytes int64
 	// writeErr is the error of the last write of a report file to
 	// finish, nil if it succeeded or none has. While it is set, Append
 	// refuses reports, and the reports of that write wait in buf for
 	// the next flush.
 	writeErr error
 	// writers are the goroutines that write report files: flushLoop,
 	// and each one Append starts at flushSizeThreshold. OnStop waits
 	// for them before the final flush.
 	writers sync.WaitGroup
 }
 // New creates a Buffer and registers lifecycle hooks to
@@ -127,33 +115,16 @@ func New(
 	lc.Append(fx.Hook{
 		OnStart: func(_ context.Context) error {
 			// The errors name DATA_DIR, as config.New's do for the
 			// settings it checks.
 			err := os.MkdirAll(b.dataDir, dirPerms)
 			if err != nil {
-				return fmt.Errorf("DATA_DIR %q: %w", b.dataDir, err)
+				return fmt.Errorf("create data dir: %w", err)
 			}
 			// Creating and removing a file stops the start when no
 			// file can be created in DATA_DIR, instead of the first
 			// write of a report file failing after reports were
 			// answered 200. A full disk is not caught: the empty
 			// file is still created.
 			f, err := os.CreateTemp(b.dataDir, "")
 			if err != nil {
 				return fmt.Errorf("DATA_DIR %q: %w", b.dataDir, err)
 			}
 			err = errors.Join(f.Close(), os.Remove(f.Name()))
 			if err != nil {
 				return fmt.Errorf("DATA_DIR %q: %w", b.dataDir, err)
 			}
 			// Report files left by earlier runs count too, and are
 			// the first to be deleted to make room.
 			files, err := reportFiles(b.dataDir)
 			if err != nil {
-				return fmt.Errorf("DATA_DIR %q: %w", b.dataDir, err)
+				return err
 			}
 			b.mu.Lock()
@@ -171,7 +142,7 @@ func New(
 			b.mu.Unlock()
-			b.writers.Go(b.flushLoop)
+			go b.flushLoop()
 			return nil
 		},
@@ -182,14 +153,7 @@ func New(
 			var err error
 			b.stopOnce.Do(func() {
 				// Closing done ends flushLoop after any flush it is
 				// running. Wait for it and for the writes Append
 				// started, which the process exiting would cut off;
 				// one that fails puts its reports back in buf, for the
 				// final flush to write.
 				close(b.done)
 				b.writers.Wait()
 				err = b.flushLocked()
 			})
@@ -203,12 +167,11 @@ func New(
 }
 // Append marshals v as a single JSON line and appends it to
-// the buffer. It stores nothing and returns an error if the last
+// the buffer. If the line would take usedBytes past maxBytes, the
-// write of a report file failed, until a write succeeds again. If the
+// oldest report files are deleted to make room; it stores nothing
-// line would take usedBytes past maxBytes, the oldest report files are
+// and returns ErrFull if that cannot make room. If the buffer
-// deleted to make room; it stores nothing and returns ErrFull if that
+// reaches the size threshold, it is drained and written to disk
-// cannot make room. If the buffer reaches the size threshold, it is
+// asynchronously.
 // drained and written to disk asynchronously.
 func (b *Buffer) Append(v any) error {
 	line, err := json.Marshal(v)
 	if err != nil {
@@ -219,13 +182,6 @@ func (b *Buffer) Append(v any) error {
 	b.mu.Lock()
 	if b.writeErr != nil {
 		err = fmt.Errorf("report files cannot be written: %w", b.writeErr)
 		b.mu.Unlock()
 		return err
 	}
 	b.deleteOldestFiles(lineBytes)
 	if b.usedBytes+lineBytes > b.maxBytes {
@@ -242,12 +198,12 @@ func (b *Buffer) Append(v any) error {
 		data := b.drainBuf()
 		b.mu.Unlock()
-		b.writers.Go(func() {
+		go func() {
 			writeErr := b.writeFile(data)
 			if writeErr != nil {
 				b.log.Error("flush reports failed", "error", writeErr)
 			}
-		})
+		}()
 		return nil
 	}
@@ -335,8 +291,7 @@ func (b *Buffer) drainBuf() []byte {
 }
 // writeFile writes data, reports drained from the buffer, to a new
-// timestamped zstd-compressed JSONL file in the data directory. If the
+// timestamped zstd-compressed JSONL file in the data directory.
 // write fails, it puts the reports back in the buffer.
 func (b *Buffer) writeFile(data []byte) error {
 	// The timestamp comes first, so the names sort by time; the number
 	// after it tells apart files named in the same millisecond.
@@ -345,27 +300,19 @@ func (b *Buffer) writeFile(data []byte) error {
 	size, err := b.createFile(filepath.Join(b.dataDir, name), data)
 	// The reports no longer wait to be written, so they stop counting
 	// at their uncompressed size. If the write failed they are lost;
 	// otherwise they count as the file, which from here on may be
 	// deleted to make room.
 	b.mu.Lock()
 	defer b.mu.Unlock()
-	b.writeErr = err
+	b.usedBytes -= int64(len(data))
 	if err != nil {
 		// The reports go back in front of any appended since, for the
 		// next flush to write, and still count at their uncompressed
 		// size.
 		appended := bytes.Clone(b.buf.Bytes())
 		b.buf.Reset()
 		b.buf.Write(data)
 		b.buf.Write(appended)
 		return err
 	}
 	// The reports no longer wait to be written, so they stop counting
 	// at their uncompressed size and count as the file, which from here
 	// on may be deleted to make room.
 	b.usedBytes -= int64(len(data))
 	b.usedBytes += size
 	b.filesBytes += size
@@ -5,8 +5,6 @@ import (
 	"errors"
 	"fmt"
 	"io/fs"
 	"net/http"
 	"net/http/httptest"
 	"os"
 	"path/filepath"
 	"slices"
@@ -15,13 +13,10 @@ import (
 	"sync"
 	"sync/atomic"
 	"testing"
 	"testing/synctest"
 	"time"
 	"sneak.berlin/go/netwatch/internal/config"
 	"sneak.berlin/go/netwatch/internal/globals"
 	"sneak.berlin/go/netwatch/internal/handlers"
 	"sneak.berlin/go/netwatch/internal/healthcheck"
 	"sneak.berlin/go/netwatch/internal/logger"
 	"sneak.berlin/go/netwatch/internal/reportbuf"
@@ -108,236 +103,9 @@ func TestFailedFinalFlushFailsStop(t *testing.T) {
 	}
 }
-// TestUncreatableDataDirStopsStart sets DATA_DIR below a regular file,
+// startBuffer starts a Buffer through fx, as main does, with the
-// where no directory can be created, even by root, as the tests run in
+// DATA_DIR and DATA_DIR_MAX_BYTES the calling test has set.
-// the backend image. The start must fail with an error naming DATA_DIR
+func startBuffer(t *testing.T) *reportbuf.Buffer {
 // and its value, as the errors for the other settings do.
 func TestUncreatableDataDirStopsStart(t *testing.T) {
 	file := filepath.Join(t.TempDir(), "file")
 	writeBytes(t, file, 1)
 	dir := filepath.Join(file, "reports")
 	t.Setenv("DATA_DIR", dir)
 	app := fxtest.New(t,
 		fx.Provide(
 			globals.New,
 			logger.New,
 			config.New,
 			reportbuf.New,
 		),
 		fx.Invoke(func(*reportbuf.Buffer) {}),
 	)
 	err := app.Start(t.Context())
 	if err == nil {
 		t.Fatal("start succeeded with DATA_DIR below a regular file")
 	}
 	want := fmt.Sprintf("DATA_DIR %q: ", dir)
 	if !strings.Contains(err.Error(), want) {
 		t.Fatalf("start error = %q, want it to contain %q", err, want)
 	}
 }
 // TestUnwritableDataDirStopsStart sets DATA_DIR to /proc, which exists
 // and can be read, but where no file can be created, even by root, as
 // the tests run in the backend image: root ignores a directory the test
 // makes read-only. The start must fail with an error naming DATA_DIR and
 // its value, rather than the first write of a report file.
 func TestUnwritableDataDirStopsStart(t *testing.T) {
 	dir := "/proc"
 	t.Setenv("DATA_DIR", dir)
 	app := fxtest.New(t,
 		fx.Provide(
 			globals.New,
 			logger.New,
 			config.New,
 			reportbuf.New,
 		),
 		fx.Invoke(func(*reportbuf.Buffer) {}),
 	)
 	err := app.Start(t.Context())
 	if err == nil {
 		t.Fatal("start succeeded with DATA_DIR /proc")
 	}
 	want := fmt.Sprintf("DATA_DIR %q: ", dir)
 	if !strings.Contains(err.Error(), want) {
 		t.Fatalf("start error = %q, want it to contain %q", err, want)
 	}
 }
 // TestStopWaitsForPeriodicWrite holds open the write the periodic flush
 // starts, then stops the app. The stop must wait until the write is
 // released, and the report must then be in its file. The test runs in
 // a synctest bubble, whose clock moves on at once when every goroutine
 // in it is waiting, so the periodic flush does not take a minute.
 func TestStopWaitsForPeriodicWrite(t *testing.T) {
 	dir := t.TempDir()
 	t.Setenv("DATA_DIR", dir)
 	synctest.Test(t, func(t *testing.T) {
 		buf, app := startApp(t)
 		created := make(chan struct{})
 		release := make(chan struct{})
 		buf.OnFileCreated(func(*os.File) {
 			created <- struct{}{}
 			<-release
 		})
 		err := buf.Append(map[string]string{"id": "periodic"})
 		if err != nil {
 			t.Fatalf("append report: %v", err)
 		}
 		<-created
 		err = stopWhileHeld(t, app, release)
 		if err != nil {
 			t.Fatalf("stop: %v", err)
 		}
 		files, err := readReportFiles(dir)
 		if err != nil {
 			t.Fatalf("read report files: %v", err)
 		}
 		want := `{"id":"periodic"}` + "\n"
 		if len(files) != 1 || files[0] != want {
 			t.Fatalf("report files = %q, want one holding %q", files, want)
 		}
 	})
 }
 // TestStopWaitsForWriteAtSizeThreshold holds open the write Append
 // starts when the buffer reaches FlushSizeThreshold, then stops the
 // app. The stop must wait until the write is released, and the reports
 // must then be in its file.
 func TestStopWaitsForWriteAtSizeThreshold(t *testing.T) {
 	dir := t.TempDir()
 	t.Setenv("DATA_DIR", dir)
 	synctest.Test(t, func(t *testing.T) {
 		buf, app := startApp(t)
 		created := make(chan struct{})
 		release := make(chan struct{})
 		buf.OnFileCreated(func(*os.File) {
 			created <- struct{}{}
 			<-release
 		})
 		appended := appendToThreshold(t, buf)
 		<-created
 		err := stopWhileHeld(t, app, release)
 		if err != nil {
 			t.Fatalf("stop: %v", err)
 		}
 		files, err := readReportFiles(dir)
 		if err != nil {
 			t.Fatalf("read report files: %v", err)
 		}
 		if len(files) != 1 || files[0] != appended {
 			t.Fatalf("%d report files, want one holding the %d bytes "+
 				"appended", len(files), len(appended))
 		}
 	})
 }
 // TestFinalFlushWritesReportsOfFailedWrite holds open the write the
 // periodic flush starts, makes it fail, then stops the app. The stop
 // waits for the write, which puts its report back in the buffer, and
 // the final flush writes it, so the stop succeeds with nothing lost.
 func TestFinalFlushWritesReportsOfFailedWrite(t *testing.T) {
 	dir := t.TempDir()
 	t.Setenv("DATA_DIR", dir)
 	synctest.Test(t, func(t *testing.T) {
 		buf, app := startApp(t)
 		created := make(chan *os.File)
 		release := make(chan struct{})
 		buf.OnFileCreated(func(f *os.File) {
 			created <- f
 			<-release
 		})
 		err := buf.Append(map[string]string{"id": "failed"})
 		if err != nil {
 			t.Fatalf("append report: %v", err)
 		}
 		held := <-created
 		// Closing the file under the write makes the write fail.
 		_ = held.Close()
 		// The final flush's write goes through.
 		buf.OnFileCreated(func(*os.File) {})
 		err = stopWhileHeld(t, app, release)
 		if err != nil {
 			t.Fatalf("stop: %v", err)
 		}
 		files, err := readReportFiles(dir)
 		if err != nil {
 			t.Fatalf("read report files: %v", err)
 		}
 		want := `{"id":"failed"}` + "\n"
 		if len(files) != 1 || files[0] != want {
 			t.Fatalf("report files = %q, want one holding %q", files, want)
 		}
 	})
 }
 // stopWhileHeld stops app while a report file write is held open until
 // release is closed, and fails the test if the stop returns before
 // that. It then closes release and returns the stop's error. It must
 // be called in a synctest bubble.
 func stopWhileHeld(
 	t *testing.T,
 	app *fxtest.App,
 	release chan<- struct{},
 ) error {
 	t.Helper()
 	stopped := make(chan error, 1)
 	go func() { stopped <- app.Stop(t.Context()) }()
 	// Wait returns once every other goroutine in the bubble is waiting:
 	// the stop has got as far as it can while the write is held.
 	synctest.Wait()
 	if len(stopped) != 0 {
 		t.Error("stop returned while a report file write was held open")
 	}
 	close(release)
 	return <-stopped
 }
 // startApp starts a Buffer through fx, as main does, with the DATA_DIR
 // and DATA_DIR_MAX_BYTES the calling test has set, and returns it with
 // the app, for tests that stop the app themselves.
 func startApp(t *testing.T) (*reportbuf.Buffer, *fxtest.App) {
 	t.Helper()
 	var buf *reportbuf.Buffer
@@ -355,16 +123,6 @@ func startApp(t *testing.T) (*reportbuf.Buffer, *fxtest.App) {
 	app.RequireStart()
 	t.Cleanup(app.RequireStop)
 	return buf, app
 }
 // startBuffer starts a Buffer through fx, as main does, with the
 // DATA_DIR and DATA_DIR_MAX_BYTES the calling test has set.
 func startBuffer(t *testing.T) *reportbuf.Buffer {
 	t.Helper()
 	buf, _ := startApp(t)
 	return buf
 }
@@ -749,17 +507,13 @@ func TestFileBeingWrittenIsNeverDeleted(t *testing.T) {
 	}
 }
-// TestFailedWriteKeepsItsReports makes a write fail once its file is
+// TestFailedWriteStopsCounting makes a write fail once its file is
-// created, under a cap with room for one report. The part of the file
+// created. Its reports are lost, so they stop counting, and the part of
-// written is removed, so it takes no room, and the report waits in
+// the file written is removed, so it takes no room.
-// memory for the next flush, which writes it. Once written, it counts
+func TestFailedWriteStopsCounting(t *testing.T) {
-// as its file and no longer as a report waiting, so the cap still holds
+	report := map[string]string{"id": "failed"}
 // exactly: one more report is taken and the one after it is refused.
 func TestFailedWriteKeepsItsReports(t *testing.T) {
 	report := map[string]string{"id": "kept"}
 	dir := t.TempDir()
-	t.Setenv("DATA_DIR", dir)
+	t.Setenv("DATA_DIR", t.TempDir())
 	t.Setenv("DATA_DIR_MAX_BYTES", strconv.Itoa(lineBytes(t, report)))
 	buf := startBuffer(t)
@@ -790,213 +544,10 @@ func TestFailedWriteKeepsItsReports(t *testing.T) {
 	// Writes from here on, the final one at stop included, succeed.
 	buf.OnFileCreated(func(*os.File) {})
 	err = buf.Flush()
 	if err != nil {
 		t.Fatalf("flush after the failed write: %v", err)
 	}
 	files, err := readReportFiles(dir)
 	if err != nil {
 		t.Fatalf("read report files: %v", err)
 	}
 	want := `{"id":"kept"}` + "\n"
 	if len(files) != 1 || files[0] != want {
 		t.Fatalf("report files = %q, want one holding %q", files, want)
 	}
 	// The file is deleted to make room if need be.
 	err = buf.Append(report)
 	if err != nil {
-		t.Fatalf("report after the written one: %v", err)
+		t.Fatalf("report after the failed write: %v", err)
 	}
 	err = buf.Append(report)
 	if !errors.Is(err, reportbuf.ErrFull) {
 		t.Fatalf("report past the cap: error = %v, want ErrFull", err)
 	}
 }
 // TestFailedWriteKeepsReportsAppendedDuringIt holds a write open,
 // appends a report while it is held, then makes the held write fail.
 // Both reports are kept, and the next flush writes them in the order
 // they were appended, the held write's first.
 func TestFailedWriteKeepsReportsAppendedDuringIt(t *testing.T) {
 	dir := t.TempDir()
 	t.Setenv("DATA_DIR", dir)
 	buf := startBuffer(t)
 	created := make(chan *os.File)
 	release := make(chan struct{})
 	buf.OnFileCreated(func(f *os.File) {
 		created <- f
 		<-release
 	})
 	err := buf.Append(map[string]string{"id": "held"})
 	if err != nil {
 		t.Fatalf("report of the held write: %v", err)
 	}
 	flushed := make(chan error)
 	go func() { flushed <- buf.Flush() }()
 	held := <-created
 	// Errorf, not Fatalf, until the held write is released, so that a
 	// failure here does not leave it held.
 	err = buf.Append(map[string]string{"id": "appended"})
 	if err != nil {
 		t.Errorf("report appended while the write was held: %v", err)
 	}
 	// Closing the file under the write makes the write fail.
 	_ = held.Close()
 	close(release)
 	err = <-flushed
 	if err == nil {
 		t.Fatal("held write succeeded, though its file was closed under it")
 	}
 	// Writes from here on, the final one at stop included, succeed.
 	buf.OnFileCreated(func(*os.File) {})
 	err = buf.Flush()
 	if err != nil {
 		t.Fatalf("flush after the failed write: %v", err)
 	}
 	files, err := readReportFiles(dir)
 	if err != nil {
 		t.Fatalf("read report files: %v", err)
 	}
 	want := `{"id":"held"}` + "\n" + `{"id":"appended"}` + "\n"
 	if len(files) != 1 || files[0] != want {
 		t.Fatalf("report files = %q, want one holding %q", files, want)
 	}
 }
 // TestReportsRefusedWhileWritesFail posts reports through the report
 // handler, as the page does. Once a write has failed, a report is
 // refused with 500 until a write succeeds again; the reports taken
 // before and after are stored, and the one refused is not.
 func TestReportsRefusedWhileWritesFail(t *testing.T) {
 	dir := t.TempDir()
 	t.Setenv("DATA_DIR", dir)
 	buf, h := startBufferWithHandlers(t)
 	if code := postReport(t, h, "before"); code != http.StatusOK {
 		t.Fatalf("report before the failed write: status = %d, want %d",
 			code, http.StatusOK)
 	}
 	// With the data directory gone, the write has nowhere to go.
 	err := os.Remove(dir)
 	if err != nil {
 		t.Fatalf("remove data dir: %v", err)
 	}
 	err = buf.Flush()
 	if err == nil {
 		t.Fatal("flush succeeded with the data directory gone")
 	}
 	if code := postReport(t, h, "refused"); code != http.StatusInternalServerError {
 		t.Fatalf("report after the failed write: status = %d, want %d",
 			code, http.StatusInternalServerError)
 	}
 	err = os.Mkdir(dir, 0o750)
 	if err != nil {
 		t.Fatalf("make data dir: %v", err)
 	}
 	err = buf.Flush()
 	if err != nil {
 		t.Fatalf("flush with the data directory back: %v", err)
 	}
 	if code := postReport(t, h, "after"); code != http.StatusOK {
 		t.Fatalf("report after a write succeeded: status = %d, want %d",
 			code, http.StatusOK)
 	}
 	err = buf.Flush()
 	if err != nil {
 		t.Fatalf("flush of the report after: %v", err)
 	}
 	files, err := readReportFiles(dir)
 	if err != nil {
 		t.Fatalf("read report files: %v", err)
 	}
 	stored := strings.Join(files, "")
 	for _, clientID := range []string{"before", "after"} {
 		if !strings.Contains(stored, `"clientId":"`+clientID+`"`) {
 			t.Errorf("report %q not stored", clientID)
 		}
 	}
 	if strings.Contains(stored, `"clientId":"refused"`) {
 		t.Error("refused report stored")
 	}
 }
 // startBufferWithHandlers starts a Buffer and the Handlers that store
 // reports in it through fx, as main does, with the DATA_DIR the calling
 // test has set.
 func startBufferWithHandlers(
 	t *testing.T,
 ) (*reportbuf.Buffer, *handlers.Handlers) {
 	t.Helper()
 	var (
 		buf *reportbuf.Buffer
 		h   *handlers.Handlers
 	)
 	app := fxtest.New(t,
 		fx.Provide(
 			config.New,
 			globals.New,
 			handlers.New,
 			healthcheck.New,
 			logger.New,
 			reportbuf.New,
 		),
 		fx.Populate(&buf, &h),
 	)
 	app.RequireStart()
 	t.Cleanup(app.RequireStop)
 	return buf, h
 }
 // postReport posts a report from clientID to the report handler, as the
 // page does, and returns the status of the answer.
 func postReport(t *testing.T, h *handlers.Handlers, clientID string) int {
 	t.Helper()
 	rec := httptest.NewRecorder()
 	req := httptest.NewRequestWithContext(t.Context(),
 		http.MethodPost, "/api/v1/reports",
 		strings.NewReader(`{"clientId":"`+clientID+`","hosts":[]}`),
 	)
 	req.Header.Set("Content-Type", "application/json")
 	h.HandleReport().ServeHTTP(rec, req)
 	return rec.Code
 }
 // TestConcurrentAppendsStopAtCap appends from many goroutines at once
@@ -1130,32 +681,6 @@ func TestFlushAtSizeThreshold(t *testing.T) {
 	buf := startBuffer(t)
 	appended := appendToThreshold(t, buf)
 	// Append writes the file in the background, so wait for it.
 	deadline := time.Now().Add(10 * time.Second)
 	for {
 		files, err := readReportFiles(dir)
 		if err == nil && len(files) == 1 && files[0] == appended {
 			return
 		}
 		if time.Now().After(deadline) {
 			t.Fatalf("%d report files (error: %v), want one holding the "+
 				"%d bytes appended", len(files), err, len(appended))
 		}
 		time.Sleep(10 * time.Millisecond)
 	}
 }
 // appendToThreshold appends reports to buf until it holds
 // FlushSizeThreshold bytes, so that the last append starts writing them
 // to a report file, and returns the lines appended.
 func appendToThreshold(t *testing.T, buf *reportbuf.Buffer) string {
 	t.Helper()
 	// Large reports, so the threshold takes a few hundred appends.
 	pad := strings.Repeat("a", 64<<10)
@@ -1178,7 +703,22 @@ func appendToThreshold(t *testing.T, buf *reportbuf.Buffer) string {
 		appended.WriteByte('\n')
 	}
-	return appended.String()
+	// Append writes the file in the background, so wait for it.
 	deadline := time.Now().Add(10 * time.Second)
 	for {
 		files, err := readReportFiles(dir)
 		if err == nil && len(files) == 1 && files[0] == appended.String() {
 			return
 		}
 		if time.Now().After(deadline) {
 			t.Fatalf("%d report files (error: %v), want one holding the "+
 				"%d bytes appended", len(files), err, appended.Len())
 		}
 		time.Sleep(10 * time.Millisecond)
 	}
 }
 // reportFilesBytes returns the total size of the report files in dir.
@@ -34,16 +34,13 @@ func (s *Server) SetupRoutes() {
 	s.router.Use(s.mw.Recoverer())
 	s.router.Use(middleware.RequestID)
 	s.router.Use(s.mw.Logging())
 	// s.mw.Recoverer would write a panic's 500 only after the panic has
 	// passed the request log, so it is written here, where the log sees it.
 	s.router.Use(s.mw.Write500OnPanic())
 	s.router.Use(s.mw.SecurityHeaders())
 	s.router.Use(s.mw.CORS(s.params.Config.CORSAllowedOrigins))
 	s.router.Use(s.mw.MaxBodyBytes(maxRequestBodyBytes))
 	s.router.Use(middleware.Timeout(requestTimeout))
-	// Sentry reports a panic, then panics again, so that it still
+	// Sentry reports a panic, then panics again, so that s.mw.Recoverer
-	// reaches s.mw.Recoverer.
+	// still answers 500.
 	if s.params.Config.SentryDSN != "" {
 		s.router.Use(sentryhttp.New(sentryhttp.Options{Repanic: true}).Handle)
 	}
@@ -67,8 +64,6 @@ func (s *Server) SetupRoutes() {
 		// other.
 		if s.params.Config.MetricsUsername != "" {
 			r.Use(s.mw.Metrics(registry))
 			// Likewise inside the metrics.
 			r.Use(s.mw.Write500OnPanic())
 		}
 		r.Get("/.well-known/healthcheck", s.h.HandleHealthCheck())
@@ -2,10 +2,9 @@
 # script/frontend-test: run the frontend test suite on the host: the
 # unit tests in test/unit/, through the test script in package.json,
 # then the production build, which fails on broken code. make test runs
-# the same tests in the frontend-test stage of Dockerfile, and the image
+# the same in the frontend stage of Dockerfile. The tests print a dot
-# build runs the production build in its frontend-build stage. The tests
+# each; if any fails, they run again with every test listed, and the
-# print a dot each; if any fails, they run again with every test listed,
+# script fails even if that run passes. NODE_OPTIONS chooses the
 # and the script fails even if that run passes. NODE_OPTIONS chooses the
 # reporter because yarn adds its arguments after the test files, where
 # node would take a reporter option for one more file.
 set -eu
@@ -7,8 +7,6 @@
 # headless Chrome at it over CDP, and asserts on computed layout at every
 # viewport width derived from the app's own CSS. See
 # test/viewport/README.md for what this covers and what it cannot.
 # Before the browser starts, it checks that the page is served with
 # Cache-Control: no-cache and Content-Security-Policy.
 #
 # Deliberately not part of script/check: it needs Docker and takes far
 # longer than the 20s budget make test has to stay inside.
@@ -66,8 +64,8 @@ main() {
    # configs/nginx.conf is a template: the image renders it over its own
    # default.conf, with the same port and limit bin/entrypoint.sh uses.
    # The empty file it includes trusts no proxy, as bin/entrypoint.sh
-    # writes it when TRUSTED_PROXIES is set and empty. It also includes
+    # writes it when TRUSTED_PROXIES is unset. It also includes the
-    # the security headers, so the page runs under the shipped policy.
+    # security headers, so the page runs under the shipped policy.
    docker run -d --rm --name "$SERVER" \
        --network "$NETWORK" --network-alias netwatch \
        -e PORT=8080 -e NGINX_ENVSUBST_FILTER='^PORT$' \
@@ -77,32 +75,6 @@ main() {
        -v "$ROOT/configs/security-headers.conf:/etc/nginx/security-headers.conf:ro" \
        "$SERVER_IMAGE" > /dev/null
    # The page, and /no-such-page, which location / answers with the
    # page through its try_files fallback, must go out with
    # Cache-Control: no-cache. That add_header in its location drops the
    # server's own unless the location includes the security headers
    # again; only Content-Security-Policy is checked, as it comes from
    # the same file as the rest. curl tries up to ten more times, a
    # second apart, while nginx starts. It runs without -S, which would
    # print an error for every failed attempt, even when a later one
    # succeeds.
    for path in / /no-such-page; do
        if ! headers="$(docker exec "$SERVER" curl -s -o /dev/null -D - \
            --retry 10 --retry-connrefused --retry-delay 1 \
            "http://127.0.0.1:8080$path")"; then
            echo "frontend-viewport-test: nginx did not answer $path" >&2
            exit 1
        fi
        headers="$(printf '%s\n' "$headers" | tr -d '\r')"
        if ! printf '%s\n' "$headers" | grep -qix 'Cache-Control: no-cache' ||
            ! printf '%s\n' "$headers" | grep -qi '^Content-Security-Policy:'; then
            echo "frontend-viewport-test: $path needs" \
                "Cache-Control: no-cache and Content-Security-Policy; got:" >&2
            printf '%s\n' "$headers" >&2
            exit 1
        fi
    done
    # The image's own entrypoint already exposes CDP on 9222 and passes
    # --no-sandbox, so only extra flags belong here; re-specifying the
    # debugging port collides with it and leaves the endpoint bound to
@@ -6,7 +6,6 @@ import { beforeEach, test } from "node:test";
 import assert from "node:assert/strict";
 import {
    AppState,
    buildUI,
    CONFIG,
    greyOutUI,
    hostRowHTML,
@@ -14,26 +13,20 @@ import {
    humanDuration,
    latencyClass,
    latencyHex,
    log,
    measureLatency,
    Reporter,
    tick,
    updateClocks,
    updateSummary,
 } from "../../web/src/main.js";
 // There is no page here, so the tests stand in for it. The debug log looks
-// for its panel by id and finds none, an element the page creates is a
+// for its panel by id and finds none. Each element of a host's row that
-// plain object, and no frame the page asks for ever comes. Each element of
+// tick or greyOutUI draws into is a plain object, made the first time a
-// a host's row that tick or greyOutUI draws into is a plain object, made
+// test looks it up and kept in elements under its selector until the next
-// the first time a test looks it up and kept in elements under its
+// test starts. As on a page, writing its text replaces its markup; the
-// selector until the next test starts. As on a page, writing its text
+// status dot greyOutUI looks for in it is not there. Drawing a sparkline
-// replaces its markup; the status dot greyOutUI looks for in it is not
+// does nothing; it looks for the pixel ratio on window and finds none. In
-// there. Drawing a sparkline does nothing; it looks for the pixel ratio on
+// each test, console.error and console.info print nothing and keep what
-// window and finds none. The commit the page's footer names, which
+// they are given.
 // vite.config.js fills in when it builds the page, is blank. In each test,
 // console.error and console.info print nothing and keep what they are
 // given.
 const doNothing = () => {};
 let elements;
 beforeEach((t) => {
@@ -53,13 +46,8 @@ const canvasContext = {
    arc: doNothing,
 };
 globalThis.window = {};
 globalThis.requestAnimationFrame = doNothing;
 globalThis.cancelAnimationFrame = doNothing;
 globalThis.__COMMIT_HASH__ = "";
 globalThis.__COMMIT_FULL__ = "";
 globalThis.document = {
    getElementById: () => null,
    createElement: () => ({}),
    querySelector: (selector) =>
        (elements[selector] ??= {
            getContext: () => canvasContext,
@@ -483,39 +471,6 @@ test("of the checks interval changes cleared before they were reported, the next
    assert.equal(sent.at(-1).t, 120000);
 });
 // panel stands in for the open debug log panel, and for the element in it
 // that holds its lines, whichever the page looks up by id; the lines are
 // kept in order in lines. Drawing the whole panel, as opening it does,
 // replaces every line with a new one.
 test("with the debug log open, writing more lines than it keeps adds each to the panel and leaves the lines already shown as they are", (t) => {
    const lines = [];
    const panel = {
        classList: { contains: () => false },
        children: lines,
        get firstElementChild() {
            return lines[0];
        },
        append: (line) => lines.push(line),
        removeChild: (line) => lines.splice(lines.indexOf(line), 1),
        replaceChildren: (...newLines) =>
            lines.splice(0, lines.length, ...newLines),
    };
    t.mock.method(globalThis.document, "getElementById", () => panel);
    const kept = CONFIG.maxLogEntries;
    for (let i = 1; i <= kept; i++) log.info(`line ${i}`);
    const shown = [...lines];
    for (let i = kept + 1; i <= kept + 5; i++) log.info(`line ${i}`);
    assert.deepEqual(
        lines.map((line) => line.textContent.match(/line \d+$/)?.[0]),
        Array.from({ length: kept }, (_, i) => `line ${i + 6}`),
    );
    // The first five lines shown were dropped, and the rest are the same
    // lines, not drawn again.
    shown.slice(5).forEach((line, i) => assert.equal(lines[i], line));
 });
 // The page shows &lt; &gt; &quot; &amp; and &#39; in a row's markup as
 // < > " & and '.
 test(`a target whose name and URL hold < > " & and ' shows those characters in its row`, () => {
@@ -585,32 +540,6 @@ test("a check that timed out or found its target unreachable has a grey figure a
    assert.equal(latencyHex(null), "#6b7280");
 });
 // buildUI draws the page into #app, here a plain object. Each entry in the
 // footer's color legend is a colored dot and the latencies it stands for,
 // with < and > written as &lt; and &gt;. A latency takes the color of the
 // first entry in CONFIG.latencyColors whose limit it is below, so the
 // legend has, for each of those entries in order, a dot of its color (a
 // bg- class where CONFIG.latencyColors has a text- one) and the latencies
 // below its limit, or, for the last, which has no limit, the latencies
 // from the limit before it up. A gray dot for offline comes after them.
 test("the footer's color legend has each entry in CONFIG.latencyColors, with its color and limit, then offline", (t) => {
    const app = {};
    t.mock.method(globalThis.document, "getElementById", () => app);
    buildUI(new AppState([]));
    const legend = [
        ...app.innerHTML.matchAll(/(bg-\w+-500) [^"]*"><\/span>(\S+)/g),
    ].map(([, dot, latencies]) => [dot, latencies]);
    const colors = CONFIG.latencyColors;
    const expected = colors.map((color, i) => [
        color.className.replace("text-", "bg-"),
        color.below === Infinity
            ? `&gt;=${colors[i - 1].below}ms`
            : `&lt;${color.below}ms`,
    ]);
    assert.deepEqual(legend, [...expected, ["bg-gray-500", "offline"]]);
 });
 // A target whose checks, in turn, answered after each of latencies ms, or,
 // for null, found it unreachable.
 function hostAfter(latencies) {
@@ -687,102 +616,6 @@ test("the summary's min, max, median and average latency over the WAN targets' l
    });
 });
 // In the next two tests each element of the summary that updateSummary
 // writes into is a plain object, made the first time it is looked up and
 // kept in elements under "#" and its id.
 // The interval menu resets each target and counts the rounds from 0 again,
 // then updates the summary, before any check since the change is recorded.
 test("after an interval change, the summary's Reachable slot reads --/-- in white, as at page load", (t) => {
    t.mock.method(
        globalThis.document,
        "getElementById",
        (id) => (elements[`#${id}`] ??= {}),
    );
    const state = new AppState([]);
    for (const host of state.wan) {
        host.pushSample(Date.now(), { latency: 30, error: null });
    }
    state.tickCount = 5;
    for (const host of state.allHosts) host.reset();
    state.tickCount = 0;
    updateSummary(state);
    assert.equal(elements["#summary-reachable"].textContent, "--/--");
    assert.equal(elements["#summary-reachable"].className, "text-white");
 });
 test("once every WAN target's check has failed, the summary's Reachable slot reads 0 of them, in red", (t) => {
    t.mock.method(
        globalThis.document,
        "getElementById",
        (id) => (elements[`#${id}`] ??= {}),
    );
    const state = new AppState([]);
    for (const host of state.wan) {
        host.pushSample(Date.now(), { latency: null, error: "timeout" });
    }
    updateSummary(state);
    assert.equal(
        elements["#summary-reachable"].textContent,
        `0/${state.wan.length}`,
    );
    assert.equal(elements["#summary-reachable"].className, "text-red-400");
 });
 // In the next two tests each of the header's clocks is a plain object, made
 // the first time updateClocks looks it up and kept in elements under "#" and
 // its id.
 // The mocked clock reads 1970-01-01T00:00:00.000Z.
 test("the header's clocks show the local time with its time zone's name, and the UTC time", (t) => {
    t.mock.method(
        globalThis.document,
        "getElementById",
        (id) => (elements[`#${id}`] ??= {}),
    );
    t.mock.timers.enable({ apis: ["Date"] });
    updateClocks();
    assert.match(
        elements["#clock-local"].textContent,
        /^Local: \d{4}-\d\d-\d\d \d\d:\d\d:\d\d \S/,
    );
    assert.equal(
        elements["#clock-utc"].textContent,
        "UTC: 1970-01-01 00:00:00 UTC",
    );
 });
 // Here Intl.DateTimeFormat is as in Chrome before 95, Firefox before 91 or
 // Safari before 15.4: it throws a RangeError when asked for the time zone's
 // "shortGeneric" name.
 test("in a browser that cannot name the time zone, updating the clocks throws nothing and leaves them blank", (t) => {
    t.mock.method(
        globalThis.document,
        "getElementById",
        (id) => (elements[`#${id}`] ??= {}),
    );
    const DateTimeFormat = Intl.DateTimeFormat;
    t.mock.method(Intl, "DateTimeFormat", function (locales, options) {
        if (options?.timeZoneName === "shortGeneric") {
            throw new RangeError(
                "Value shortGeneric out of range for Intl.DateTimeFormat options property timeZoneName",
            );
        }
        return new DateTimeFormat(locales, options);
    });
    updateClocks();
    assert.equal(elements["#clock-local"].textContent, "");
    assert.equal(elements["#clock-utc"].textContent, "");
 });
 // An app state in which, of the WAN targets, the first timedOut timed out,
 // the next unreachable were found unreachable, the next answered answered
 // after latency ms, and the rest have not been checked yet.
@@ -144,15 +144,13 @@ const WAN_HOSTS = [
 const debugLog = [];
-export const log = (() => {
+const log = (() => {
    function append(level, message) {
-        const entry = { timestamp: new Date(), level, message };
+        debugLog.push({ timestamp: new Date(), level, message });
        debugLog.push(entry);
        if (debugLog.length > CONFIG.maxLogEntries)
            debugLog.splice(0, debugLog.length - CONFIG.maxLogEntries);
        const panel = document.getElementById("debug-panel");
-        if (panel && !panel.classList.contains("hidden"))
+        if (panel && !panel.classList.contains("hidden")) renderDebugLog();
            appendDebugLogLine(entry);
    }
    return {
        error: (msg) => append("error", msg),
@@ -829,7 +827,7 @@ function wanRowsHTML(wanHosts) {
    return rows.join("");
 }
-export function buildUI(state) {
+function buildUI(state) {
    const app = document.getElementById("app");
    app.innerHTML = `
    <div class="mx-auto px-[5%] py-8">
@@ -911,7 +909,7 @@ export function buildUI(state) {
          <span class="inline-block w-3 h-3 rounded-full bg-lime-500 mr-1 ml-3 align-middle"></span>&lt;100ms
          <span class="inline-block w-3 h-3 rounded-full bg-yellow-500 mr-1 ml-3 align-middle"></span>&lt;200ms
          <span class="inline-block w-3 h-3 rounded-full bg-orange-500 mr-1 ml-3 align-middle"></span>&lt;500ms
-          <span class="inline-block w-3 h-3 rounded-full bg-red-500 mr-1 ml-3 align-middle"></span>&gt;=500ms
+          <span class="inline-block w-3 h-3 rounded-full bg-red-500 mr-1 ml-3 align-middle"></span>&gt;500ms
          <span class="inline-block w-3 h-3 rounded-full bg-gray-500 mr-1 ml-3 align-middle"></span>offline
        </p>
        <p class="mt-2"><a href="https://git.eeqj.de/sneak/netwatch/commit/${__COMMIT_FULL__}" target="_blank" rel="noopener" class="text-gray-600 hover:text-gray-400">${__COMMIT_HASH__}</a></p>
@@ -995,7 +993,7 @@ function updateHostRow(host, index) {
    SparklineRenderer.draw(canvas, host.history);
 }
-export function updateSummary(state) {
+function updateSummary(state) {
    const stats = state.wanStats();
    const hstats = state.wanHistoryStats();
@@ -1014,20 +1012,13 @@ export function updateSummary(state) {
    const hmaxUnitEl = document.getElementById("summary-hmax-unit");
    if (!reachableEl) return;
-    // Before any WAN host's check is recorded, as after an interval change,
+    reachableEl.textContent = `${stats.reachable}/${stats.total}`;
-    // no host has answered or failed, so the slot reads as at page load.
+    reachableEl.className =
-    if (state.wan.every((h) => h.status === "pending")) {
+        stats.reachable === stats.total
-        reachableEl.textContent = "--/--";
+            ? "text-green-400"
-        reachableEl.className = "text-white";
+            : stats.reachable === 0
-    } else {
+              ? "text-red-400"
-        reachableEl.textContent = `${stats.reachable}/${stats.total}`;
+              : "text-yellow-400";
        reachableEl.className =
            stats.reachable === stats.total
                ? "text-green-400"
                : stats.reachable === 0
                  ? "text-red-400"
                  : "text-yellow-400";
    }
    if (stats.min !== null) {
        minEl.textContent = `${stats.min}`;
@@ -1114,37 +1105,11 @@ function updateHealthBox(state) {
    else if (health === "healthy") log.notice(`Health: ${labels[health]}`);
 }
 // Writes the local time, with its time zone's name, and the UTC time into
 // the header's clocks. The clocks only decorate the page: in a browser
 // whose Intl.DateTimeFormat rejects the "shortGeneric" time zone name
 // (Chrome before 95, Firefox before 91, Safari before 15.4) they are left
 // blank.
 export function updateClocks() {
    let local = "";
    let utc = "";
    try {
        const now = new Date();
        const zone = new Intl.DateTimeFormat("en-US", {
            timeZoneName: "shortGeneric",
        })
            .formatToParts(now)
            .find((p) => p.type === "timeZoneName").value;
        const pad = (n) => String(n).padStart(2, "0");
        local = `Local: ${now.toLocaleString("sv-SE", { hour12: false })} ${zone}`;
        utc =
            `UTC: ${now.getUTCFullYear()}-${pad(now.getUTCMonth() + 1)}-${pad(now.getUTCDate())} ` +
            `${pad(now.getUTCHours())}:${pad(now.getUTCMinutes())}:${pad(now.getUTCSeconds())} UTC`;
    } catch {
        // Both clocks are left blank.
    }
    document.getElementById("clock-local").textContent = local;
    document.getElementById("clock-utc").textContent = utc;
 }
 // --- Debug Log Renderer ------------------------------------------------------
-// One line of the debug log panel, its message set as text.
+function renderDebugLog() {
-function debugLogLine(entry) {
+    const el = document.getElementById("debug-log");
    if (!el) return;
    const levelColors = {
        error: "text-red-400",
        warning: "text-orange-400",
@@ -1152,43 +1117,19 @@ function debugLogLine(entry) {
        info: "text-gray-300",
        debug: "text-gray-500",
    };
-    const ts = formatUTCTimestamp(entry.timestamp);
+    el.replaceChildren(
-    const lvl = entry.level.toUpperCase().padEnd(7);
+        ...debugLog.map((entry) => {
-    const line = document.createElement("div");
+            const ts = formatUTCTimestamp(entry.timestamp);
-    line.className = levelColors[entry.level] || "text-gray-400";
+            const lvl = entry.level.toUpperCase().padEnd(7);
-    line.textContent = `${ts} ${lvl} ${entry.message}`;
+            const line = document.createElement("div");
-    return line;
+            line.className = levelColors[entry.level] || "text-gray-400";
-}
+            line.textContent = `${ts} ${lvl} ${entry.message}`;
-
+            return line;
-// Draws every line of the debug log into the panel, when it is opened.
+        }),
-function renderDebugLog() {
+    );
    const el = document.getElementById("debug-log");
    if (!el) return;
    el.replaceChildren(...debugLog.map((entry) => debugLogLine(entry)));
    el.scrollTop = el.scrollHeight;
 }
 // The request that scrolls the open panel to its newest line in the next
 // frame. One waits at most, also in a hidden tab, where frames do not run.
 let debugLogScrollFrame = 0;
 // Adds entry to the open panel as its last line, and drops the first line
 // once the panel holds more than maxLogEntries. A check that ends while the
 // page is busy is timed only when the page is done, so the lines already
 // shown are left as they are, and the panel is scrolled once a frame
 // rather than once a line: scrolling it lays out all of its lines again.
 function appendDebugLogLine(entry) {
    const el = document.getElementById("debug-log");
    if (!el) return;
    el.append(debugLogLine(entry));
    if (el.children.length > CONFIG.maxLogEntries)
        el.removeChild(el.firstElementChild);
    cancelAnimationFrame(debugLogScrollFrame);
    debugLogScrollFrame = requestAnimationFrame(() => {
        el.scrollTop = el.scrollHeight;
    });
 }
 // --- Sorting -----------------------------------------------------------------
 // Sort WAN hosts: pinned hosts first (alphabetically), then unpinned hosts
@@ -1536,6 +1477,24 @@ async function init() {
        sortAndRebuildWAN(state);
    });
    function updateClocks() {
        const now = new Date();
        const pad = (n) => String(n).padStart(2, "0");
        const utc =
            `${now.getUTCFullYear()}-${pad(now.getUTCMonth() + 1)}-${pad(now.getUTCDate())} ` +
            `${pad(now.getUTCHours())}:${pad(now.getUTCMinutes())}:${pad(now.getUTCSeconds())} UTC`;
        const local =
            now.toLocaleString("sv-SE", { hour12: false }) +
            " " +
            new Intl.DateTimeFormat("en-US", { timeZoneName: "shortGeneric" })
                .formatToParts(now)
                .find((p) => p.type === "timeZoneName").value;
        document.getElementById("clock-local").textContent = "Local: " + local;
        document.getElementById("clock-utc").textContent = "UTC: " + utc;
    }
    updateClocks();
    setInterval(updateClocks, 1000);
    // Rounds never overlap: a round first gives up the last round's checks
    // if they are still waiting, and the last round then records nothing
    // more. At a steady interval they never are, as they time out at 80% of
@@ -1615,11 +1574,6 @@ async function init() {
    window.addEventListener("resize", () => handleResize(state));
    setTimeout(() => handleResize(state), CONFIG.resizeDelay);
    // The clocks start last, after the rounds: they only decorate the page,
    // so nothing in them may stop the monitor from probing.
    updateClocks();
    setInterval(updateClocks, 1000);
 }
 // Bootstrap only when loaded as the page: a real DOM containing the #app