Interval change keeps unreported samples for the reporter (closes #124)

The interval menu cleared every host's history, and the reporter builds
each report from that history, so the samples recorded since the last
delivered report were never sent. The menu now resets each host with
HostState.reset, which moves the history's entries to clearedHistory,
keeping the last 100 it has cleared, and buildReport reads both. A host
still pending after the reset is sent with the status of its last check.
The per-host marks are unchanged, so a sample a delivered report had is
not sent again, and the page's history still starts over. Reporter is
exported for the new unit tests.

Model: opus-5-5

.dockerignore

@@ -1,9 +1,81 @@
-node_modules
-dist
-tmp
-.DS_Store
-*.log
+# .dockerignore does NOT use .gitignore semantics. Docker matches with
+# moby/patternmatcher: filepath.Match plus `**`, so `*` does not cross
+# `/` and an unprefixed pattern is anchored at the context root. Every
+# depth-independent pattern therefore needs `**/`, or `config/.env` and
+# `certs/server.key` still ship while this file reads as solved. Only
+# genuinely root-anchored entries go unprefixed. Never transplant these
+# into .gitignore, where `**/` is wrong.
+#
+# Matching is case-sensitive, so secrets use character ranges rather
+# than an ALL-CAPS twin, which would still miss `Server.Key`.
+#
+# Extend with this repo's own host-built artifacts, written anchored:
+# `/myapp`, never `**/myapp`, which also matches `cmd/myapp/` and
+# deletes the package directory from the context.
+
+# .git is sent without its config. Without a VERSION build argument the
+# stage that compiles runs `git describe --tags --always` on .git, which
+# does not need .git/config; that file can hold a credential, such as a
+# password in a remote URL or the token the CI checkout step stores there.
+# Each submodule keeps a config with the same exposure in its git directory
+# under .git/modules/, nested again for a submodule's own submodules, or in
+# its own .git directory when it keeps one.
+# KNOWN GAP: a submodule whose name has a `config` segment (`config`,
+# `deploy/config`, `config/lib`) loses its whole git directory, because
+# `**/.git/modules/**/config` also matches that segment's directory
+# under .git/modules/. Go's version stamping then fails the build;
+# nothing leaks. Name such a submodule without that segment:
+# `git submodule add --name`.
+**/.git/config
+**/.git/modules/**/config
+
+# Agent scratch: one full checkout of the repo per in-flight agent.
+# Anchored because it occurs once where agents run at the repo root.
+# KNOWN GAP: a repo running agents in subdirectories still ships
+# `services/api/.claude/` and must add its own anchored entry.
 .claude
 
-# .git is sent so the build can stamp the version, without its config.
-.git/config
+# Environment files. `*.env` covers bare `.env` and the `prod.env`
+# convention. Re-include a committed template with a negation if the
+# build needs one: `!docs/example.env`.
+**/*.[eE][nN][vV]
+**/.[eE][nN][vV].*
+**/.[eE][nN][vV][rR][cC]
+
+# Private keys and the bundles carrying them. Public certificates
+# (*.crt, *.cer) are deliberately absent: they are legitimate inputs.
+**/*.[pP][eE][mM]
+**/*.[kK][eE][yY]
+**/*.[pP]12
+**/*.[pP][fF][xX]
+**/[iI][dD]_[rR][sS][aA]
+**/[iI][dD]_[dD][sS][aA]
+**/[iI][dD]_[eE][cC][dD][sS][aA]
+**/[iI][dD]_[eE][cC][dD][sS][aA]_[sS][kK]
+**/[iI][dD]_[eE][dD]25519
+**/[iI][dD]_[eE][dD]25519_[sS][kK]
+
+# Dependencies: restored inside the image, never copied in.
+**/node_modules
+
+# OS metadata.
+**/.DS_Store
+**/Thumbs.db
+
+# Editor state: never a build input, and it churns COPY.
+**/*.swp
+**/*.swo
+**/*~
+**/*.bak
+**/.idea
+**/.vscode
+**/*.sublime-*
+
+# This repository's own entries, after the shared content above: the
+# frontend build, the viewport test's output, the binary `make build`
+# writes and the reports `make run` stores, and log files at the root.
+/dist
+/tmp
+/netwatch-server
+/data
+/*.log

.editorconfig

@@ -10,3 +10,8 @@ insert_final_newline = true
 
 [Makefile]
 indent_style = tab
+
+# This repository's own entries, after the shared content above.
+
+[*.go]
+indent_style = tab

.gitea/workflows/check.yml

@@ -6,7 +6,4 @@ jobs:
         steps:
             # actions/checkout v4.2.2, 2026-02-22
             - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
-            # script/cibuild bootstraps, runs every check and builds the
-            # image. script/bootstrap links what it installs into
-            # ~/.local/bin, so that has to be on PATH for the rest.
-            - run: PATH="$HOME/.local/bin:$PATH" script/cibuild
+            - run: script/cibuild

.gitignore

@@ -11,18 +11,54 @@ Thumbs.db
 .vscode/
 *.sublime-*
 
+# Agent scratch (worktrees of this repo, created and destroyed by
+# in-flight tooling). Unanchored: .gitignore patterns already match at
+# every depth, so no prefix is wanted here. This is not a .dockerignore
+# entry and must not be given a `**/` prefix on the way into one.
+.claude/
+
 # Node
 node_modules/
 
-# Environment / secrets
-.env
-.env.*
-*.pem
-*.key
+# Secrets. Unanchored like every entry above, so each matches at every
+# depth. Matching is case-sensitive on Linux, so names use character
+# ranges rather than a lowercase form that misses `Server.Key`.
+
+# Environment files. `*.env` covers bare `.env` and the `prod.env`
+# convention. Only the templates `example.env` and `sample.env` are
+# re-included below. A repository that commits any other template adds
+# its own negation after these lines, for example `!.env.example`.
+*.[eE][nN][vV]
+.[eE][nN][vV].*
+.[eE][nN][vV][rR][cC]
+!example.env
+!sample.env
+
+# Private keys and the bundles carrying them.
+*.[pP][eE][mM]
+*.[kK][eE][yY]
+*.[pP]12
+*.[pP][fF][xX]
+[iI][dD]_[rR][sS][aA]
+[iI][dD]_[dD][sS][aA]
+[iI][dD]_[eE][cC][dD][sS][aA]
+[iI][dD]_[eE][cC][dD][sS][aA]_[sS][kK]
+[iI][dD]_[eE][dD]25519
+[iI][dD]_[eE][dD]25519_[sS][kK]
+
+# This repository's own entries, after the shared content above.
 
 # Build output
 dist/
 tmp/
+/netwatch-server
+
+# The reports make run stores, in netwatch-server's default DATA_DIR
+/data/
+
+# Go test binaries and coverage output
+*.test
+*.out
 
 # Logs
 *.log

.golangci.yml

@@ -17,6 +17,7 @@ linters:
   disable:
     # Genuinely incompatible with project patterns
     - exhaustruct      # Requires all struct fields
+    - exhaustruct_v5   # Requires all struct fields (successor to exhaustruct)
     - godot            # Requires comments to end with periods
     - wrapcheck        # Too verbose for internal packages
     - varnamelen       # Short names like db, id are idiomatic Go

.prettierignore

@@ -1,7 +1,2 @@
-dist/
 node_modules/
-tmp/
 yarn.lock
-.claude/
-# The org standard file, copied verbatim; backend/script/lint checks its sha256.
-backend/.golangci.yml

Dockerfile

@@ -2,95 +2,121 @@
 # passes /api/, /.well-known/healthcheck and /metrics to netwatch-server,
 # the Go backend, which runs in the same container on loopback only.
 # bin/entrypoint.sh starts and watches both.
-
-# Lint stage — fast feedback on formatting and lint issues. The
-# golangci/golangci-lint image ships Go, gofmt, make and the linter, so
-# nothing is installed here. The root make lint builds this stage alone.
-# golangci/golangci-lint:v2.12.2 (2026-08-10)
-FROM golangci/golangci-lint@sha256:5cceeef04e53efe1470638d4b4b4f5ceefd574955ab3941b2d9a68a8c9ad5240 AS lint
-
-WORKDIR /src
-COPY backend/go.mod backend/go.sum ./
-RUN go mod download
-COPY backend/ .
-RUN make fmt-check
-RUN make lint
-
-# Backend build stage
-# golang:1.25-alpine (2026-02-27)
-FROM golang:1.25-alpine@sha256:f6751d823c26342f9506c03797d2527668d095b0a15f1862cddb4d927a7a4ced AS builder
-
-# gcc and musl-dev are for make test: its race detector needs cgo, which
-# Go turns on by itself once a C compiler is present. make build still
-# sets CGO_ENABLED=0, so the binary stays static.
-RUN apk add --no-cache gcc git make musl-dev
-
-WORKDIR /src
-
-# Force BuildKit to run the lint stage before proceeding. BuildKit runs
-# stages in parallel by default; without this no-op copy a lint failure
-# would not gate compilation.
-COPY --from=lint /src/go.sum /dev/null
-
-COPY backend/go.mod backend/go.sum ./
-RUN go mod download
-COPY backend/ .
-
-RUN make test
-
-# make build is a shim around backend/script/build, the one definition
-# of the build command:
-# CGO_ENABLED=0 go build -trimpath -ldflags "-s -w -X main.Version=..."
-# That script reads VERSION from the environment, so it is handed over
-# there rather than as a make variable.
 #
-# The version is the VERSION build argument when one is given, otherwise
-# `git describe --tags --always` of the repo's .git: the tag on a tagged
-# commit, tag-N-gHASH on a commit after one, the short commit when no
-# tag is reachable. A version that still comes out empty, dev or unknown
-# fails the build. .git goes to /git, not /src/.git, where go build would
-# find it and record VCS details of a work tree holding only backend/.
-COPY .git /git
-ARG VERSION
-RUN version="${VERSION:-$(git --git-dir=/git describe --tags --always)}"; \
-    case "$version" in ""|dev|unknown) \
-        echo "version is '$version' although .git is present" >&2; \
-        exit 1 ;; \
-    esac; \
-    VERSION="$version" make build
+# 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 builder stage depends on both, so the image
+# cannot be built unless they pass. Each covers the frontend as well,
+# through a copy from a node stage. Inside them each tool is invoked
+# directly, never through make or script/, whose lint and test are
+# themselves docker builds.
 
-# Frontend lint stage — eslint over the JavaScript, as the lint stage
-# above lints the Go. The root make lint builds this stage alone too.
+# Frontend lint stage: eslint with the rules in eslint.config.js. The
+# lint phase below runs it.
 # node:22-alpine as of 2026-02-22
 FROM node@sha256:e4bf2a82ad0a4037d28035ae71529873c069b13eb0455466ae0bc13363826e34 AS frontend-lint
 WORKDIR /app
 COPY package.json yarn.lock ./
 RUN yarn install --frozen-lockfile
 COPY . .
-RUN script/frontend-lint
+RUN yarn eslint .
 
-# Frontend stage
+# Lint phase: golangci-lint over the Go packages with .golangci.yml,
+# and eslint through the copy from frontend-lint at the end. The
+# golangci/golangci-lint image ships Go and the linter.
+# golangci/golangci-lint:v2.14.0, 2026-09-24
+FROM golangci/golangci-lint@sha256:ad862ba6b3798cbe0fd9fd7408d498fd74fbd2623a92406b2fd3898faf0bf98f AS lint
+WORKDIR /src
+COPY go.mod go.sum ./
+RUN go mod download
+COPY . .
+RUN golangci-lint run --config .golangci.yml ./...
+# Nothing is wanted from frontend-lint; the copy is what makes this
+# phase run it.
+COPY --from=frontend-lint /app/yarn.lock /dev/null
+
+# Frontend stage: the unit tests in test/unit/, then the production
+# build into dist/, which the runtime stage serves. The test phase below
+# runs it. The tests print a dot each; if any fails, they run again with
+# every test listed, and the step 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.
 # node:22-alpine as of 2026-02-22
 FROM node@sha256:e4bf2a82ad0a4037d28035ae71529873c069b13eb0455466ae0bc13363826e34 AS frontend
 WORKDIR /app
-
-# Force BuildKit to run the frontend-lint stage before proceeding, as
-# the builder stage does with the lint stage: without this no-op copy an
-# eslint failure would not gate the image.
-COPY --from=frontend-lint /app/yarn.lock /dev/null
-
 COPY package.json yarn.lock ./
 RUN yarn install --frozen-lockfile
-RUN apk add --no-cache git make
+# vite.config.js reads the commit for the page's footer with git.
+RUN apk add --no-cache git
 COPY . .
-# make frontend-check runs the frontend tests and format check; its test
-# step runs the unit tests, then the production yarn build, so this both
-# produces dist/ and gates the image on test and formatting regressions.
-# This node stage has neither Go nor Docker; the frontend-lint, lint and
-# builder stages above gate the rest.
-RUN make frontend-check
+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
 
-# Runtime stage
+# Test phase: the backend's tests with the race detector and coverage,
+# and the frontend's through the copy from the frontend stage at the
+# 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.
+# Go's module and build caches are in memory (tmpfs) for the go test
+# step alone, so the image make test tags does not carry them and the
+# build spends no time writing them into it. They start empty on every
+# build, so no stored test result can stand in for a run.
+# golang:1.25.7-trixie, 2026-10-07
+FROM golang@sha256:2b174ffcf56c7ad0c47d30d2630693265639ddf2a5141149c2da34db921791b4 AS test
+WORKDIR /src
+COPY . .
+RUN --mount=type=tmpfs,target=/go/pkg/mod \
+    --mount=type=tmpfs,target=/root/.cache/go-build \
+    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 stage; the copy is what makes
+# this phase run its tests.
+COPY --from=frontend /app/yarn.lock /dev/null
+
+# Backend build 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.
+# golang:1.25-alpine (2026-02-27)
+FROM golang@sha256:f6751d823c26342f9506c03797d2527668d095b0a15f1862cddb4d927a7a4ced AS builder
+COPY --from=lint /src/go.sum /dev/null
+COPY --from=test /src/go.sum /dev/null
+RUN apk add --no-cache git
+# A tar-stream context keeps the sender's file owners, which git refuses.
+RUN git config --system --add safe.directory /src
+WORKDIR /src
+COPY go.mod go.sum ./
+RUN go mod download
+COPY . .
+
+# The same go build as in script/build, which builds the binary on the
+# host.
+#
+# The version is the VERSION build argument when one is given, otherwise
+# `git describe --tags --always` on the .git in the build context: the
+# tag on a tagged commit, tag-N-gHASH on a commit after one, the short
+# commit when no tag is reachable. With .git present, a version that is
+# still empty, dev or unknown fails the build: git is missing or could
+# not read the checkout.
+ARG VERSION
+RUN version="${VERSION:-$(git describe --tags --always)}"; \
+    if [ -e .git ]; then \
+        case "$version" in ""|dev|unknown) \
+            echo "version is '$version' although .git is present" >&2; \
+            exit 1 ;; \
+        esac; \
+    fi; \
+    CGO_ENABLED=0 go build -trimpath \
+        -ldflags "-s -w -X main.Version=$version" \
+        -o netwatch-server ./cmd/netwatch-server/
+
+# Runtime stage, and the last one: a plain `docker build .` builds it
+# and the stages it copies from, the two phases included.
 # nginx:stable-alpine as of 2026-02-22
 FROM nginx@sha256:15e96e59aa3b0aada3a121296e3bce117721f42d88f5f64217ef4b18f458c6ab
 
@@ -103,8 +129,8 @@ RUN addgroup -g 1000 -S netwatch && \
 # At start-up the nginx image renders every template here into
 # conf.d; bin/entrypoint.sh says how.
 RUN rm /etc/nginx/conf.d/default.conf
-COPY nginx.conf /etc/nginx/templates/netwatch.conf.template
-COPY security-headers.conf /etc/nginx/security-headers.conf
+COPY configs/nginx.conf /etc/nginx/templates/netwatch.conf.template
+COPY configs/security-headers.conf /etc/nginx/security-headers.conf
 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

Makefile

@@ -1,10 +1,10 @@
-.PHONY: bootstrap setup dev build test lint fmt fmt-check check \
-	add-dependency tidy frontend-check frontend-viewport-test docker hooks
+.PHONY: bootstrap setup dev build run clean test lint fmt fmt-check check \
+	add-dependency tidy frontend-viewport-test docker hooks
 
 # Standard targets are thin shims; the implementations live in script/
 # per the scripts-to-rule-them-all pattern (see the Entrypoints section
 # of README.md). test, lint, fmt, fmt-check and check cover the whole
-# repo: the frontend here and the Go backend in backend/.
+# repo: the frontend in web/ and the Go backend in cmd/ and internal/.
 
 bootstrap:
 	@script/bootstrap
@@ -15,10 +15,17 @@ setup:
 dev:
 	@script/dev
 
-# The frontend only; backend/Makefile's build target builds the Go server.
+# The frontend into dist/ and the netwatch-server binary.
 build:
 	@script/build
 
+# Builds, then runs netwatch-server on port 8080.
+run:
+	@script/run
+
+clean:
+	@script/clean
+
 test:
 	@script/test
 
@@ -42,14 +49,8 @@ add-dependency:
 tidy:
 	@script/tidy
 
-# The frontend tests and format check, for Dockerfile's frontend stage,
-# which has neither Go nor Docker. Use check everywhere else.
-frontend-check:
-	@script/frontend-check
-
 # Responsive-layout verification in a containerised browser. Kept out of
-# check: it needs Docker and takes minutes, where make test has to stay
-# under 20 seconds.
+# check: it takes minutes.
 frontend-viewport-test:
 	@script/frontend-viewport-test
 

README.md

@@ -13,10 +13,13 @@ make setup
 # Run the page on the Vite dev server
 make dev
 
+# Build netwatch-server and run it on port 8080
+make run
+
 # Run the tests, both linters and the format check
 make check
 
-# Build the page into dist/
+# Build the page into dist/ and netwatch-server into the repo root
 make build
 
 # Build the image and run it
@@ -25,9 +28,8 @@ docker run -p 8080:8080 netwatch
 ```
 
 `make check` and `make docker` need Docker. `make dev` passes `/api` to
-`http://127.0.0.1:8080`, where `make run` in `backend/` starts `netwatch-server`
-with its defaults, so the reports the page posts are stored in
-`backend/data/reports`.
+`http://127.0.0.1:8080`, where `make run` starts `netwatch-server` with its
+defaults, so the reports the page posts are stored in `data/reports`.
 
 ## Entrypoints
 
@@ -35,56 +37,56 @@ This repository adheres to the
 [Scripts to Rule Them All](https://github.com/github/scripts-to-rule-them-all)
 standard: normalized scripts in `script/` are the entrypoints for the
 development workflow, and the Makefile targets are thin shims that call them.
-The Go backend in `backend/` has its own `script/` directory and shim Makefile
-(see [backend/README.md](backend/README.md)). The root scripts cover both
-halves, so the root `make check` fails if either one is broken. We provide:
+The scripts cover both the frontend and the Go backend, so `make check` fails if
+either one is broken. We provide:
 
 - `script/bootstrap` — install all dependencies (the pinned node via nvm unless
   one new enough for the frontend's dependencies is installed, yarn via
-  corepack, `yarn install --frozen-lockfile`, the pinned Go unless one at least
-  as new as `backend/go.mod` asks for is installed, the Go modules, and gcc with
-  the C library headers unless gcc is installed, for the race detector in
-  `make test`), linking what it installs itself into `~/.local/bin`, which has
-  to be on `PATH`. It installs no Go linter and not Docker: `make lint` runs
-  both linters in Docker
+  corepack, `yarn install --frozen-lockfile`, Go `GO_VERSION` unless the `go` on
+  `PATH` is exactly that version, and the Go modules), linking what it installs
+  itself into `~/.local/bin`, which has to be on `PATH`. It installs no Go
+  linter and not Docker: `make test` and `make lint` run in Docker
 - `script/setup` — make a fresh clone ready for development: bootstrap plus the
   git pre-commit hook
 - `script/dev` — run the Vite dev server, which proxies `/api` to a locally
   running `netwatch-server`
-- `script/build` — build the frontend for production into `dist/`;
-  `backend/script/build` builds the Go server
+- `script/build` — build the frontend for production into `dist/`, then the
+  static `netwatch-server` binary into the repo root with its version stamped
+  in: `VERSION` from the environment, or when that is unset or empty,
+  `git describe` inside a git checkout, then `dev`
+- `script/run` — build with `script/build`, then run `netwatch-server` with its
+  defaults (see [Settings](#settings))
+- `script/clean` — remove what `script/build` writes
 - `script/projectname` — print the project name (used for the Docker image tag)
-- `script/test` — run `script/frontend-test`, then `backend/script/test`, the
+- `script/test` — build the `test` phase of `Dockerfile` without the cache: the
+  frontend's unit tests and production build in its `frontend` stage, and the
   backend's Go tests with the race detector and coverage
-- `script/lint` — run eslint, then golangci-lint, both in Docker, by building
-  the `frontend-lint` and `lint` stages of `Dockerfile` without the cache
-- `script/fmt` — format all files (writes): prettier, then gofmt over `backend/`
+- `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,
+  HTML and Markdown, then gofmt over `cmd/` and `internal/`. It runs on the
+  host, as `script/fmt-check` does, with `~/.local/bin` put on `PATH`
 - `script/fmt-check` — check formatting (read-only): prettier, then gofmt
 - `script/check` — run test, lint, and fmt-check
 - `script/add-dependency` — add a frontend package, or move one to another
   version: `make add-dependency PACKAGE=<name>@<version>` runs `yarn add --dev`,
   which changes `package.json` and `yarn.lock` together, then
   `yarn install --frozen-lockfile`
-- `script/tidy` — run `go mod tidy` in `backend/`: to add a Go module, import it
-  and run `make tidy`; to move one to another version, edit its `require` line
-  in `backend/go.mod`, then run `make tidy`
-- `script/frontend-test` — run the unit tests in `test/unit/` 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 run has a 30-second timeout
-- `script/frontend-lint` — run eslint with the rules in `eslint.config.js`; it
-  runs inside the `frontend-lint` stage of `Dockerfile`, which `make lint`
-  builds
-- `script/frontend-fmt` — format everything prettier understands (writes), the
-  markdown in `backend/` included
+- `script/tidy` — run `go mod tidy`: to add a Go module, import it and run
+  `make tidy`; to move one to another version, edit its `require` line in
+  `go.mod`, then run `make tidy`
+- `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 in
+  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-check` — run `script/frontend-test` and
-  `script/frontend-fmt-check`, for the frontend stage of `Dockerfile`, which has
-  neither Go nor Docker
 - `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)). Not part of
-  `script/check`: it needs Docker and takes minutes.
+  `script/check`: it takes minutes.
 - `script/docker` — build the image from `Dockerfile` without the build cache,
   tagged `netwatch` via `script/projectname`
 - `script/cibuild` — CI entrypoint: runs `script/bootstrap` and `script/check`,
@@ -95,11 +97,11 @@ halves, so the root `make check` fails if either one is broken. We provide:
 ## Responsive layout
 
 The narrow-viewport layout lives in the `max-width: 768px` media block in
-`src/styles.css`. It is verified automatically by `make frontend-viewport-test`,
-which drives a digest-pinned headless Chrome against the built `dist/` and
-asserts on computed layout at widths derived from that CSS — on every breakpoint
-it declares and one pixel either side of it, plus a 320px floor, a desktop
-baseline and two landscape sizes. See
+`web/src/styles.css`. It is verified automatically by
+`make frontend-viewport-test`, which drives a digest-pinned headless Chrome
+against the built `dist/` and asserts on computed layout at widths derived from
+that CSS — on every breakpoint it declares and one pixel either side of it, plus
+a 320px floor, a desktop baseline and two landscape sizes. See
 [test/viewport/README.md](test/viewport/README.md) for what it covers and what
 it genuinely cannot.
 
@@ -114,8 +116,11 @@ the same and nothing is stored.
 
 ## Design
 
+The page's source is in `web/`, the Go backend's in `cmd/` and `internal/`, and
+nginx's configuration in `configs/`.
+
 The page is built with Vite and Tailwind CSS v4. Its code is all in
-`src/main.js`, with a class-based architecture:
+`web/src/main.js`, with a class-based architecture:
 
 - **`CONFIG`**: Configuration object (update interval, timeouts, axis ticks,
   etc.). The interval menu sets `updateInterval`, the one value the page writes
@@ -144,16 +149,18 @@ same-origin path `/api/v1/reports`: a random per-browser `clientId` kept in
 `localStorage`, `geo` sent as null, and each host's unreported, non-paused
 samples (timestamp, latency, error). A per-host high-water mark makes every
 report a delta, so only new samples are sent; the mark advances only on a
-delivered report, and while paused nothing is sent. Delivery failure is quiet —
-one debug-log line per outage, retried at the next interval, never blocking
-probing. The report-building step is a pure function of host state.
+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,
+retried at the next interval, never blocking probing. The report-building step
+is a pure function of host state.
 
 ### Backend
 
-`netwatch-server`, in `backend/`, is a small Go HTTP server that stores the
-reports the page posts. It keeps them in memory and writes them to `DATA_DIR` as
-zstd-compressed files of JSON lines: every minute, whenever 10 MiB are waiting,
-and when it stops. Its routes:
+`netwatch-server` is a small Go HTTP server that stores the reports the page
+posts. It keeps them in memory and writes them to `DATA_DIR` as zstd-compressed
+files of JSON lines: every minute, whenever 10 MiB are waiting, and when it
+stops. Its routes:
 
 - `POST /api/v1/reports` — takes a report, without credentials; each client
   address may send a limited number a minute, and the report files are capped in
@@ -164,11 +171,133 @@ and when it stops. Its routes:
   `METRICS_USERNAME` and `METRICS_PASSWORD` are set; each client address may
   make a limited number of requests to it a minute
 
-In the image, the `builder` stage of `Dockerfile` tests it and builds it with
-`backend/script/build`, and `bin/entrypoint.sh` runs it as user `netwatch` on
-`127.0.0.1:8081`, behind nginx. Outside the image, `make run` in `backend/`
-builds it and runs it on port 8080. Its settings, report storage and limits are
-in [backend/README.md](backend/README.md).
+It is an `fx`-wired Go application: `cmd/netwatch-server/` starts it, and its
+packages are in `internal/`:
+
+- **`config`**: Loads configuration from environment variables and config files
+  via Viper.
+- **`handlers`**: HTTP request handlers for the API (health check, report
+  ingestion).
+- **`reportbuf`**: The in-memory buffer of reports and the files it writes them
+  to.
+- **`server`**: Chi-based HTTP server with middleware wiring and route
+  registration.
+- **`healthcheck`**, **`middleware`**, **`logger`**, **`globals`**: Supporting
+  infrastructure.
+
+In the image, the `test` phase of `Dockerfile` tests it, the `builder` stage
+builds it, and `bin/entrypoint.sh` runs it as user `netwatch` on
+`127.0.0.1:8081`, behind nginx (see [Deployment](#deployment)). Outside the
+image, `make run` builds it and runs it on port 8080.
+
+#### Settings
+
+| Variable               | Default              | Description                                                                                              |
+| ---------------------- | -------------------- | -------------------------------------------------------------------------------------------------------- |
+| `BIND_ADDRESS`         | empty                | IP address to listen on; empty listens on every interface                                                |
+| `PORT`                 | `8080`               | HTTP listen port                                                                                         |
+| `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`      | 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
+`127.0.0.1/32,::1/128,10.0.0.0/8,172.16.0.0/12,192.168.0.0/16`. The loopback
+entries cover a reverse proxy on the same host. A request whose direct peer is
+outside this set has its forwarded headers ignored, and the direct peer is
+logged and rate-limited instead. 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.
+
+#### Report storage
+
+Reports are written as `reports-<timestamp>-<number>.jsonl.zst` files in
+`DATA_DIR`. The timestamp is in UTC to the millisecond, so the names sort by
+time. The number starts at 1 when the server starts and goes up by one for each
+file the server starts to write, so two files written in the same millisecond
+still get different names. A failed write uses up its number and leaves a gap in
+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.
+
+#### Report limits
+
+`POST /api/v1/reports` takes reports from anyone who can reach it, without
+credentials, so it is bounded instead. Both refusals below answer with the same
+`{"status":"error"}` body as any other error.
+
+- **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
+  count, fading out over the current one, so an address is sure never to be
+  refused only while it sends at most half of `REPORTS_PER_MINUTE` in any 60
+  seconds. The page sends one report a minute from each open tab, so the default
+  of 60 refuses nothing from up to 30 tabs behind one address, such as a
+  household or an office sharing it, however their reports bunch up. Report
+  responses also carry `X-RateLimit-Limit`, `X-RateLimit-Remaining` and
+  `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;
+  those lost to a failed write stop counting, and the part of its file written
+  is removed. When a report would take the total past the cap, the oldest report
+  files are deleted to make room, and each deletion is logged with the file's
+  name and size; a file still being written is never deleted. A report is
+  refused with 507, and nothing of it is stored, only when the reports waiting
+  to be written fill the cap on their own, and then no file is deleted. At
+  start, report files past the cap, as after lowering it, are deleted the same
+  way. So the cap is how much of the newest reports is kept: the default of 1
+  GiB is small enough for any host; set it to the space you can give `DATA_DIR`.
+
+#### CORS
+
+The page calls the API from the origin it is served from, so by default the
+server sends no CORS headers, and browsers let no other origin's pages call it.
+To serve the page from elsewhere, list that origin in `CORS_ALLOWED_ORIGINS`
+(for example `https://netwatch.example.com`); pages from a listed origin may
+`GET` and `POST` with a `Content-Type` header. Each entry must be a plain
+origin, `scheme://host` with an optional `:port`, as browsers send it: no path,
+not even a trailing `/`, and no `*`. Any other entry stops the server from
+starting, with an error naming `CORS_ALLOWED_ORIGINS`.
+
+#### Metrics
+
+With both `METRICS_USERNAME` and `METRICS_PASSWORD` set, the server serves
+Prometheus metrics at `GET /metrics` to requests with those as their basic auth
+credentials, and answers any other with 401. For each request that reaches the
+health check or `POST /api/v1/reports`, those the rate limit refuses included,
+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, 405
+for a method its route does not take, or 413 for declaring a body length over
+the 1 MiB limit. A report whose body goes over the limit without declaring its
+length reaches the route, is answered 413 there, and is recorded with that
+status. 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
+minute, whatever their credentials. Past that it gets 429 with
+`Retry-After: 60`, and its credentials are not checked. The minute slides as it
+does for reports (see [Report limits](#report-limits)), so a scraper polling
+every 2 seconds or less often is never refused. This allowance is apart from the
+one for reports.
+
+#### Sentry
+
+With `SENTRY_DSN` set, each panic in a handler is reported to that Sentry
+project under the release `netwatch-server-` followed by the server's version.
+On shutdown the server waits up to 2 seconds for Sentry to finish sending.
 
 ### Monitoring targets
 
@@ -270,20 +399,25 @@ behind a reverse proxy.
 
 The Docker image, built from `Dockerfile` by `make docker`, is the whole service
 in one container: nginx serves the built frontend and passes `/api/`,
-`/.well-known/healthcheck` and `/metrics` to the Go backend, `netwatch-server`,
-which listens only inside the container, on `127.0.0.1:8081`. The image:
+`/.well-known/healthcheck` and `/metrics` to the Go backend, `netwatch-server`.
+`bin/entrypoint.sh` starts it listening only inside the container, on
+`127.0.0.1:8081`, with `TRUSTED_PROXIES=127.0.0.1/32`, so it takes the client
+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`, and by default from none
+  reverse proxies named in `TRUSTED_PROXIES`, and by default from none.
+  `bin/entrypoint.sh` checks each entry with `netwatch-server check-cidr`, which
+  parses it as the backend parses its own `TRUSTED_PROXIES`
 - Sends access logs to stdout
 - Caches static assets with immutable headers
 - Sends the security headers `REPO_POLICIES.md` requires on every response, as
-  `security-headers.conf` sets them, in place of the backend's own
+  `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`
   volume. Before the backend starts, the image creates `DATA_DIR` and gives it
-  and `/data` to user `netwatch` (uid 1000), which the backend runs as, so a
-  host directory bind-mounted at `/data` ends up owned by uid 1000
+  and `/data` to user `netwatch` (uid 1000), which the backend runs as, with
+  `netwatch-server prepare-data-dir`, which acts on nothing outside `/data`, so
+  a host directory bind-mounted at `/data` ends up owned by uid 1000
 - Writes buffered reports to disk on `docker stop`, and exits non-zero if nginx
   or the backend exits on its own, so the platform restarts it
 

REPO_POLICIES.md

@@ -1,6 +1,6 @@
 ---
 title: Repository Policies
-last_modified: 2026-07-06
+last_modified: 2026-10-04
 ---
 
 This document covers repository structure, tooling, and workflow standards. Code
@@ -60,17 +60,28 @@ style conventions are in separate documents:
   prerequisite since nvm requires bash. yarn is then pinned via
   `corepack prepare yarn@<version> --activate`. Never install "latest" or "lts";
   always exact versions. `script/cibuild` runs the CI build: it changes to the
-  repo root and runs `docker build .`; the Gitea workflow calls it. Four further
-  scripts are our own extensions to the standard: `script/check` runs
-  `script/test`, `script/lint`, and `script/fmt-check`; `script/precommit` is
-  what the git pre-commit hook runs, and it calls `script/check`;
-  `script/install-precommit` installs the git pre-commit hook (the `make hooks`
-  target shims to it); and `script/projectname` (literally that filename) simply
-  outputs the project's name. Scripts that need the name call
-  `script/projectname` — e.g. `script/docker` assembles its image tag from it —
-  so those scripts stay byte-identical across all repos. Repo-type-specific
-  pre-commit extras (e.g. `go mod tidy` verification in Go repos) belong in
-  `script/precommit`, not in the hook itself. Model scripts are at
+  repo root, runs `script/bootstrap`, runs `script/check`, and builds the image
+  with the version; the Gitea workflow calls it. **`script/cibuild` runs
+  `script/bootstrap` first**, because the workflow checks out the repo and runs
+  nothing else, while `script/fmt-check` runs the formatter on the host: on a
+  pristine checkout with nothing installed the run dies there, after the
+  containerised gates have passed. **The bootstrap alone is not enough**:
+  `script/bootstrap` installs node and yarn under nvm and leaves neither on the
+  `PATH` of the shell that called it, so a bare `yarn` still exits 127. The host
+  entrypoints that need yarn — `script/fmt` and `script/fmt-check` — therefore
+  source nvm for the pinned node version before invoking it, exactly as
+  `script/bootstrap`'s own install step does. A runner carrying nothing but
+  docker and git then gets through `script/check`. Four further scripts are our
+  own extensions to the standard: `script/check` runs `script/test`,
+  `script/lint` and `script/fmt-check`; `script/precommit` is what the git
+  pre-commit hook runs, and it calls `script/check`; `script/install-precommit`
+  installs the git pre-commit hook (the `make hooks` target shims to it); and
+  `script/projectname` (literally that filename) simply outputs the project's
+  name. Scripts that need the name call `script/projectname` — e.g.
+  `script/docker` assembles its image tag from it — so those scripts stay
+  byte-identical across all repos. Repo-type-specific pre-commit extras (e.g.
+  `go mod tidy` verification in Go repos) belong in `script/precommit`, not in
+  the hook itself. Model scripts are at
   `https://git.eeqj.de/sneak/prompts/raw/branch/main/script/<name>`. The README
   must document the provided scripts in an **Entrypoints** section (see the
   README requirements below).
@@ -89,87 +100,198 @@ style conventions are in separate documents:
   contributor should be able to understand the entire development workflow by
   reading the Makefile.
 
-- Every repo should have a `Dockerfile`. All Dockerfiles must run `make check`
-  as a build step so the build fails if the branch is not green. For non-server
-  repos, the Dockerfile should bring up a development environment and run
-  `make check`. For server repos, `make check` should run as an early build
-  stage before the final image is assembled. Dockerfiles install development
-  prerequisites by running `script/bootstrap` rather than duplicating installs
-  inline; COPY `script/` and the dependency manifests (`package.json` +
-  `yarn.lock`, `go.mod` + `go.sum`, etc.) before running it so the bootstrap
-  layer stays cached until dependencies change.
+- Every repo should have a `Dockerfile`, and it carries the repo's gates: a
+  `lint` phase and a `test` phase, with the final stage depending on both so the
+  image cannot be built unless they pass. For non-server repos the final stage
+  brings up a development environment; for server repos it is the runtime image.
+  The gate phases and the build stage start from their pinned base images and
+  install what those images lack either inline, as the canonical Go `Dockerfile`
+  below does for `git`, or by running `script/bootstrap`, as the `prompts`
+  repo's own `Dockerfile` does for its yarn packages. The development
+  environment stage installs development prerequisites by running
+  `script/bootstrap` rather than duplicating its installs inline. A stage that
+  runs `script/bootstrap` COPYs `script/` and the dependency manifests
+  (`package.json` + `yarn.lock`, `go.mod` + `go.sum`, etc.) before running it.
 
-- **Dockerfiles must use a separate lint stage for fail-fast feedback.** Go
-  repos use a multistage build where linting runs in an independent stage based
-  on the `golangci/golangci-lint` image (pinned by hash). This stage runs
-  `make fmt-check` and `make lint` before the full build begins. The build stage
-  then declares an explicit dependency on the lint stage via
-  `COPY --from=lint /src/go.sum /dev/null`, which forces BuildKit to complete
-  linting before proceeding to compilation and tests. This ensures lint failures
-  surface in seconds rather than minutes, without blocking on dependency
-  download or compilation in the build stage.
+- **Linting and testing run in Docker, as phases of the `Dockerfile`.** There is
+  no separate lint file. `script/lint` and `script/test` each build one phase
+  and nothing else:
 
-    The standard pattern for a Go repo Dockerfile is:
+    ```sh
+    docker build --no-cache --target lint -t "$(script/projectname)-lint" .
+    docker build --no-cache --target test -t "$(script/projectname)-test" .
+    ```
+
+    **A stage that is not the last one in the file is built only when the final
+    stage's chain depends on it, or when `--target` names it.** That is why the
+    two gates are always invoked by name here, and why the final stage carries a
+    `COPY --from=` of a harmless file from each of them: without that edge a
+    plain `docker build .` builds the last stage alone and exits 0 having linted
+    and tested nothing.
+
+    **Every `docker build` in `script/` is tagged**, here and in
+    `script/cibuild` and `script/docker`. An untagged build leaves a dangling
+    image behind on every invocation, on every developer host and every CI
+    runner; a tagged one replaces the previous image.
+
+    Inside a phase the tool is invoked directly — `golangci-lint`, `go test`,
+    `eslint`, `prettier` — never through `make lint` or `script/test`, which are
+    themselves a `docker build` and would recurse into a daemon that does not
+    exist in a build step. Formatting is the exception and stays on the host:
+    `script/fmt` writes the working tree, and `script/fmt-check` is its
+    read-only twin.
+
+    **No lint verdict may come from a host invocation of the linter.** On a
+    shared host golangci-lint reads a result cache keyed on file content rather
+    than location, so a second checkout of the same content is served the first
+    one's findings, and a host-global lock in `$TMPDIR` makes concurrent runs
+    exit non-zero with `parallel golangci-lint is running` — a status a caller
+    cannot tell from real findings. Both have produced wrong verdicts in this
+    org, in both directions. A container has its own cache, its own `TMPDIR` and
+    a digest-pinned binary, so neither is reachable.
+
+- **Any build that runs checks is built with `--no-cache`.** Docker invalidates
+  a `COPY` layer only when the copied content changes, so on an unchanged tree
+  the check `RUN` is served from cache, nothing executes, and the build still
+  exits 0. Every `docker build` in `script/` therefore passes `--no-cache`:
+  `script/lint`, `script/test`, `script/cibuild` and `script/docker` are the
+  four, and there is no fifth — `script/check` runs the two gate phases and
+  `script/fmt-check`, and builds no image of its own. A bare `docker build .` is
+  not evidence that anything ran: a sub-second build reporting success is a
+  cache hit, not a result. Never invalidate by pruning — `docker builder prune`
+  and friends destroy a build cache shared with every other build on the host.
+  When a check is added or changed, prove it works by planting a defect it must
+  catch and watching the run fail on it, then revert the defect. A green run
+  alone shows neither that the check ran nor that it covers what it should.
+
+- **The gate phases are separate stages, and the build stage depends on both.**
+  The lint phase is based on the `golangci/golangci-lint` image (pinned by
+  hash), so lint failures surface in seconds rather than after a full compile,
+  and the test phase is based on the Debian Go image. The canonical Go repo
+  `Dockerfile`:
 
     ```dockerfile
-    # Lint stage — fast feedback on formatting and lint issues
+    # Lint phase
     # golangci/golangci-lint:v2.x.x, YYYY-MM-DD
     FROM golangci/golangci-lint@sha256:... AS lint
     WORKDIR /src
     COPY go.mod go.sum ./
     RUN go mod download
     COPY . .
-    RUN make fmt-check
-    RUN make lint
+    RUN golangci-lint run --config .golangci.yml ./...
 
-    # Build stage
-    # golang:1.x-alpine, YYYY-MM-DD
-    FROM golang@sha256:... AS builder
+    # Test phase. -race needs cgo and so a C compiler, which the Debian Go
+    # image ships and the alpine one does not.
+    # golang:1.x, YYYY-MM-DD
+    FROM golang@sha256:... AS test
     WORKDIR /src
-
-    # Force BuildKit to run the lint stage before proceeding
-    COPY --from=lint /src/go.sum /dev/null
-
     COPY go.mod go.sum ./
     RUN go mod download
     COPY . .
-    RUN make test
+    RUN go test -timeout 90s -race -cover ./... || \
+        { echo "--- Rerunning with -v for details ---"; \
+          go test -timeout 90s -race -v ./...; exit 1; }
 
-    ARG VERSION=dev
-    RUN CGO_ENABLED=0 go build -trimpath \
-        -ldflags="-s -w -X main.Version=${VERSION}" \
-        -o /app ./cmd/app/
+    # Build stage. Nothing is wanted from either phase above; the copies
+    # are what make BuildKit build them first, so this stage cannot run
+    # unless lint and test passed.
+    # golang:1.x-alpine, YYYY-MM-DD
+    FROM golang@sha256:... AS builder
+    COPY --from=lint /src/go.sum /dev/null
+    COPY --from=test /src/go.sum /dev/null
+    RUN apk add --no-cache git
+    # A tar-stream context keeps the sender's file owners, which git refuses.
+    RUN git config --system --add safe.directory /src
+    WORKDIR /src
+    COPY go.mod go.sum ./
+    RUN go mod download
+    COPY . .
 
-    # Runtime stage
+    # The VERSION build arg when one is given, otherwise
+    # `git describe --tags --always` on the .git in the build context. With
+    # .git present, a version that is still empty, dev or unknown fails the
+    # build: git is missing or could not read the checkout.
+    ARG VERSION
+    RUN VERSION="${VERSION:-$(git describe --tags --always)}"; \
+        if [ -e .git ]; then \
+            case "$VERSION" in ""|dev|unknown) \
+                echo "version is '$VERSION' although .git is present" >&2; \
+                exit 1 ;; \
+            esac; \
+        fi; \
+        CGO_ENABLED=0 go build -trimpath \
+            -ldflags="-s -w -X main.Version=${VERSION}" \
+            -o /app ./cmd/app/
+
+    # Runtime stage, and the last one
     FROM alpine@sha256:...
     COPY --from=builder /app /usr/local/bin/app
     ENTRYPOINT ["app"]
     ```
 
     Key points:
-    - The lint stage uses the `golangci/golangci-lint` image directly (it
-      includes both Go and the linter), so there is no need to install the
-      linter separately.
-    - `COPY --from=lint /src/go.sum /dev/null` is a no-op file copy that creates
-      a stage dependency. BuildKit runs stages in parallel by default; without
-      this line, the build stage would not wait for lint to finish and a lint
-      failure might not fail the overall build.
+    - The lint phase uses the `golangci/golangci-lint` image directly (it has
+      both Go and the linter), so nothing needs installing.
+    - `COPY --from=<phase> /src/go.sum /dev/null` is a no-op copy whose only
+      purpose is the ordering edge. BuildKit runs stages in parallel by default,
+      and a stage nothing depends on is not built at all, so without these two
+      lines a red gate would not fail the build.
+    - Keep the runtime stage last, and if you add a stage after it, give it the
+      same two copies. A plain `docker build .` builds the last stage's chain
+      and nothing else.
     - If the project uses `//go:embed` directives that reference build artifacts
-      (e.g. a web frontend compiled in a separate stage), the lint stage must
+      (e.g. a web frontend compiled in a separate stage), the lint phase must
       create placeholder files so the embed directives resolve. Example:
       `RUN mkdir -p web/dist && touch web/dist/index.html web/dist/style.css`.
-      The lint stage should not depend on the actual build output — it exists to
-      fail fast.
-    - If the project requires CGO or system libraries for linting (e.g.
-      `vips-dev`), install them in the lint stage with `apk add`.
-    - The build stage runs `make test` after compilation setup. Tests run in the
-      build stage, not the lint stage, because they may require compiled
-      artifacts or heavier dependencies.
+    - If the project requires CGO or system libraries for linting, install them
+      in the lint phase. The `golangci/golangci-lint` image is Debian-based and
+      has no `apk`, so install with `apt-get` under the Debian package name
+      (`libvips-dev`, where alpine says `vips-dev`), and delete the package
+      lists in the same `RUN`, so the layer does not keep them:
+
+        ```dockerfile
+        RUN apt-get update \
+            && apt-get install -y --no-install-recommends libvips-dev \
+            && rm -rf /var/lib/apt/lists/*
+        ```
+
+    - `.dockerignore` lets `.git` into the build context. It keeps out every git
+      `config` at any depth (`**/.git/config`, `**/.git/modules/**/config`): the
+      repository's own, each submodule's under `.git/modules/`, and that of a
+      submodule keeping its own `.git` directory. `git describe` does not need
+      them, and each can hold a credential: a password in a remote URL, or the
+      token the CI checkout step stores there. A submodule whose name has a
+      `config` segment (`config`, `deploy/config`, `config/lib`) loses its whole
+      git directory to `**/.git/modules/**/config`, and Go's version stamping
+      then fails the build: give it a name without that segment
+      (`git submodule add --name`). The stage that compiles has `git` (the
+      Debian Go image has it; an alpine one needs `apk add --no-cache git`) and
+      takes the version from the `VERSION` build argument when one is given,
+      otherwise from `git describe --tags --always`. That gives the tag on a
+      tagged commit; on a later commit, the tag, the number of commits since it
+      and the short commit (`v1.2.3-4-gabc1234`); and the short commit when no
+      tag is reachable. The stage that compiles also marks its working directory
+      safe for git (`git config --system --add safe.directory /src`): a context
+      sent as a tar stream keeps the sender's file owners, and git refuses a
+      checkout owned by another user, so the version would come out empty.
+      `ARG VERSION` has no default, and the build fails if the context carries
+      `.git` and the version still comes out empty, `dev` or `unknown`. A plain
+      `docker build .` with no build arguments must succeed; a Dockerfile that
+      refuses an empty build argument drops that refusal and keeps the argument.
 
 - Every repo should have a Gitea Actions workflow (`.gitea/workflows/`) that
-  runs `script/cibuild` (which runs `docker build .`) on push. Since the
-  Dockerfile already runs `make check`, a successful build implies all checks
-  pass.
+  runs `script/cibuild` on push, and checks out the repo as its only other step.
+  That script bootstraps, runs the gate phases, and then builds the image, so a
+  successful run means every check passed; a bare `docker build .` does not
+  carry the same guarantee, because its gate phases may come from the cache. The
+  image build is uncached and so runs the gate phases a second time. That is the
+  price of the rule above, and it is worth paying: the image that ships is built
+  from a run of its own gates rather than from a cache entry. A separate
+  workflow limited to `main` by a `branches` list under `on: push` cannot be
+  checked by review: to try a change to it, add the feature branch to that list
+  and push, then remove the branch from the list again before merging. Keep any
+  job in it that publishes behind `if: github.ref_name == 'main'`, so the run
+  from the feature branch publishes nothing.
 
 - Use platform-standard formatters: `black` for Python, `prettier` for
   JS/CSS/Markdown/HTML, `go fmt` for Go. Always use default configuration with
@@ -189,14 +311,21 @@ style conventions are in separate documents:
   module under test to verify it compiles/parses. There is no excuse for
   `make test` to be a no-op.
 
-- `make test` must complete in under 20 seconds. Add a 30-second timeout in the
-  Makefile.
+- `make test` must complete in under 60 seconds. That is the hard cap, and a
+  suite that exceeds it fails. Under 20 seconds is the target. A suite between
+  20 and 60 seconds is still green, but the overage must be filed as an
+  improvement bug against that repo. Add a 90-second timeout to the test
+  invocation (`go test -timeout 90s`). The backstop deliberately sits above the
+  hard cap so that it catches a genuinely hung test rather than a merely slow
+  one.
 
-- **`make test` should use the conditional verbose rerun pattern.** Run tests
-  without `-v` (verbose) first. If tests fail, automatically rerun with `-v` to
-  show full output. This keeps CI logs and `docker build` output clean on
-  success (just package/suite summaries) while providing full diagnostic detail
-  on failure (every test case, every assertion). The general shell pattern:
+- **The test command should use the conditional verbose rerun pattern.** Run
+  tests without `-v` (verbose) first. If tests fail, automatically rerun with
+  `-v` to show full output. This keeps CI logs and `docker build` output clean
+  on success (just package/suite summaries) while providing full diagnostic
+  detail on failure (every test case, every assertion). The command lives in the
+  `test` phase of the `Dockerfile`, since `script/test` builds that phase; the
+  Makefile form below is the same pattern for any repo-local invocation:
 
     ```makefile
     test:
@@ -209,11 +338,26 @@ style conventions are in separate documents:
 
     ```makefile
     test:
-    	@go test -timeout 30s -race -cover ./... || \
+    	@go test -count=1 -timeout 90s -race -cover ./... || \
     		{ echo "--- Rerunning with -v for details ---"; \
-    		  go test -timeout 30s -race -v ./...; exit 1; }
+    		  go test -count=1 -timeout 90s -race -v ./...; exit 1; }
     ```
 
+    `-count=1` is required on both invocations: it defeats Go's test _result_
+    cache, so neither run can report a stored pass in place of running the
+    tests. It leaves the build cache alone, so it costs the runtime of the suite
+    and no recompilation.
+
+    That cache is Go's own, separate from Docker's layer cache. Go stores a
+    passing result in its cache directory (`GOCACHE`), and when the same tests
+    run again on unchanged code it prints that result, marked `(cached)`,
+    without running them. That matters on a developer's machine, where this
+    target runs and the directory lasts from one run to the next. The `test`
+    phase of the `Dockerfile` needs no `-count=1`: its base image holds no
+    result for this repo's tests and nothing before its `go test` step runs a
+    test, so there is nothing to replay. `--no-cache` (above) is what makes that
+    step run on an unchanged tree.
+
     Python example:
 
     ```makefile
@@ -239,10 +383,84 @@ style conventions are in separate documents:
   must be in `.gitignore`. No exceptions.
 
 - `.gitignore` should be comprehensive from the start: OS files (`.DS_Store`),
-  editor files (`.swp`, `*~`), language build artifacts, and `node_modules/`.
-  Fetch the standard `.gitignore` from
-  `https://git.eeqj.de/sneak/prompts/raw/branch/main/.gitignore` when setting up
-  a new repo.
+  editor files (`.swp`, `*~`), in-repo agent scratch directories (`.claude/`),
+  language build artifacts, and `node_modules/`. Fetch the standard `.gitignore`
+  from `https://git.eeqj.de/sneak/prompts/raw/branch/main/.gitignore` when
+  setting up a new repo. These patterns are written to `.gitignore`'s own
+  semantics, in which an unanchored pattern already matches at every depth; they
+  are not a `.dockerignore` and must not be transplanted into one unmodified.
+
+- **`.dockerignore` does not use `.gitignore` semantics, and copying patterns
+  across unmodified leaves secrets in the build context.** Docker matches with
+  `moby/patternmatcher`: `filepath.Match` semantics plus a `**` extension, so
+  `*` does not cross `/` and a pattern without a leading `**/` is anchored at
+  the build-context root. A `.dockerignore` listing `.env`, `*.pem` and `*.key`
+  therefore excludes only the copies at the repository root, while `config/.env`
+  and `certs/server.key` still reach the context and can land in an image layer
+  — which is more dangerous than a short file with no secret patterns at all,
+  because it reads as solved and stops anyone looking. Give every
+  depth-independent pattern the `**/` prefix and leave only genuinely
+  root-anchored entries unprefixed: `.claude`, and the repo's own host-built
+  binary, written `/myapp` and never `**/myapp`, which would also match
+  `cmd/myapp/` and delete the package directory from the context. Matching is
+  case-sensitive, and an ALL-CAPS twin per pattern still misses `Server.Key`, so
+  secret names use character ranges — `**/*.[kK][eE][yY]`, `**/*.[pP][eE][mM]`,
+  and likewise for `.envrc` and the extensionless SSH keys. Where such a pattern
+  also catches something the build needs, re-include it with a negation
+  (`!docs/example.env`); deleting the pattern reopens the exposure for every
+  other file it covers. Fetch the standard `.dockerignore` from
+  `https://git.eeqj.de/sneak/prompts/raw/branch/main/.dockerignore` and extend
+  it with the repo's own artifacts.
+
+- **In-repo agent scratch belongs in both files, written to each file's own
+  semantics.** `.claude/` holds one worktree per in-flight agent — an entire
+  additional checkout of the repo — so under `COPY . .` the build context
+  inflates by a multiple of the repo and another session's unreviewed work can
+  be copied into an image layer. In `.gitignore` the entry is `.claude/`,
+  unanchored. In `.dockerignore` it is `.claude`, anchored and with **no** `**/`
+  prefix, because the prefixed form would also delete any nested directory of
+  that name from the build. Anchoring carries a known gap that the canonical
+  `.dockerignore` states in its own comment, since consuming repos receive the
+  file and not the tracker: the directory is created in the agent's working
+  directory, so a repo running agents in subdirectories still ships
+  `services/api/.claude/` and must add its own anchored entry there.
+
+- **A plain `docker build .` of a clone stamps the version that
+  `git describe --tags --always` gives**, derived from the `.git` in the build
+  context as the canonical `Dockerfile` above shows. Without its failure check,
+  a missing `git` or an unreadable checkout would leave `-X main.Version=` empty
+  and the build would still exit 0. `script/docker` and `script/cibuild` pass
+  the version they compute on the host; it takes precedence. They do this
+  byte-identically across repos:
+
+    ```sh
+    # Own line: a failing command substitution inside an argument does not
+    # trip `set -e`, so the inline form degrades to an empty constant.
+    version="$(git describe --tags --always --dirty 2>/dev/null || true)"
+    [ -n "$version" ] || version="unknown"
+    docker build --no-cache \
+        --build-arg VERSION="$version" \
+        -t "$(script/projectname)" .
+    ```
+
+    `--always` makes an untagged repo yield an abbreviated commit hash rather
+    than failing, and the `[ -n "$version" ]` line is the single place the
+    fallback is applied — a live check that fires on a build from an export with
+    no `.git` and on a repository with no commits yet. Do not fold it into the
+    substitution as `|| echo unknown`, which makes the guard unreachable. The
+    Dockerfile's side is `ARG VERSION` in the stage that compiles, declared
+    there because `ARG` is stage-scoped; passing `VERSION` to a repo whose
+    Dockerfile declares no such `ARG` is ignored and costs nothing, which is why
+    the scripts stay byte-identical. One consequence for CI: the standard
+    checkout action clones shallow and fetches no tags, so a repo that embeds a
+    tag-derived version must set `fetch-depth: 0` on its checkout step.
+
+- **Verify `.dockerignore` by enumerating the image, not by reading the
+  patterns.** Plant files at the root _and_ at least two directories deep, build
+  a probe image that does `COPY . .`, and list what actually landed
+  (`docker run --rm --entrypoint find IMAGE /app`). The `transferring context`
+  size is not a substitute: a nested secret is a few bytes, and BuildKit
+  transfers only the delta from the previous build.
 
 - **No build artifacts in version control.** Code-derived data (compiled
   bundles, minified output, generated assets) must never be committed to the
@@ -258,9 +476,56 @@ style conventions are in separate documents:
 - Make all changes on a feature branch. You can do whatever you want on a
   feature branch.
 
-- `.golangci.yml` is standardized and must _NEVER_ be modified by an agent, only
-  manually by the user. Fetch from
-  `https://git.eeqj.de/sneak/prompts/raw/branch/main/.golangci.yml`.
+- `.golangci.yml` is standardized. The vendored copy in a consuming repo must
+  _NEVER_ be modified by an agent: fetch it from
+  `https://git.eeqj.de/sneak/prompts/raw/branch/main/.golangci.yml` and keep it
+  byte-identical, so that no repo can quietly loosen its own linting. Linter
+  configuration changes are made to the canonical copy in the `prompts` repo and
+  reach consuming repos by re-vendoring; an agent may open a PR against
+  canonical, which only the user merges. One list is exempt from byte-identity,
+  because it cannot be written once for every repo: the `deny` list of the
+  `test-support` depguard rule, where a repo names its own test-support packages
+  by full import path. A repo adds entries there and changes nothing else, and a
+  re-vendor carries its entries forward. The canonical golangci-lint version is
+  v2.14.0 (released 2026-09-24), pinned as the digest of the lint phase's base
+  image
+  (`golangci/golangci-lint@sha256:ad862ba6b3798cbe0fd9fd7408d498fd74fbd2623a92406b2fd3898faf0bf98f`,
+  which reports `2.14.0 built with go1.27.0 from 114493f9`). A module's `go`
+  directive must not name a newer Go minor version than the one golangci-lint
+  was built with, or golangci-lint refuses to lint it: this release lints
+  `go 1.27.1` but not `go 1.28`. That digest is the only pin, since no repo
+  installs golangci-lint on the host. A repo sets the lint phase digest to the
+  one named here and re-vendors `.golangci.yml` in the same commit, whichever of
+  the two prompted the change: the canonical copy can name linters that an older
+  golangci-lint rejects, and a newer golangci-lint can add linters that
+  `default: all` switches on until the canonical copy disables them.
+
+- **`script/bootstrap` installs a pinned tool by comparing versions, never by
+  testing presence.** An `if ! command -v <tool>; then install; fi` guard tests
+  `PATH` only, so on an already-provisioned machine the pin is inert and a
+  version bump is a silent no-op — while the Dockerfile, installing into a clean
+  image, gets the pinned version, so a local `make check` and `make docker` can
+  disagree about what the tool even is. The canonical form:
+    - compares the installed version against the pin over the **whole** version
+      token; a parser that stops at the first `-` reports `2.12.2` for a host
+      running `2.12.2-rc1` and skips the install;
+    - treats absent, non-zero, empty or unrecognised `--version` output as a
+      mismatch, so the failure direction is a redundant install and never a
+      skipped one;
+    - after installing, re-resolves the binary the way callers do — `hash -r`,
+      then through `PATH`, not through the directory the installer wrote to —
+      and fails naming the resolved path, since an install that a shadowing
+      binary hides succeeds while changing nothing any caller sees;
+    - is actually called, and prints the version on both success paths: a
+      function defined and never invoked has the same exit status and the same
+      empty output as one that worked.
+
+    Keep it POSIX sh: no arrays, no `[[`, no `grep -P`.
+
+    A Go tool a repo needs on the host is installed with `go install` pinned to
+    a commit hash (`go install <package>@<commit hash>`). It is never tracked as
+    a `go.mod` tool dependency or through a `tools.go` file, either of which
+    pulls the tool's own dependencies into the repo's `go.mod` and `go.sum`.
 
 - When pinning images or packages by hash, add a comment above the reference
   with the version and date (YYYY-MM-DD).
@@ -374,12 +639,14 @@ style conventions are in separate documents:
   settings.
 
 - Avoid putting files in the repo root unless necessary. Root should contain
-  only project-level config files (`README.md`, `Makefile`, `Dockerfile`,
-  `LICENSE`, `.gitignore`, `.editorconfig`, `REPO_POLICIES.md`, and
-  language-specific config). Everything else goes in a subdirectory. Canonical
-  subdirectory names:
+  only project-level config files (`README.md`, `AGENTS.md`, `Makefile`,
+  `Dockerfile`, `LICENSE`, `.gitignore`, `.editorconfig`, `REPO_POLICIES.md`,
+  and language-specific config). Everything else goes in a subdirectory.
+  Canonical subdirectory names:
     - `bin/` — executable scripts and tools
-    - `cmd/` — Go command entrypoints
+    - `cmd/` — Go command entrypoints; thin only: one `main.go` per binary whose
+      body is a single call into `internal/` or `pkg/`, no project logic in
+      `cmd/`
     - `configs/` — configuration templates and examples
     - `deploy/` — deployment manifests (k8s, compose, terraform)
     - `docs/` — documentation and markdown (README.md stays in root)
@@ -406,3 +673,7 @@ style conventions are in separate documents:
     - Go: `go.mod`, `go.sum`, `.golangci.yml`
     - JS: `package.json`, `yarn.lock`, `.prettierrc`, `.prettierignore`
     - Python: `pyproject.toml`
+
+- Guidance for coding agents lives in one `AGENTS.md` at the repository root. It
+  is never committed under a file or directory named after one agent tool, such
+  as `CLAUDE.md` or `.claude/`, and never split into separate memory files.

TODO.md

@@ -16,12 +16,55 @@ Docker image, and the Gitea workflow `.gitea/workflows/check.yml` runs
 
 # Next Step
 
-Decide whether the repo moves to the layout `REPO_POLICIES.md` gives, with
-`backend/` no longer repeating files from the root
-([#30](https://git.eeqj.de/sneak/netwatch/issues/30)).
+Run `make frontend-viewport-test` in CI as its own step; it is not part of
+`make check`, as it needs Docker and takes minutes.
 
 # Completed Steps
 
+- 2026-10-14: changing the interval no longer drops the samples not yet reported
+  to the backend ([#124](https://git.eeqj.de/sneak/netwatch/issues/124)). The
+  interval menu resets each host with the new `HostState.reset`, which moves the
+  history's entries to `clearedHistory`, keeping the last 100 of all it has
+  cleared, and `buildReport` reads both, so the next report has the samples
+  recorded before the change that no report has delivered. Until its next check,
+  such a host is sent with the status of its last check, not `pending`. The
+  page's history still starts over, and the per-host marks still leave out of a
+  report the samples a delivered one had. Unit tests reset a host as the
+  interval menu does and find its unreported samples in the next report, and
+  only the last 100 after more were cleared; `web/src/main.js` now exports
+  `Reporter` for them
+- 2026-10-14: the repo has the layout `REPO_POLICIES.md` gives
+  ([#30](https://git.eeqj.de/sneak/netwatch/issues/30)). The Go module is at the
+  root (`go.mod`, `go.sum`, `.golangci.yml`, `cmd/netwatch-server/`,
+  `internal/`), so its path `sneak.berlin/go/netwatch` names the repository.
+  `go.mod` ignores `node_modules/`, where npm packages can ship `.go` files that
+  `make tidy` would otherwise read as this module's packages. The page's source
+  is in `web/` (`index.html`, `src/`), which `vite.config.js` makes Vite's root;
+  the build still goes to `dist/`. `nginx.conf` and `security-headers.conf` are
+  in `configs/`. `backend/` is gone: its `LICENSE` and `.dockerignore` are
+  deleted, its `.gitignore` entries are in the root one, its `README.md` is
+  folded into the root `README.md`, and its scripts into the root `script/`:
+  `script/build` builds the server binary after the frontend, `script/run` and
+  `script/clean` came from `backend/script/`, and `make test`, `make lint`,
+  `make fmt` and `make fmt-check` do what its `test`, `lint`, `fmt` and
+  `fmt-check` did. `script/bootstrap` no longer installs gcc, which only the
+  host Go tests needed. The image and the page are unchanged
+- 2026-10-07: the files shared from `sneak/prompts` are its copies at commit
+  `dd4027b` ([#113](https://git.eeqj.de/sneak/netwatch/issues/113)), with this
+  repository's own entries after the shared content in `.gitignore`,
+  `.dockerignore` and `.editorconfig`. `make lint` and `make test` each build
+  one phase of `Dockerfile` without the cache: `lint` runs golangci-lint v2.14.0
+  over `backend/` and, through the `frontend-lint` stage, eslint; `test` runs
+  the Go tests on the Debian Go image and, through the `frontend` stage, the
+  frontend's unit tests and build. The builder stage waits on both, and without
+  a `VERSION` build argument takes the version from `git describe` on the `.git`
+  in the build context. Neither linter nor the tests run on the host for
+  `make check`; `backend/script/lint` runs the root one, and
+  `backend/.golangci.yml` is no longer checked against a sha256. prettier
+  formats only the JavaScript, CSS, HTML and Markdown, so the shared
+  `.golangci.yml` stays as fetched. `script/fmt` and `script/fmt-check` put
+  `~/.local/bin` on `PATH`, which the shared workflow no longer does.
+  `script/frontend-lint` and `script/frontend-check` are gone
 - 2026-10-07: the six Hetzner targets answer again, and failed checks are
   written to the browser console
   ([#114](https://git.eeqj.de/sneak/netwatch/issues/114)). The Hetzner
@@ -400,8 +443,6 @@ Decide whether the repo moves to the layout `REPO_POLICIES.md` gives, with
 
 # Future Steps
 
-- Run `make frontend-viewport-test` in CI as its own step; it is not part of
-  `make check`, as it needs Docker and takes minutes
 - A backend test that posts a report to `POST /api/v1/reports` and checks the
   compressed file it is written to
 - A backend route that decompresses the stored reports and answers queries on

backend/.dockerignore

@@ -1,2 +0,0 @@
-node_modules
-.DS_Store

backend/.gitignore

@@ -1,6 +0,0 @@
-/netwatch-server
-*.log
-*.out
-*.test
-.env
-data/

backend/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 @sneak (https://sneak.berlin)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

backend/Makefile

@@ -1,30 +0,0 @@
-# Thin shims; the implementations live in backend/script/ (see the
-# Entrypoints section of README.md). There is no check, hooks or docker
-# target here: the root Makefile's check covers this directory, its
-# hooks target installs the repo's only pre-commit hook, and its docker
-# target builds the one image, which contains this backend.
-
-.PHONY: all build test lint fmt fmt-check run clean
-
-all: build
-
-build:
-	@script/build
-
-test:
-	@script/test
-
-lint:
-	@script/lint
-
-fmt:
-	@script/fmt
-
-fmt-check:
-	@script/fmt-check
-
-run:
-	@script/run
-
-clean:
-	@script/clean

backend/README.md

@@ -1,231 +0,0 @@
-netwatch-server is an MIT-licensed Go HTTP backend by
-[@sneak](https://sneak.berlin) that receives telemetry reports from the NetWatch
-SPA and persists them as zstd-compressed JSONL files on disk.
-
-## Getting Started
-
-From this directory:
-
-```bash
-# Build and run locally
-make run
-```
-
-From the repo root, whose `Dockerfile` builds the one image that ships this
-backend behind nginx (see [Container image](#container-image)):
-
-```bash
-# Run tests, lint, and format check over the frontend and this backend
-make check
-
-# Build the image: nginx, the frontend and this backend
-make docker
-docker run -p 8080:8080 netwatch
-```
-
-## Entrypoints
-
-This directory follows the same
-[Scripts to Rule Them All](https://github.com/github/scripts-to-rule-them-all)
-pattern as the repo root: the targets in `backend/Makefile` are thin shims over
-`backend/script/`. The root `Dockerfile` runs them, and the root scripts call
-`test`, `fmt` and `fmt-check`:
-
-- `script/build` — compile the static `netwatch-server` binary with its version
-  stamped in. The version is `VERSION` from the environment; when that is unset
-  or empty, it falls back to `git describe` inside a git checkout, then to `dev`
-- `script/test` — run the Go tests with the race detector and coverage. Go's
-  `-timeout 30s` bounds the tests, not their compile. If they fail, they run
-  again with `-v` for the details, and the script fails. The race detector needs
-  a C compiler
-- `script/lint` — check `.golangci.yml` against its pinned sha256, then run
-  golangci-lint. It runs inside the golangci-lint image of the lint stage of the
-  root `Dockerfile`; from a checkout, run `make lint` at the repo root, which
-  builds that stage
-- `script/fmt` — format the Go sources (writes)
-- `script/fmt-check` — check Go formatting (read-only)
-- `script/run` — build and run the server locally
-- `script/clean` — remove build artifacts
-
-There is no `check`, `hooks` or `docker` target here: the root `make check`
-covers this directory, the root `make hooks` installs the repo's only pre-commit
-hook, and the root `make docker` builds the image that contains this backend.
-
-## Rationale
-
-The NetWatch frontend collects latency measurements from the browser but has no
-way to persist or aggregate them. This backend provides a minimal
-`POST /api/v1/reports` endpoint that buffers incoming reports in memory and
-flushes them to compressed files on disk for later analysis.
-
-## Design
-
-The server is structured as an `fx`-wired Go application under
-`cmd/netwatch-server/`. Internal packages in `internal/` follow standard Go
-project layout:
-
-- **`config`**: Loads configuration from environment variables and config files
-  via Viper.
-- **`handlers`**: HTTP request handlers for the API (health check, report
-  ingestion).
-- **`reportbuf`**: In-memory buffer that accumulates JSONL report lines and
-  flushes to zstd-compressed files when the buffer reaches 10 MiB or every 60
-  seconds.
-- **`server`**: Chi-based HTTP server with middleware wiring and route
-  registration.
-- **`healthcheck`**, **`middleware`**, **`logger`**, **`globals`**: Supporting
-  infrastructure.
-
-### Configuration
-
-| Variable               | Default              | Description                                                                                              |
-| ---------------------- | -------------------- | -------------------------------------------------------------------------------------------------------- |
-| `BIND_ADDRESS`         | empty                | IP address to listen on; empty listens on every interface                                                |
-| `PORT`                 | `8080`               | HTTP listen port                                                                                         |
-| `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`      | 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
-`127.0.0.1/32,::1/128,10.0.0.0/8,172.16.0.0/12,192.168.0.0/16`. The loopback
-entries cover a reverse proxy on the same host. A request whose direct peer is
-outside this set has its forwarded headers ignored, and the direct peer is
-logged and rate-limited instead. The container image does not use this default;
-see [Container image](#container-image).
-
-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.
-
-### Container image
-
-The root `Dockerfile` builds one image in which nginx listens on the public port
-8080, serves the frontend, and proxies `/api/`, `/.well-known/healthcheck` and
-`/metrics` to this server. The image's entrypoint, `bin/entrypoint.sh`, starts
-the server as user `netwatch` (uid 1000) with `BIND_ADDRESS=127.0.0.1` and
-`PORT=8081`, so only nginx reaches it, and with `TRUSTED_PROXIES=127.0.0.1/32`,
-so it takes the client address nginx passes on and no other. `DATA_DIR` is
-`/data/reports`, on the `/data` volume; before starting the server, the
-entrypoint creates it and gives it and `/data` to `netwatch` with
-`netwatch-server prepare-data-dir`, which acts on nothing outside `/data`. nginx
-replaces the security headers this server sets with those in the root
-`security-headers.conf`, so those are what clients of the image see.
-
-The container's own `TRUSTED_PROXIES` goes to nginx instead: IP addresses or
-CIDRs, separated by commas, of the reverse proxies in front of the container.
-nginx takes the client address from `X-Forwarded-For` only on a request from one
-of them. Unset or empty, nginx trusts no proxy, and the client address is the
-one each request comes from, so every client behind a proxy shares one rate
-limit. An entry that is not an IP address or CIDR, such as a hostname or
-`1.2.3`, stops the container at start with an error naming `TRUSTED_PROXIES`:
-the entrypoint checks each entry with `netwatch-server check-cidr`, which parses
-it as this server parses its own `TRUSTED_PROXIES`.
-
-### Report storage
-
-Reports are written as `reports-<timestamp>-<number>.jsonl.zst` files in
-`DATA_DIR`. The timestamp is in UTC to the millisecond, so the names sort by
-time. The number starts at 1 when the server starts and goes up by one for each
-file the server starts to write, so two files written in the same millisecond
-still get different names. A failed write uses up its number and leaves a gap in
-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.
-Each file contains one JSON object per line, compressed with zstd. Files are
-created with `O_EXCL` to prevent overwrites.
-
-### Report limits
-
-`POST /api/v1/reports` takes reports from anyone who can reach it, without
-credentials, so it is bounded instead. Both refusals below answer with the same
-`{"status":"error"}` body as any other error.
-
-- **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
-  count, fading out over the current one, so an address is sure never to be
-  refused only while it sends at most half of `REPORTS_PER_MINUTE` in any 60
-  seconds. The page sends one report a minute from each open tab, so the default
-  of 60 refuses nothing from up to 30 tabs behind one address, such as a
-  household or an office sharing it, however their reports bunch up. Report
-  responses also carry `X-RateLimit-Limit`, `X-RateLimit-Remaining` and
-  `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;
-  those lost to a failed write stop counting, and the part of its file written
-  is removed. When a report would take the total past the cap, the oldest report
-  files are deleted to make room, and each deletion is logged with the file's
-  name and size; a file still being written is never deleted. A report is
-  refused with 507, and nothing of it is stored, only when the reports waiting
-  to be written fill the cap on their own, and then no file is deleted. At
-  start, report files past the cap, as after lowering it, are deleted the same
-  way. So the cap is how much of the newest reports is kept: the default of 1
-  GiB is small enough for any host; set it to the space you can give `DATA_DIR`.
-
-### CORS
-
-The page calls the API from the origin it is served from, so by default the
-server sends no CORS headers, and browsers let no other origin's pages call it.
-To serve the page from elsewhere, list that origin in `CORS_ALLOWED_ORIGINS`
-(for example `https://netwatch.example.com`); pages from a listed origin may
-`GET` and `POST` with a `Content-Type` header. Each entry must be a plain
-origin, `scheme://host` with an optional `:port`, as browsers send it: no path,
-not even a trailing `/`, and no `*`. Any other entry stops the server from
-starting, with an error naming `CORS_ALLOWED_ORIGINS`.
-
-### Metrics
-
-With both `METRICS_USERNAME` and `METRICS_PASSWORD` set, the server serves
-Prometheus metrics at `GET /metrics` to requests with those as their basic auth
-credentials, and answers any other with 401. For each request that reaches the
-health check or `POST /api/v1/reports`, those the rate limit refuses included,
-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, 405
-for a method its route does not take, or 413 for declaring a body length over
-the 1 MiB limit. A report whose body goes over the limit without declaring its
-length reaches the route, is answered 413 there, and is recorded with that
-status. 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. With neither set, nothing
-is recorded and `/metrics` answers 404. One without the other stops the server
-from starting, with an error naming both; so does a `METRICS_USERNAME`
-containing `:`, which basic auth cannot carry, with an error naming it.
-
-`/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
-minute, whatever their credentials. Past that it gets 429 with
-`Retry-After: 60`, and its credentials are not checked. The minute slides as it
-does for reports (see [Report limits](#report-limits)), so a scraper polling
-every 2 seconds or less often is never refused. This allowance is apart from the
-one for reports.
-
-### Sentry
-
-With `SENTRY_DSN` set, the server sends its errors to that Sentry project: each
-panic in a handler is reported there, under the release `netwatch-server-`
-followed by the server's version, and the request still gets 500 from the
-server's panic recovery. On shutdown the server waits up to 2 seconds for Sentry
-to finish sending. A DSN Sentry refuses stops the server from starting, with an
-error naming `SENTRY_DSN`. With it empty, Sentry is not set up, and nothing is
-sent to it.
-
-## TODO
-
-The to-do list, this backend's open work included, is [TODO.md](../TODO.md) at
-the repo root.
-
-## License
-
-MIT. See [LICENSE](LICENSE).
-
-## Author
-
-[@sneak](https://sneak.berlin)

backend/script/build

@@ -1,21 +0,0 @@
-#!/bin/sh
-# script/build: compile the static netwatch-server binary into the
-# backend project root, with its version stamped in.
-set -eu
-
-ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
-
-main() {
-    cd "$ROOT"
-
-    # VERSION comes from the environment (the root Dockerfile passes its
-    # ARG VERSION in). Unset or empty, it is git describe, or "dev" where
-    # there is no git or no repository history.
-    version="${VERSION:-$(git describe --always --dirty 2>/dev/null || echo dev)}"
-
-    CGO_ENABLED=0 go build -trimpath \
-        -ldflags "-s -w -X main.Version=$version" \
-        -o netwatch-server ./cmd/netwatch-server/
-}
-
-main "$@"

backend/script/clean

@@ -1,12 +0,0 @@
-#!/bin/sh
-# script/clean: remove build artifacts.
-set -eu
-
-ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
-
-main() {
-    cd "$ROOT"
-    rm -f netwatch-server
-}
-
-main "$@"

backend/script/fmt

@@ -1,12 +0,0 @@
-#!/bin/sh
-# script/fmt: format the Go sources (writes).
-set -eu
-
-ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
-
-main() {
-    cd "$ROOT"
-    go fmt ./...
-}
-
-main "$@"

backend/script/fmt-check

@@ -1,18 +0,0 @@
-#!/bin/sh
-# script/fmt-check: check Go formatting (read-only). Same scope as
-# script/fmt, but fails instead of writing.
-set -eu
-
-ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
-
-main() {
-    cd "$ROOT"
-    unformatted="$(gofmt -l .)"
-    if [ -n "$unformatted" ]; then
-        echo "Files not formatted:" >&2
-        echo "$unformatted" >&2
-        exit 1
-    fi
-}
-
-main "$@"

backend/script/lint

@@ -1,50 +0,0 @@
-#!/bin/sh
-# script/lint: run golangci-lint over the backend. This runs inside the
-# lint stage of the root Dockerfile, whose digest-pinned golangci-lint
-# image provides the linter; nothing installs golangci-lint on the host.
-# From a checkout, run `make lint` at the repo root, which builds that
-# stage.
-#
-# .golangci.yml is standardized org-wide and must never be edited here
-# (REPO_POLICIES.md). Its last silent drift replaced the v2 schema with
-# v1 keys, which left every threshold in the file inert while the build
-# stayed green. So the file is first checked against the canonical
-# copy's sha256: a local comparison, no network, nothing unpinned.
-set -eu
-
-ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
-
-# The sha256 of the org standard .golangci.yml. When that file changes in
-# sneak/prompts and is copied here again, this changes with it.
-GOLANGCI_CONFIG_SHA256="a79b63a254602a5318db5d0e9a06bc71b84bf0c1d896305229d8bfed1d1b1776"
-
-main() {
-    cd "$ROOT"
-    if [ ! -f .golangci.yml ]; then
-        echo "backend/.golangci.yml is missing. Copy the org standard verbatim" >&2
-        echo "from https://git.eeqj.de/sneak/prompts/raw/branch/main/.golangci.yml" >&2
-        exit 1
-    fi
-    actual="$(sha256sum .golangci.yml | cut -d' ' -f1)"
-    if [ -z "$actual" ]; then
-        echo "sha256sum is missing or printed no hash, so" >&2
-        echo "backend/.golangci.yml could not be checked." >&2
-        exit 1
-    fi
-    if [ "$actual" != "$GOLANGCI_CONFIG_SHA256" ]; then
-        echo "backend/.golangci.yml does not match GOLANGCI_CONFIG_SHA256" >&2
-        echo "in backend/script/lint." >&2
-        echo "  expected $GOLANGCI_CONFIG_SHA256" >&2
-        echo "  actual   $actual" >&2
-        echo "Compare it with the org standard," >&2
-        echo "https://git.eeqj.de/sneak/prompts/raw/branch/main/.golangci.yml" >&2
-        echo "- If they differ, it was edited here: restore the org standard" >&2
-        echo "  verbatim. Do not edit it." >&2
-        echo "- If they are the same, the org standard changed: set" >&2
-        echo "  GOLANGCI_CONFIG_SHA256 in backend/script/lint to the actual hash." >&2
-        exit 1
-    fi
-    golangci-lint run ./...
-}
-
-main "$@"

backend/script/test

@@ -1,20 +0,0 @@
-#!/bin/sh
-# script/test: run the backend test suite with the race detector and
-# coverage. Go's own -timeout bounds the tests and not their compile,
-# so a cold build cache cannot fail it. The race detector needs cgo,
-# and so a C compiler. If the tests fail, they run again with -v for
-# the details, and the script fails even if that run passes.
-set -eu
-
-ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
-
-main() {
-    cd "$ROOT"
-    go test -timeout 30s -race -cover ./... || {
-        echo "--- Rerunning with -v for details ---"
-        go test -timeout 30s -race -v ./...
-        exit 1
-    }
-}
-
-main "$@"

bin/entrypoint.sh

@@ -35,8 +35,8 @@ 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, so
-# unset or empty, it trusts no one. nginx.conf includes the file written
-# here, one set_real_ip_from line per entry.
+# unset or empty, it trusts no one. 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
@@ -76,10 +76,10 @@ stop_requested=""
 trap 'stop_requested=yes' TERM INT
 
 # netwatch-server runs as the netwatch user and listens on loopback
-# only, on a port other than the public one; nginx.conf proxies to this
-# address. Its only client is nginx, so it takes the client address
-# nginx passes on from 127.0.0.1 alone, whatever TRUSTED_PROXIES the
-# container has. The netwatch user has no login shell, hence -s
+# only, on a port other than the public one; configs/nginx.conf proxies
+# to this address. Its only client is nginx, so it takes the client
+# address nginx passes on from 127.0.0.1 alone, whatever TRUSTED_PROXIES
+# the container has. The netwatch user has no login shell, hence -s
 # /bin/sh. busybox su replaces itself with the command instead of
 # staying on as its parent, so $! is the server's own PID.
 BIND_ADDRESS=127.0.0.1 PORT=8081 TRUSTED_PROXIES=127.0.0.1/32 \
@@ -88,8 +88,8 @@ backend=$!
 
 # nginx starts through the nginx image's own entrypoint, which applies
 # the image's start-up configuration and then replaces itself with
-# nginx. Part of that start-up configuration renders nginx.conf into
-# conf.d with nginx listening on PORT. NGINX_ENVSUBST_FILTER limits
+# nginx. Part of that start-up configuration renders configs/nginx.conf
+# into conf.d with nginx listening on PORT. NGINX_ENVSUBST_FILTER limits
 # that rendering to PORT: a variable nginx itself uses, such as $uri,
 # would otherwise be replaced by an environment variable of the same
 # name.

configs/nginx.conf

@@ -53,7 +53,7 @@ server {
 
     # netwatch-server sets the same security headers on its own
     # responses. Its copies are dropped so that each header goes out
-    # once, as security-headers.conf sets it.
+    # once, as configs/security-headers.conf sets it.
     proxy_hide_header Strict-Transport-Security;
     proxy_hide_header Content-Security-Policy;
     proxy_hide_header X-Frame-Options;

configs/security-headers.conf

@@ -1,5 +1,5 @@
 # The security headers REPO_POLICIES.md requires on every response.
-# nginx.conf includes this file, which Dockerfile copies to
+# configs/nginx.conf includes this file, which Dockerfile copies to
 # /etc/nginx/security-headers.conf. always sends each header on error
 # responses too.
 
@@ -8,11 +8,11 @@ add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" alway
 # Scripts and styles load only from the page's own origin. Inline ones
 # are blocked, style attributes in markup included, so style elements
 # through classes or element.style. data: images are for the favicon
-# in index.html. connect-src is * because the browser checks each probe in
-# src/main.js against it, and also every redirect the probe follows,
-# and several of those hosts redirect to others; a list of hosts here
-# would block those probes. It also covers the reports the page sends
-# to its own origin.
+# in web/index.html. connect-src is * because the browser checks each
+# probe in web/src/main.js against it, and also every redirect the probe
+# follows, and several of those hosts redirect to others; a list of
+# hosts here would block those probes. It also covers the reports the
+# page sends to its own origin.
 add_header Content-Security-Policy "default-src 'self'; connect-src *; img-src 'self' data:; object-src 'none'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'" always;
 
 add_header X-Frame-Options DENY always;

eslint.config.js

@@ -1,5 +1,5 @@
 // eslint's recommended rules over every JavaScript file in the repo.
-// script/frontend-lint runs it, in the frontend-lint stage of Dockerfile.
+// make lint runs it, in the frontend-lint stage of Dockerfile.
 import js from "@eslint/js";
 import globals from "globals";
 import { defineConfig } from "eslint/config";
@@ -8,7 +8,7 @@ export default defineConfig([
     js.configs.recommended,
     {
         // The page, and facts.js, which the viewport test runs inside it.
-        files: ["src/**/*.js", "test/viewport/facts.js"],
+        files: ["web/src/**/*.js", "test/viewport/facts.js"],
         languageOptions: {
             globals: {
                 ...globals.browser,

go.mod

@@ -2,6 +2,9 @@ module sneak.berlin/go/netwatch
 
 go 1.25.5
 
+// npm packages can ship .go files, which ./... and all would include.
+ignore ./node_modules
+
 require (
 	github.com/99designs/basicauth-go v0.0.0-20230316000542-bf6f9cbbf0f8
 	github.com/getsentry/sentry-go v0.49.0

internal/config/config.go

@@ -29,8 +29,8 @@ import (
 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; backend/README.md gives the
-// reasons for these values.
+// Default limits on stored reports; README.md gives the reasons for
+// these values.
 const (
 	defaultReportsPerMinute = 60
 	defaultDataDirMaxBytes  = 1 << 30 // 1 GiB

internal/middleware/middleware_test.go

@@ -343,7 +343,7 @@ func TestLoggingCutsRequestStringsToBound(t *testing.T) {
 		http.MethodGet, "/"+long, http.NoBody)
 	req.Header.Set("User-Agent", long)
 	req.Header.Set("Referer", long)
-	req.Header.Set("X-Request-Id", long)
+	req.Header.Set("X-Request-ID", long)
 
 	handler.ServeHTTP(httptest.NewRecorder(), req)
 

script/bootstrap

@@ -6,19 +6,18 @@
 # used directly if it is at least NODE_MIN_VERSION; otherwise it is
 # installed at a pinned version via nvm (installing nvm itself first,
 # from a hash-verified release archive, never curl | sh). Go, with its
-# gofmt, is used directly if it is at least the version backend/go.mod
-# asks for; otherwise the pinned Go release is installed from its
-# hash-verified archive.
+# gofmt, is used directly only if it is exactly GO_VERSION; otherwise
+# that release is installed from its hash-verified archive.
 #
 # What this script installs outside the system package manager lives
 # under $HOME and is linked into ~/.local/bin, where make and the git
 # hook find it once that directory is on PATH. Nothing in ~/.local/bin
 # that this script did not create is ever replaced.
 #
-# golangci-lint is not installed: make lint runs it in Docker, which
-# this script does not install either.
+# golangci-lint is not installed: make lint runs it in Docker, as make
+# test runs the tests, and this script does not install Docker either.
 #
-# Unlike the org model: Go and gcc for backend/, a newer node for eslint.
+# Unlike the org model: Go for the backend, a newer node for eslint.
 set -eu
 
 ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
@@ -186,20 +185,30 @@ ensure_yarn() {
 }
 
 # go_ok: the go on PATH has its gofmt beside it (a Go release ships the
-# two together) and is at least the version backend/go.mod asks for.
-# GOTOOLCHAIN=local makes an older go fail here instead of fetching a
-# newer toolchain for itself.
+# two together) and go version reports exactly GO_VERSION, compared over
+# the whole version, not a prefix of it. A go that fails or prints
+# anything else does not pass. GOTOOLCHAIN=local makes go report itself
+# rather than a toolchain it would fetch.
 go_ok() {
     if missing go; then return 1; fi
     [ -x "$(dirname "$(command -v go)")/gofmt" ] || return 1
-    (cd "$ROOT/backend" && GOTOOLCHAIN=local go list -m >/dev/null 2>&1)
+    version="$(GOTOOLCHAIN=local go version 2>/dev/null)" || return 1
+    case "$version" in
+        "go version go$GO_VERSION "*) return 0 ;;
+        *) return 1 ;;
+    esac
 }
 
 # ensure_go: unless go_ok, install GO_VERSION and link its go and gofmt.
 # They are linked on every run that needs them, so a deleted link is put
 # back, and the archive is unpacked again if either binary is missing.
+# Afterwards go is looked up through PATH again and must pass go_ok, so
+# another go that hides the link stops bootstrap.
 ensure_go() {
-    if go_ok; then return 0; fi
+    if go_ok; then
+        echo "bootstrap: using $(GOTOOLCHAIN=local go version)"
+        return 0
+    fi
     go_dir="$TOOLCHAIN/go-$GO_VERSION"
     if [ ! -x "$go_dir/bin/go" ] || [ ! -x "$go_dir/bin/gofmt" ]; then
         # sha256 of each archive, from https://go.dev/dl/?mode=json
@@ -240,6 +249,13 @@ ensure_go() {
     fi
     link_bin "$go_dir/bin/go" go
     link_bin "$go_dir/bin/gofmt" gofmt
+    hash -r
+    if ! go_ok; then
+        echo "bootstrap: after installing go $GO_VERSION in $go_dir," >&2
+        echo "  the go on PATH, $(command -v go), is not it or has no gofmt" >&2
+        exit 1
+    fi
+    echo "bootstrap: installed $(GOTOOLCHAIN=local go version)"
 }
 
 main() {
@@ -256,23 +272,17 @@ main() {
 
     if missing make; then pkg_install gnumake make make make; fi
     if missing git; then pkg_install git git git git; fi
-    # The race detector in make test needs cgo, which Go turns on only
-    # when it finds its C compiler, gcc on Linux. apt and apk ship the C
-    # library headers apart from gcc.
-    if missing gcc; then
-        pkg_install gcc "gcc libc6-dev" gcc "gcc musl-dev"
-    fi
 
     ensure_node
     ensure_yarn
     yarn install --frozen-lockfile
 
     ensure_go
-    (cd "$ROOT/backend" && go mod download)
+    go mod download
 
     if missing docker; then
-        echo "bootstrap: docker not found; make lint, and so make check" >&2
-        echo "  and the pre-commit hook, need it to run the linters" >&2
+        echo "bootstrap: docker not found; make test and make lint, and so" >&2
+        echo "  make check and the pre-commit hook, need it" >&2
     fi
     if [ -n "$path_hint" ] && [ -d "$BIN_DIR" ]; then
         echo "bootstrap: add $BIN_DIR to the front of your PATH, e.g." >&2

script/build

@@ -1,6 +1,7 @@
 #!/bin/sh
-# script/build: build the frontend for production into dist/. The Go
-# backend is built by backend/script/build.
+# script/build: build the frontend for production into dist/, then the
+# static netwatch-server binary into the repo root, with its version
+# stamped in.
 set -eu
 
 ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
@@ -8,6 +9,14 @@ ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
 main() {
     cd "$ROOT"
     yarn build
+
+    # VERSION comes from the environment. Unset or empty, it is git
+    # describe, or "dev" where there is no git or no repository history.
+    version="${VERSION:-$(git describe --always --dirty 2>/dev/null || echo dev)}"
+
+    CGO_ENABLED=0 go build -trimpath \
+        -ldflags "-s -w -X main.Version=$version" \
+        -o netwatch-server ./cmd/netwatch-server/
 }
 
 main "$@"

script/check

@@ -1,6 +1,8 @@
 #!/bin/sh
 # script/check: run all checks (test, lint, fmt-check). Our own
-# extension to scripts-to-rule-them-all. Must not modify any files.
+# extension to scripts-to-rule-them-all. test and lint are Docker
+# phases; fmt-check is native, because a formatter writes the working
+# tree. Must not modify any files.
 set -eu
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"

script/clean

@@ -0,0 +1,13 @@
+#!/bin/sh
+# script/clean: remove what script/build writes: dist/ and the
+# netwatch-server binary.
+set -eu
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
+
+main() {
+    cd "$ROOT"
+    rm -rf dist netwatch-server
+}
+
+main "$@"

script/fmt

@@ -1,15 +1,20 @@
 #!/bin/sh
-# script/fmt: format the whole repo (writes): prettier over everything
-# it understands, then gofmt over the Go backend.
-# The org model formats only markdown; this repo also has JS and Go.
+# script/fmt: format the whole repo (writes): prettier over the
+# JavaScript, CSS, HTML and Markdown, then gofmt over the Go sources in
+# cmd/ and internal/; not over the whole root, as node_modules/ holds
+# .go files of its own. The org model formats only markdown; this repo
+# also has JS and Go.
 set -eu
 
 ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
 
 main() {
     cd "$ROOT"
+    # script/bootstrap links the node, yarn and gofmt it installs into
+    # ~/.local/bin, which the shell that called it may not have on PATH.
+    PATH="$HOME/.local/bin:$PATH"
     "$ROOT/script/frontend-fmt"
-    "$ROOT/backend/script/fmt"
+    gofmt -l -w cmd internal
 }
 
 main "$@"

script/fmt-check

@@ -8,8 +8,16 @@ ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
 
 main() {
     cd "$ROOT"
+    # script/bootstrap links the node, yarn and gofmt it installs into
+    # ~/.local/bin, which the shell that called it may not have on PATH.
+    PATH="$HOME/.local/bin:$PATH"
     "$ROOT/script/frontend-fmt-check"
-    "$ROOT/backend/script/fmt-check"
+    unformatted="$(gofmt -l cmd internal)"
+    if [ -n "$unformatted" ]; then
+        echo "Go files not formatted:" >&2
+        echo "$unformatted" >&2
+        exit 1
+    fi
 }
 
 main "$@"

script/frontend-check

@@ -1,18 +0,0 @@
-#!/bin/sh
-# script/frontend-check: run the frontend tests and format check only.
-# This exists for the frontend stage of Dockerfile, a node image with
-# neither Go nor Docker; the Dockerfile's frontend-lint stage runs the
-# frontend linter, and its lint and builder stages gate the backend.
-# Everywhere else, use script/check, which covers the whole repo. Must
-# not modify any files.
-set -eu
-
-ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
-
-main() {
-    cd "$ROOT"
-    "$ROOT/script/frontend-test"
-    "$ROOT/script/frontend-fmt-check"
-}
-
-main "$@"

script/frontend-fmt

@@ -1,14 +1,16 @@
 #!/bin/sh
-# script/frontend-fmt: format the frontend and every other file prettier
-# understands, repo-wide (writes), the markdown in backend/ included.
-# Prettier does not read Go; backend/script/fmt formats the Go sources.
+# script/frontend-fmt: format the JavaScript, CSS, HTML and Markdown,
+# repo-wide (writes). Those are the languages REPO_POLICIES.md gives
+# prettier; the YAML is left alone, as .golangci.yml must stay the org
+# standard byte for byte. Prettier does not read Go; script/fmt runs
+# gofmt over the Go sources.
 set -eu
 
 ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
 
 main() {
     cd "$ROOT"
-    yarn prettier --write .
+    yarn prettier --write '**/*.{js,css,html,md}'
 }
 
 main "$@"

script/frontend-fmt-check

@@ -7,7 +7,7 @@ ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
 
 main() {
     cd "$ROOT"
-    yarn prettier --check .
+    yarn prettier --check '**/*.{js,css,html,md}'
 }
 
 main "$@"

script/frontend-lint

@@ -1,15 +0,0 @@
-#!/bin/sh
-# script/frontend-lint: run eslint over the frontend. This runs inside
-# the frontend-lint stage of Dockerfile, the digest-pinned node image
-# with the packages from yarn.lock. From a checkout, run `make lint`,
-# which builds that stage.
-set -eu
-
-ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
-
-main() {
-    cd "$ROOT"
-    yarn eslint .
-}
-
-main "$@"

script/frontend-test

@@ -1,7 +1,8 @@
 #!/bin/sh
-# script/frontend-test: run the frontend test suite: the unit tests in
-# test/unit/, through the test script in package.json, then the
-# production build, which fails on broken code. The tests print a dot
+# 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 in the frontend stage of Dockerfile. The tests print a dot
 # each; if any fails, they run again with every test listed, and the
 # script fails even if that run passes. NODE_OPTIONS chooses the
 # reporter because yarn adds its arguments after the test files, where
@@ -12,9 +13,9 @@ ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
 
 main() {
     cd "$ROOT"
-    NODE_OPTIONS=--test-reporter=dot timeout 30 yarn --silent run test || {
+    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 30 yarn --silent run test
+        NODE_OPTIONS=--test-reporter=spec timeout 90 yarn --silent run test
         exit 1
     }
     timeout 30 yarn build

script/frontend-viewport-test

@@ -2,11 +2,11 @@
 # script/frontend-viewport-test: verify the responsive layout of the built
 # frontend in a real browser engine.
 #
-# Builds dist/, serves it with the same nginx image and the same nginx.conf
-# the shipping container uses, points a containerised 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.
+# Builds dist/, serves it with the same nginx image and the same
+# configs/nginx.conf the shipping container uses, points a containerised
+# 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.
 #
 # Deliberately not part of script/check: it needs Docker and takes far
 # longer than the 20s budget make test has to stay inside.
@@ -61,18 +61,18 @@ main() {
     # host.
     docker network create --internal "$NETWORK" > /dev/null
 
-    # nginx.conf is a template: the image renders it over its own
+    # 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 unset. nginx.conf also includes
-    # the security headers, so the page runs under the shipped policy.
+    # writes it when TRUSTED_PROXIES is unset. It also includes the
+    # 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$' \
         -v "$ROOT/dist:/usr/share/nginx/html:ro" \
-        -v "$ROOT/nginx.conf:/etc/nginx/templates/default.conf.template:ro" \
+        -v "$ROOT/configs/nginx.conf:/etc/nginx/templates/default.conf.template:ro" \
         -v /dev/null:/etc/nginx/trusted-proxies.conf:ro \
-        -v "$ROOT/security-headers.conf:/etc/nginx/security-headers.conf:ro" \
+        -v "$ROOT/configs/security-headers.conf:/etc/nginx/security-headers.conf:ro" \
         "$SERVER_IMAGE" > /dev/null
 
     # The image's own entrypoint already exposes CDP on 9222 and passes

script/lint

@@ -1,23 +1,23 @@
 #!/bin/sh
-# script/lint: lint the whole repo: eslint over the frontend, then the Go
-# linter over backend/.
+# script/lint: run the linter. Linting is a phase of the Dockerfile and
+# this builds that phase alone; the linter is never installed or run on
+# a developer host, where a shared result cache and a host-global lock
+# make its answer untrustworthy.
 #
-# No linter runs on the host: this builds the frontend-lint and lint
-# stages of Dockerfile, the digest-pinned node and golangci-lint images.
-# The first runs eslint; the second runs the backend's fmt-check and
-# lint targets. --no-cache makes each linter really run every time
-# rather than reuse an earlier result, and each stage is built for its
-# checks alone, so no image is kept.
+# The phase is not the last stage in the file, so it is built only when
+# --target names it. --no-cache because a cached lint layer is a lint
+# that did not run. The tag makes each build replace the previous image
+# instead of leaving a dangling one behind.
 set -eu
 
-ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
+ROOT="$(cd "$SCRIPT_DIR/.." && pwd -P)"
 
 main() {
     cd "$ROOT"
-    timeout 300 docker build --no-cache --target frontend-lint \
-        --output type=cacheonly .
-    timeout 300 docker build --no-cache --target lint \
-        --output type=cacheonly .
+    docker build --no-cache \
+        --target lint \
+        -t "$("$SCRIPT_DIR/projectname")-lint" .
 }
 
 main "$@"

script/run

@@ -1,5 +1,6 @@
 #!/bin/sh
-# script/run: build and run netwatch-server locally.
+# script/run: build with script/build, then run netwatch-server locally
+# with its defaults: port 8080, reports stored in data/reports.
 set -eu
 
 ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"

script/test

@@ -1,17 +1,19 @@
 #!/bin/sh
-# script/test: run the test suite for the whole repo: the frontend at
-# the repo root, then the Go backend in backend/. Each half has its own
-# 30-second limit, and there is none around both: from a cold Go build
-# cache, compiling the backend's tests with the race detector can take
-# 30 seconds on its own, and Go's -timeout leaves the compile out.
+# script/test: run the test suite. Testing is a phase of the Dockerfile
+# and this builds that phase alone, on the same terms as script/lint:
+# --target because a phase that is not the last stage is built only when
+# named, --no-cache because a cached test layer is a test that did not
+# run, and a tag so each build replaces the previous image.
 set -eu
 
-ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
+ROOT="$(cd "$SCRIPT_DIR/.." && pwd -P)"
 
 main() {
     cd "$ROOT"
-    script/frontend-test
-    backend/script/test
+    docker build --no-cache \
+        --target test \
+        -t "$("$SCRIPT_DIR/projectname")-test" .
 }
 
 main "$@"

script/tidy

@@ -1,12 +1,12 @@
 #!/bin/sh
-# script/tidy: run go mod tidy in backend/, which adds the modules the
-# Go sources import, drops those they no longer do, and updates go.sum.
+# script/tidy: run go mod tidy, which adds the modules the Go sources
+# import, drops those they no longer do, and updates go.sum.
 set -eu
 
 ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
 
 main() {
-    cd "$ROOT/backend"
+    cd "$ROOT"
     go mod tidy
 }
 

test/unit/main.test.js

@@ -1,4 +1,4 @@
-// Unit tests for src/main.js, run with Node's built-in test runner by the
+// Unit tests for web/src/main.js, run with Node's built-in test runner by the
 // test script in package.json. Importing the module does not start the
 // page.
 
@@ -14,8 +14,9 @@ import {
     latencyClass,
     latencyHex,
     measureLatency,
+    Reporter,
     tick,
-} from "../../src/main.js";
+} 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. Each element of a host's row that
@@ -378,6 +379,98 @@ test("a check that fails in the first round, which is discarded, writes nothing
     assert.deepEqual(consoleLines("info"), []);
 });
 
+// The reports Reporter sent in this test, each as the hosts it sent.
+function reportedHosts() {
+    return fetch.mock.calls.map(
+        (call) => JSON.parse(call.arguments[1].body).hosts,
+    );
+}
+
+// In the next two tests every report is delivered, and only Target has
+// checks to report. target.reset() does to Target what the interval menu
+// does to each target.
+
+// The interval changes after the first report. The second report is sent
+// before Target's first check since then, and the third after it. A fourth
+// would hold no check the first three did not, so it is not sent.
+test("checks recorded before an interval change and not yet reported go in the next report, with the status of the last check, and no check is reported twice", async (t) => {
+    const state = new AppState([
+        { name: "Target", url: "https://target.test" },
+    ]);
+    const target = state.local[0];
+    const reporter = new Reporter(state, "client", CONFIG.reportInterval);
+    t.mock.method(globalThis, "fetch", async () => ({ ok: true }));
+
+    target.pushSample(1000, { latency: 10, error: null });
+    await reporter.flush();
+    target.pushSample(2000, { latency: 20, error: null });
+    target.pushSample(3000, { latency: null, error: "timeout" });
+    target.reset();
+    await reporter.flush();
+    target.pushSample(4000, { latency: 40, error: null });
+    await reporter.flush();
+    await reporter.flush();
+
+    const name = "Target";
+    const url = "https://target.test";
+    assert.deepEqual(reportedHosts(), [
+        [
+            {
+                name,
+                url,
+                status: "online",
+                history: [{ t: 1000, latency: 10, error: null }],
+            },
+        ],
+        [
+            {
+                name,
+                url,
+                status: "error",
+                history: [
+                    { t: 2000, latency: 20, error: null },
+                    { t: 3000, latency: null, error: "timeout" },
+                ],
+            },
+        ],
+        [
+            {
+                name,
+                url,
+                status: "online",
+                history: [{ t: 4000, latency: 40, error: null }],
+            },
+        ],
+    ]);
+    // The page's history starts over.
+    assert.deepEqual(target.history, [
+        { timestamp: 4000, latency: 40, error: null },
+    ]);
+});
+
+// The interval changes twice, after 60 checks each time, before the first
+// report. Of the 120 checks the interval menu cleared, the report has the
+// last 100 (CONFIG.maxHistoryPoints).
+test("of the checks interval changes cleared before they were reported, the next report has the last 100", async (t) => {
+    const state = new AppState([
+        { name: "Target", url: "https://target.test" },
+    ]);
+    const target = state.local[0];
+    const reporter = new Reporter(state, "client", CONFIG.reportInterval);
+    t.mock.method(globalThis, "fetch", async () => ({ ok: true }));
+
+    for (let n = 1; n <= 120; n++) {
+        target.pushSample(n * 1000, { latency: 10, error: null });
+        if (n % 60 === 0) target.reset();
+    }
+    await reporter.flush();
+
+    const sent = reportedHosts()[0][0].history;
+    assert.equal(sent.length, 100);
+    assert.equal(sent[0].t, 21000);
+    assert.equal(sent.at(-1).t, 120000);
+});
+
 // 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`, () => {

test/viewport/README.md

@@ -7,22 +7,22 @@ make frontend-viewport-test
 ```
 
 It builds `dist/`, serves it from the same digest-pinned `nginx` image and the
-same `nginx.conf` the shipping container uses, drives a digest-pinned headless
-Chrome against it over CDP, and asserts on computed layout at every viewport
-width derived from the app's own CSS. Screenshots land in `tmp/viewport/`
-alongside a `results.json`; they are artifacts for a human to look at when
-something fails, not the evidence. The assertions are the evidence.
+same `configs/nginx.conf` the shipping container uses, drives a digest-pinned
+headless Chrome against it over CDP, and asserts on computed layout at every
+viewport width derived from the app's own CSS. Screenshots land in
+`tmp/viewport/` alongside a `results.json`; they are artifacts for a human to
+look at when something fails, not the evidence. The assertions are the evidence.
 
-The target is deliberately outside `make check`: it needs Docker and takes
-minutes, and `make test` has to stay under 20 seconds.
+The target is deliberately outside `make check`: it takes minutes, and
+`make test` has to stay under 60 seconds.
 
 ## How the widths are chosen
 
 Not from a list of phone models. `viewports.js` parses the `@media` conditions
-out of `src/styles.css` and scans `src/main.js` and `index.html` for Tailwind
-responsive prefixes, then tests every breakpoint it finds at one pixel below it,
-exactly on it, and one pixel above it. A generic 375px "phone" test sails
-straight past an off-by-one at a media query boundary; `max-width: 768px`
+out of `web/src/styles.css` and scans `web/src/main.js` and `web/index.html` for
+Tailwind responsive prefixes, then tests every breakpoint it finds at one pixel
+below it, exactly on it, and one pixel above it. A generic 375px "phone" test
+sails straight past an off-by-one at a media query boundary; `max-width: 768px`
 matches _at_ 768, and the sweep pins down which side of that line each layout is
 on.
 
@@ -108,7 +108,7 @@ function of viewport width and CSS, and is covered above.
 
 Complementary layers, not two stacks. The unit tests in `test/unit/`, which
 `make test` runs with Node's built-in test runner, exercise the functions
-`src/main.js` exports in-process with no browser. This harness exercises
+`web/src/main.js` exports in-process with no browser. This harness exercises
 rendered layout in a real engine and is the only thing here that can see a media
 query. Neither replaces the other; assertions about computed styles and element
 geometry belong here, assertions about functions belong in `test/unit/`.

test/viewport/harness.js

@@ -51,7 +51,8 @@ const PROBE_DELAYS_MS = [2, 45, 123, 456, 780];
 // offline row rendering is exercised too.
 const UNREACHABLE_MODULUS = 7;
 // The gateway candidate that "answers", so gateway detection succeeds and
-// the Local Gateway row renders. Matches GATEWAY_CANDIDATES in src/main.js.
+// the Local Gateway row renders. Matches GATEWAY_CANDIDATES in
+// web/src/main.js.
 const RESPONSIVE_GATEWAY = "http://192.168.1.1";
 
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

test/viewport/viewports.js

@@ -161,26 +161,27 @@ const ANCHOR_VIEWPORTS = [
 export function deriveViewports(root) {
     const conditions = [
         ...mediaConditionsFromCss(
-            readFileSync(join(root, "src/styles.css"), "utf8"),
-            "src/styles.css",
+            readFileSync(join(root, "web/src/styles.css"), "utf8"),
+            "web/src/styles.css",
         ),
         ...mediaConditionsFromMarkup([
             {
-                path: "src/main.js",
-                text: readFileSync(join(root, "src/main.js"), "utf8"),
+                path: "web/src/main.js",
+                text: readFileSync(join(root, "web/src/main.js"), "utf8"),
             },
             {
-                path: "index.html",
-                text: readFileSync(join(root, "index.html"), "utf8"),
+                path: "web/index.html",
+                text: readFileSync(join(root, "web/index.html"), "utf8"),
             },
         ]),
     ];
 
     if (conditions.length === 0) {
         throw new Error(
-            "no responsive breakpoints found in src/styles.css, src/main.js or " +
-                "index.html — either the responsive layout was deleted or this " +
-                "derivation has stopped matching the sources",
+            "no responsive breakpoints found in web/src/styles.css, " +
+                "web/src/main.js or web/index.html — either the responsive " +
+                "layout was deleted or this derivation has stopped matching " +
+                "the sources",
         );
     }
 

vite.config.js

@@ -6,6 +6,10 @@ const commitHash = execSync("git rev-parse --short HEAD").toString().trim();
 const commitFull = execSync("git rev-parse HEAD").toString().trim();
 
 export default defineConfig({
+    // The page's source is in web/; the build still goes to dist/ at the
+    // repo root, which Dockerfile and the viewport test serve. Vite
+    // empties only an outDir inside root unless told to.
+    root: "web",
     plugins: [tailwindcss()],
     server: {
         // Proxy /api to a locally running netwatch-server so `yarn dev`
@@ -19,6 +23,8 @@ export default defineConfig({
         __COMMIT_FULL__: JSON.stringify(commitFull),
     },
     build: {
+        outDir: "../dist",
+        emptyOutDir: true,
         target: "esnext",
         minify: "esbuild",
         cssMinify: true,

web/index.html

@@ -9,7 +9,7 @@
             type="image/svg+xml"
             href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><text y='.9em' font-size='90'>📡</text></svg>"
         />
-        <!-- Linked here, not imported by src/main.js, so the unit tests can
+        <!-- Linked here, not imported by web/src/main.js, so the unit tests can
              import that module in Node, which cannot import CSS. -->
         <link rel="stylesheet" href="/src/styles.css" />
     </head>

web/src/main.js

@@ -257,6 +257,14 @@ function latencyStats(latencies) {
     };
 }
 
+// The status a check's error gives its host: "error" for a timeout,
+// "offline" for any other error, and "online" for none.
+function statusFromError(error) {
+    if (error === "timeout") return "error";
+    if (error) return "offline";
+    return "online";
+}
+
 export class HostState {
     constructor(host, pinned = false) {
         this.name = host.name;
@@ -265,6 +273,10 @@ export class HostState {
         // error }, or a round skipped while paused, { timestamp,
         // latency: null, paused: true }.
         this.history = [];
+        // The last 100 (CONFIG.maxHistoryPoints) entries the interval menu
+        // has cleared from the history, which the reporter may not have
+        // sent yet.
+        this.clearedHistory = [];
         this.lastLatency = null;
         this.status = "pending"; // 'online' | 'offline' | 'error' | 'pending'
         this.pinned = pinned;
@@ -280,9 +292,7 @@ export class HostState {
         });
         this._trim();
         this.lastLatency = result.latency;
-        if (result.error === "timeout") this.status = "error";
-        else if (result.error) this.status = "offline";
-        else this.status = "online";
+        this.status = statusFromError(result.error);
         this.consecutiveFailures = result.error
             ? this.consecutiveFailures + 1
             : 0;
@@ -293,6 +303,18 @@ export class HostState {
         this._trim();
     }
 
+    // What the interval menu does to each host: the history starts over and
+    // the host waits for its next check. The history's entries move to
+    // clearedHistory, so the reporter still sends those it has not.
+    reset() {
+        this.clearedHistory = [...this.clearedHistory, ...this.history].slice(
+            -CONFIG.maxHistoryPoints,
+        );
+        this.history = [];
+        this.lastLatency = null;
+        this.status = "pending";
+    }
+
     // The min, max, median and average latency of the checks in the history
     // that got an answer.
     historyStats() {
@@ -429,9 +451,12 @@ function getClientId() {
 
 // Build the delta report body the backend decodes, plus the new per-host
 // high-water marks. Pure function of the passed state: `hosts` is an array
-// of { name, url, status, history }, `since` maps a host url to the Unix-ms
-// timestamp of the last sample already reported for it, and `now` is a Date.
-// Only non-paused samples newer than the mark are included. Returns null
+// of { name, url, status, clearedHistory, history }, `since` maps a host url
+// to the Unix-ms timestamp of the last sample already reported for it, and
+// `now` is a Date. Only non-paused samples newer than the mark are included,
+// from clearedHistory as well as history. A host whose status is pending,
+// as the interval menu leaves it until its next check, is sent with the
+// status of its last check, which is the last sample sent. Returns null
 // when no host has an unreported sample.
 export function buildReport(hosts, clientId, now, since) {
     const reportHosts = [];
@@ -440,7 +465,7 @@ export function buildReport(hosts, clientId, now, since) {
         const mark = since.get(host.url) ?? 0;
         const samples = [];
         let high = mark;
-        for (const p of host.history) {
+        for (const p of [...host.clearedHistory, ...host.history]) {
             if (p.paused) continue;
             if (p.timestamp <= mark) continue;
             samples.push({
@@ -454,7 +479,10 @@ export function buildReport(hosts, clientId, now, since) {
         reportHosts.push({
             name: host.name,
             url: host.url,
-            status: host.status,
+            status:
+                host.status === "pending"
+                    ? statusFromError(samples.at(-1).error)
+                    : host.status,
             history: samples,
         });
         marks.set(host.url, high);
@@ -481,7 +509,7 @@ export function buildReport(hosts, clientId, now, since) {
 // Only one report is ever in flight, and it is abandoned after half the
 // interval, so a slow POST can neither overlap the next report (which would
 // carry the same samples) nor stall reporting for good.
-class Reporter {
+export class Reporter {
     constructor(state, clientId, intervalMs) {
         this.state = state;
         this.clientId = clientId;
@@ -1502,9 +1530,7 @@ async function init() {
 
             // Clear all host history and reset state
             for (const host of state.allHosts) {
-                host.history = [];
-                host.lastLatency = null;
-                host.status = "pending";
+                host.reset();
             }
             state.tickCount = 0;