Logging in returns to the page that was asked for (closes #384 )

RequireAuth now sends a logged-out GET to /pages/login with its path and query in a `next` parameter. The login form carries it as a hidden field, and a successful login redirects there when it is a path on this site; anything else, plain or percent-encoded, goes to `/`, which leads to the webhook list. A browser already logged in that opens the login page goes to the same place. The navigation bar on the login page no longer links to the login page. Model: opus-5-5
2026-10-01 21:45:40 +00:00
28 changed files with 626 additions and 895 deletions
@@ -142,7 +142,7 @@ TTY detection, and security headers are always applied.
 | `RETENTION_SWEEP_INTERVAL` | How often the retention reaper and archive sweeper run (Go duration, must be positive) | `1h` |
 | `SESSION_IDLE_TIMEOUT`  | Idle session timeout (Go duration)  | `24h`    |
 | `RECEIVER_RATE_LIMIT`   | Receiver requests/minute per IP per entrypoint (10x that per IP across the route) | `120` |
-| `TRUSTED_PROXIES`       | CIDRs whose forwarded headers are trusted. A set value replaces the default. If any client can reach webhooker, or the proxy in front of it, from an RFC 1918 source address, set it to the proxy's address alone. See [Trusted proxies](#trusted-proxies) | `10.0.0.0/8,172.16.0.0/12,192.168.0.0/16` (RFC 1918) |
+| `TRUSTED_PROXIES`       | CIDRs whose forwarded headers are trusted (unset: all clients behind a proxy share one rate-limit bucket; a correct login password is never throttled either way) | `""` (none) |
 | `ALLOWED_EGRESS_CIDRS`  | CIDRs that delivery targets may reach despite the SSRF blocklist. Read [Allowing egress to your own network](#allowing-egress-to-your-own-network) before setting it | `""` (none) |
 #### Allowing egress to your own network
@@ -157,21 +157,6 @@ public cloud metadata addresses: currently only `168.63.129.16`, Azure's
 WireServer, which serves an Azure VM its credentials. Because it is a
 public address, listing it in `ALLOWED_EGRESS_CIDRS` reopens it.
 That is all the default blocklist covers: the IPv4 private and reserved
 ranges; of IPv6, only loopback (`::1`), unique local addresses
 (`fc00::/7`) and link-local addresses (`fe80::/10`); and certain public
 addresses. A public address belongs on the default blocklist only if it
 hands credentials, user data or bootstrap material to whatever can reach
 it, without the caller presenting anything. A provider's other public
 addresses are not refused. IBM Cloud, for example, serves its package
 mirrors, time servers and object storage on `161.26.0.0/16`, and the
 private endpoints of its own cloud services on `166.8.0.0/14`. Neither
 range hands out credentials that way: the token service among those
 endpoints issues a token only in exchange for something the caller
 presents, such as an API key. Reaching these services can be a
 legitimate delivery, and every cloud has some, so a partial list would
 promise coverage it does not give.
 That default is also inconvenient for the thing webhooker is mostly
 for: taking a public webhook and forwarding it to something on your own
 network. A container on the same Docker network, a box on `10.x`, a
@@ -389,37 +374,41 @@ unlocked.
 `TRUSTED_PROXIES` is a comma-separated list of CIDR blocks (a bare
 address such as `192.168.1.7` is accepted and treated as a single
 host), for example `192.168.1.7, 2001:db8::5`. It decides whose
-`X-Forwarded-For` header the rate limiters believe, so it should cover
+`X-Forwarded-For` header the rate limiters believe, so it should name
-the addresses of your reverse proxies.
+the addresses of your reverse proxies and nothing else.
 `X-Forwarded-For` is honoured **only** when the connecting peer is
 inside one of these blocks; for every other peer the client identity is
-the connection's own address and the header is ignored. Unset (or
+the connection's own address and the header is ignored. The default is
-empty), the list is the RFC 1918 private ranges: `10.0.0.0/8`,
+the empty list, which trusts nobody — anything else would let any
-`172.16.0.0/12` and `192.168.0.0/16`. A set value replaces the default
+client pick its own rate limit bucket, minting a fresh one per request
-entirely. A set but unparseable value aborts startup.
+or draining someone else's. Set it to the address of your reverse
 proxy, and to nothing wider. A set but unparseable value aborts
 startup.
-If any client can reach webhooker, or the proxy in front of it, from an
+That default is safe against forged headers, but leaving it unset in
-RFC 1918 source address (directly, or through anything that can
+production has a cost you must know about. Production runs behind a
-rewrite source addresses, such as NAT or a published container port),
+TLS-terminating reverse proxy, so with `TRUSTED_PROXIES` unset every
-set `TRUSTED_PROXIES` to the proxy's address alone, or every rate
+request keys on the proxy's own address and all clients share a single
-limit, the webhook receiver's included, can be bypassed by those
+bucket per limit. The receiver limits become service-wide ceilings,
-clients. The address to set is the `remoteIP` field of the
+and the login endpoint's failure counting collapses onto one key, so a
-`http request` log line for a request that came through the proxy.
+stranger's wrong passwords throttle every other client's wrong
-
+passwords.
 Behind a proxy the list does not cover, every request keys on the
 proxy's own address and all clients share a single bucket per limit.
 The receiver limits become service-wide ceilings, and the login
 endpoint's failure counting collapses onto one key, so a stranger's
 wrong passwords throttle every other client's wrong passwords. Set
 `TRUSTED_PROXIES` to that proxy's address to restore per-client
 buckets.
 What it cannot do is lock the operator out. The login endpoint
 verifies credentials **before** it consults any limit and charges only
 failures, so a correct password is never throttled no matter how full
 the bucket is. See [Rate Limiting](#rate-limiting).
 The remedy is to set `TRUSTED_PROXIES` to your reverse proxy's
 address, which restores per-client buckets. webhooker logs a warning
 at startup whenever `TRUSTED_PROXIES` is empty, in every environment,
 because behind a proxy every client shares one bucket in `dev` and
 `prod` alike. The warning is informational when nothing proxies to the
 process: with no proxy in front, the peer address is the client's own
 and the buckets are already per-client. See
 [Rate Limiting](#rate-limiting) for what each limit shares.
 `X-Real-IP` and `True-Client-IP` are **never** read, from any peer.
 Reverse proxies append to `X-Forwarded-For` but forward other client
 headers verbatim, so a single-valued header is client-controlled even
@@ -435,10 +424,20 @@ instead, since past such an entry the chain is not the shape assumed
 here. The peer address is likewise used when the header is absent or
 every hop in it is a trusted proxy.
-Your proxy must therefore **append** the peer address to
+Two operator requirements follow:
-`X-Forwarded-For` (nginx `$proxy_add_x_forwarded_for`, HAProxy
+
-`option forwardfor`, Caddy and AWS ALB by default), and must append a
+- Your proxy must **append** the peer address to `X-Forwarded-For`
-bare address with no port.
+  (nginx `$proxy_add_x_forwarded_for`, HAProxy `option forwardfor`,
  Caddy and AWS ALB by default), and must append a bare address with
  no port.
 - List proxy hosts **only**. Any address inside `TRUSTED_PROXIES`
  chooses its own rate-limit key: its `X-Forwarded-For` is walked, so
  it can name a different address on every request to get a fresh
  bucket each time, or name another client's address to drain that
  client's bucket. Never list a block that also covers clients — a
  broad `10.0.0.0/8` on a network where clients live in the same range
  makes all three limits, including the unauthenticated webhook
  receiver, silently bypassable by every client in the block.
 #### Sessions
@@ -737,15 +736,10 @@ repository's `Dockerfile` and runs it. The app needs:
 - **Volume:** one host directory mounted at `/var/lib/webhooker`.
 - **Environment variables:**
    - `WEBHOOKER_ENVIRONMENT=prod`
-    - `TRUSTED_PROXIES`: unset, it is the RFC 1918 ranges. Set it to
+    - `TRUSTED_PROXIES`: your reverse proxy's address on that Docker
-      your reverse proxy's address alone if that address is outside
+      network. The `remoteIP` field of the `http request` log line for a
-      those ranges, or if any client can reach webhooker, or the proxy,
+      request that came through the proxy shows it; the health check's
-      from an RFC 1918 source address (directly, or through anything
+      own lines show `::1`. See [Trusted proxies](#trusted-proxies).
      that can rewrite source addresses, such as NAT or a published
      container port). The `remoteIP` field of the `http request` log
      line for a request that came through the proxy shows that
      address; the health check's own lines show `::1`. See
      [Trusted proxies](#trusted-proxies).
    - Leave `BIND_ADDRESS` and `DATA_DIR` unset: the image sets
      `BIND_ADDRESS` to `0.0.0.0`, and `DATA_DIR` defaults to
      `/var/lib/webhooker`.
@@ -808,16 +802,12 @@ reports.
   behind a proxy means the `X-Forwarded-Proto` header. The block below
   sets it; without it every request is read as plaintext and cookies
   ship without `Secure`. See [Configuration](#configuration).
-3. **Make sure `TRUSTED_PROXIES` covers the proxy's address.** For a
+3. **Set `TRUSTED_PROXIES` to the proxy's address.** Unset, every rate
-   proxy it does not cover, every rate limiter keys on the proxy, so
+   limiter keys on the connecting peer, which behind a proxy is the
-   all clients share one bucket per limit. Unset, the list is the RFC
+   proxy on every request: all clients collapse into one global bucket
-   1918 ranges, which do not cover a proxy that reaches the binary
+   per limit and the receiver's per-IP limits become service-wide
-   itself over loopback (the binary bound to `127.0.0.1`). With the
+   ceilings. See [Trusted proxies](#trusted-proxies). List the proxy
-   image, the address to check is the `remoteIP` field of the
+   and nothing else.
   `http request` log line for a request that came through the proxy.
   If any client can reach webhooker, or the proxy, from an RFC 1918
   source address, set the list to the proxy's address alone. See
   [Trusted proxies](#trusted-proxies).
 4. **Send `Host` as `$http_host`, not `$host`.** `$host` strips the
   port. webhooker's Origin/Referer check compares against the host it
   was given, so on any port other than 443 `$host` makes every form
@@ -1370,11 +1360,10 @@ It uses:
 - **[go-chi/httprate](https://github.com/go-chi/httprate)** for
  sliding-window rate limiting of the password-change and webhook
  receiver endpoints. The bucket is per client IP only when
-  `TRUSTED_PROXIES` covers the reverse proxy (by default it covers the
+  `TRUSTED_PROXIES` names the reverse proxy; unset, every client
-  RFC 1918 private ranges); otherwise every client behind that proxy
+  behind that proxy shares one bucket per limit. The login endpoint
-  shares one bucket per limit. The login endpoint counts failed
+  counts failed attempts itself instead, so that a correct password is
-  attempts itself instead, so that a correct password is never
+  never throttled (see [Rate Limiting](#rate-limiting))
  throttled (see [Rate Limiting](#rate-limiting))
 - **[Prometheus](https://prometheus.io)** for metrics, served at
  `/metrics` behind basic auth
 - **[Sentry](https://sentry.io)** for optional error reporting
@@ -1653,7 +1642,6 @@ data for auditing, for replay, and for resubmission.
 | `headers`      | JSON   | Complete request headers |
 | `body`         | text   | Raw request body |
 | `content_type` | string | Content-Type header value |
 | `body_bytes`   | integer | The body's size in bytes, recorded when the event is stored, on receipt and on resubmit |
 | `resubmitted_from_id` | UUID | The event this one was copied from by a resubmit (nullable; empty for an event that arrived on the receiver). Not a foreign key: the source event can be reaped by retention while its copies remain |
 **Relations:** Belongs to Webhook. Belongs to Entrypoint. Has many
@@ -2545,44 +2533,47 @@ the tree is checked out: four checkouts have reported 3,959, 3,961,
 client-supplied field was cut, and that the shipped chain's stack
 arrived uncut — never the numbers.
-Every limiter here — receiver, login, password change, delivery replay
+Every limiter here — receiver, login, and password change — identifies
-and event resubmit — identifies the client the same way, through one
+the client the same way, through one shared key function: the
-shared key function: the connection's own address, unless the peer is
+connection's own address, unless the peer is listed in
-inside `TRUSTED_PROXIES`, in which case the forwarded client address is
+`TRUSTED_PROXIES`, in which case the forwarded client address is used
-used instead. That address becomes a bucket by family: IPv4 keys on
+instead. That address becomes a bucket by family: IPv4 keys on the full
-the full address, IPv6 on its `/64` prefix. A routed `/64` is the normal
+address, IPv6 on its `/64` prefix. A routed `/64` is the normal
 residential and mobile IPv6 allocation, so keying IPv6 per address would
 let one subscriber rotate source addresses and mint a fresh bucket per
 request, evading these limits at the network layer without spoofing
 anything; the cost is that distinct clients inside one `/64` share a
 bucket. IPv4-mapped addresses (`::ffff:1.2.3.4`) key as the IPv4 address
-they carry. See [Trusted proxies](#trusted-proxies). When that variable
+they carry. See [Trusted proxies](#trusted-proxies). Deployed without that
-does not cover the reverse proxy, a client behind it shares one bucket
+variable set, a client behind a reverse proxy shares one bucket with
-with every other client behind the same proxy. Set `TRUSTED_PROXIES` to
+every other client behind the same proxy. Set `TRUSTED_PROXIES` to the
-the proxy's address to get per-client limits back. What the shared bucket
+proxy's address to get per-client limits back. What the shared bucket
 costs is not the same for every limiter, and the two cases pull in
 opposite directions:
 - For the **receiver** limits it costs throughput, which is the safe
  direction to be wrong in: sharing can only make a limit bind sooner,
  never let a sender past it. It matters more for the aggregate limit
-  than for the per-entrypoint one: with every request keyed on the
+  than for the per-entrypoint one: with `TRUSTED_PROXIES` unset behind
-  proxy, the aggregate limit becomes a service-wide ceiling of 1200
+  the reverse proxy a production deployment is required to run behind,
-  requests per minute across all senders and all entrypoints, where the
+  every request keys on the proxy, so the aggregate limit becomes a
-  per-entrypoint limit's capacity still grows with the number of
+  service-wide ceiling of 1200 requests per minute across all senders
-  entrypoints.
+  and all entrypoints, where the per-entrypoint limit's capacity still
  grows with the number of entrypoints. Any deployment with more than a
  handful of busy entrypoints must set `TRUSTED_PROXIES`.
 - For the **login and password-change** limits it costs precision, not
  availability. Login failures from every client land in one counter,
  so a stranger's wrong passwords make the operator's own wrong
  passwords answer `429` sooner; the operator's _correct_ password is
-  never affected, because it is never counted.
+  never affected, because it is never counted. Production deployments
  should still set `TRUSTED_PROXIES`; webhooker warns at startup
  whenever it is empty, in any environment.
 #### The login endpoint
 The login `POST` is the one endpoint with no pre-emptive limiter in
 front of it, and that is deliberate. A limiter that spends budget on
-arrival is a lockout wherever clients share one bucket, as they do
+arrival is a lockout in this deployment shape: sharing one bucket, a
 behind a reverse proxy that `TRUSTED_PROXIES` does not cover: a
 stranger sending five POSTs a minute — about 0.08 requests per second,
 from anywhere — keeps it permanently full, and the operator has no
 second administrative path. So the handler inverts the order:
@@ -2679,10 +2670,8 @@ re-fills both verification slots on its first two requests. The
 remedies are to block the source at the reverse proxy, or to
 rate-limit `POST /pages/login` there — the one place a limit can be
 applied without reintroducing the lockout, because the proxy sees the
-real client address. `TRUSTED_PROXIES` does not stop the saturation.
+real client address. Setting `TRUSTED_PROXIES` does not stop the
-The flood's source is in the proxy's access log: webhooker's own logs
+saturation, but it makes the source visible in the failure logs.
 record the proxy's address, not the client's (see
 [Deployment behind a reverse proxy](#deployment-behind-a-reverse-proxy)).
 Finer-grained per-webhook rate limits (configured in the web UI and
 enforced in the webhook handler) can layer on top of this env-level
@@ -2703,12 +2692,16 @@ abuse limit later; they are tracked as future work.
 | Method | Path            | Description |
 | ------ | --------------- | ----------- |
-| `GET`  | `/pages/login`  | Login page (not rate limited) |
+| `GET`  | `/pages/login`  | Login page (not rate limited). Its `next` parameter names the page to return to after login; anything but a path on this site is replaced with `/` |
-| `POST` | `/pages/login`  | Login form submission. Credentials are verified before any limit is consulted, so a correct password is never throttled; 5 FAILED attempts per minute per bucket per submitted username, then `429`. `503` if no verification slot frees up within 5s, or immediately if 16 requests are already queued for one (see [Rate Limiting](#rate-limiting)) |
+| `POST` | `/pages/login`  | Login form submission. On success, redirects to the form's `next` when it is a path on this site, otherwise to `/`. Credentials are verified before any limit is consulted, so a correct password is never throttled; 5 FAILED attempts per minute per bucket per submitted username, then `429`. `503` if no verification slot frees up within 5s, or immediately if 16 requests are already queued for one (see [Rate Limiting](#rate-limiting)) |
 | `POST` | `/pages/logout` | Logout (destroys session) |
 #### Authenticated Endpoints
 A logged-out `GET` of any of these is redirected to `/pages/login` with
 its path and query as `next`, so logging in returns to the page that was
 asked for.
 | Method | Path                     | Description |
 | ------ | ------------------------ | ----------- |
 | `GET`  | `/user/{username}`       | User profile page |
@@ -3040,9 +3033,10 @@ check, see [The login endpoint](#the-login-endpoint).
  It runs behind session auth, so only a client already holding a
  valid session reaches it, and an operator throttled out of changing
  a password can still log in. The bucket is per client IP only when
-  `TRUSTED_PROXIES` covers the reverse proxy; otherwise every client
+  `TRUSTED_PROXIES` names the reverse proxy; unset, every client
  shares one bucket, which costs precision rather than availability
-  (see [Rate Limiting](#rate-limiting))
+  (see [Rate Limiting](#rate-limiting)). webhooker warns at startup
  whenever `TRUSTED_PROXIES` is empty
 - Prometheus metrics behind basic auth
 - Static assets embedded in binary (no filesystem access needed at
  runtime)
@@ -387,7 +387,7 @@ point of the branch.
 - 2026-03-05 security headers middleware, session regeneration on
  login, request body size limits (#41)
 - 2026-03-04 tests for delivery, middleware, and session packages
-  (#32); removed the build-architecture global (#31)
+  (#32); removed globals.Buildarch (#31)
 - 2026-03-04 1.0 MVP merge: Webhook/Entrypoint/Target rename, core
  delivery engine with bounded worker pool and circuit breaker,
  parallel fan-out, per-webhook event databases, management UI (#16)
@@ -4,7 +4,6 @@ go 1.26.1
 require (
 	github.com/99designs/basicauth-go v0.0.0-20230316000542-bf6f9cbbf0f8
 	github.com/dustin/go-humanize v1.0.1
 	github.com/getsentry/sentry-go v0.25.0
 	github.com/go-chi/chi v1.5.5
 	github.com/go-chi/cors v1.2.1
@@ -30,6 +29,7 @@ require (
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/cespare/xxhash/v2 v2.2.0 // indirect
 	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/gorilla/securecookie v1.1.2 // indirect
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/jinzhu/now v1.1.5 // indirect
@@ -75,11 +75,6 @@ const (
 	// internet-exposed endpoint.
 	defaultReceiverRateLimit = 120
 	// defaultTrustedProxies is TRUSTED_PROXIES when it is unset: the
 	// RFC 1918 private ranges, which a reverse proxy reaching the
 	// process over a Docker network or a private LAN connects from.
 	defaultTrustedProxies = "10.0.0.0/8,172.16.0.0/12,192.168.0.0/16"
 	// maxPort is the highest valid TCP port number. The lower
 	// bound (at least 1) is enforced by envPositiveInt.
 	maxPort = 65535
@@ -177,14 +172,13 @@ type Config struct {
 	// TrustedProxies is the set of networks whose members are
 	// allowed to speak for the client with X-Forwarded-For, the
-	// only forwarded header read. Unless TRUSTED_PROXIES is set it
+	// only forwarded header read. It is empty unless
-	// is the RFC 1918 private ranges (defaultTrustedProxies); a set
+	// TRUSTED_PROXIES is set, and empty means no peer is
-	// value replaces them. If any client can reach the process, or
+	// trusted: forwarded headers are then ignored entirely and
-	// the proxy in front of it, from an RFC 1918 source address
+	// clients are identified by the connection's own address.
-	// (directly, or through anything that can rewrite source
+	// Members can choose their own rate-limit key, so this must
-	// addresses, such as NAT or a published container port), it
+	// name proxy hosts only, never a block that also covers
-	// must be set to the proxy's address alone, or every rate limit
+	// clients.
 	// can be bypassed by those clients.
 	TrustedProxies []netip.Prefix
 	// AllowedEgressCIDRs is the set of networks a delivery target
@@ -466,15 +460,14 @@ func parseCIDR(entry string) (netip.Prefix, error) {
 // envPrefixList returns the value of the named environment variable
 // parsed as a comma-separated list of CIDR blocks (bare addresses
-// allowed). An unset, empty, or blank value is read as defaultValue
+// allowed). An unset, empty, or blank value yields an empty list. A
-// instead. A set value containing an unparseable entry is a hard
+// set value containing an unparseable entry is a hard error naming
-// error naming the key and the bad entry, so startup fails loudly
+// the key and the bad entry, so startup fails loudly rather than
-// rather than silently running with a list the operator did not
+// silently running with a list the operator did not intend.
-// intend.
+func envPrefixList(key string) ([]netip.Prefix, error) {
 func envPrefixList(key, defaultValue string) ([]netip.Prefix, error) {
 	v := strings.TrimSpace(os.Getenv(key))
 	if v == "" {
-		v = defaultValue
+		return nil, nil
 	}
 	var prefixes []netip.Prefix
@@ -688,12 +681,12 @@ func loadFromEnv() (*Config, error) {
 		return nil, err
 	}
-	trustedProxies, err := envPrefixList("TRUSTED_PROXIES", defaultTrustedProxies)
+	trustedProxies, err := envPrefixList("TRUSTED_PROXIES")
 	if err != nil {
 		return nil, err
 	}
-	allowedEgressCIDRs, err := envPrefixList("ALLOWED_EGRESS_CIDRS", "")
+	allowedEgressCIDRs, err := envPrefixList("ALLOWED_EGRESS_CIDRS")
 	if err != nil {
 		return nil, err
 	}
@@ -767,6 +760,50 @@ func (c *Config) warnEgressAllowlist(log *slog.Logger) {
 	)
 }
 // warnSharedRateLimitBucket logs a startup warning whenever
 // TRUSTED_PROXIES is empty, in any environment.
 //
 // With no trusted proxies every rate limiter keys on the connecting
 // peer's address. Whether that is harmless or dangerous depends on
 // what is in front of the process, which this code cannot observe:
 // with nothing in front, the peer is the client and the limits are
 // per-client as intended; behind a reverse proxy the peer is the proxy
 // for every request, so all clients share one bucket per limiter.
 //
 // The login endpoint no longer spends budget on arrival — it verifies
 // credentials first and charges only failures — so a shared bucket
 // cannot deny the operator a correct password. What it does collapse
 // is the failure counting: one client's wrong passwords throttle
 // everyone else's wrong passwords, and the receiver's limits become
 // service-wide ceilings.
 //
 // The warning is deliberately not gated on WEBHOOKER_ENVIRONMENT:
 // behind a proxy every client shares one bucket in dev and prod alike.
 //
 // The default of trusting nobody is deliberate — trusting forwarded
 // headers from arbitrary peers lets any client choose its own bucket —
 // so this warns rather than failing startup or changing the key.
 func (c *Config) warnSharedRateLimitBucket(log *slog.Logger) {
 	if len(c.TrustedProxies) > 0 {
 		return
 	}
 	log.Warn(
 		"TRUSTED_PROXIES is empty: every rate limit keys on the "+
 			"connecting peer's address. With nothing proxying to "+
 			"this process that is the client itself and the limits "+
 			"are per-client as intended. Behind a reverse proxy the "+
 			"peer is the proxy on every request, so all clients "+
 			"share one bucket per limit: the receiver limits become "+
 			"service-wide ceilings, and one client's failed logins "+
 			"throttle every other client's failed logins — a "+
 			"correct password still gets in. If anything proxies to "+
 			"this process, set TRUSTED_PROXIES to its address.",
 		"environment", c.Environment,
 		"trustedProxies", len(c.TrustedProxies),
 	)
 }
 // New creates a Config by reading environment variables.
 //
 //nolint:revive // lc parameter is required by fx even if unused.
@@ -812,6 +849,7 @@ func New(lc fx.Lifecycle, params ConfigParams) (*Config, error) {
 		"hasMetricsAuth", s.MetricsAuthEnabled(),
 	)
 	s.warnSharedRateLimitBucket(log)
 	s.warnEgressAllowlist(log)
 	return s, nil
@@ -551,11 +551,6 @@ func testReceiverRateLimitSuccess(
 }
 func TestTrustedProxies(t *testing.T) {
 	// Unset, the RFC 1918 private ranges are trusted, so a reverse
 	// proxy on a Docker network or a private LAN is covered without
 	// configuration.
 	defaultProxies := []string{cidrPrivateV4, "172.16.0.0/12", "192.168.0.0/16"}
 	tests := []struct {
 		name        string
 		set         bool
@@ -564,21 +559,18 @@ func TestTrustedProxies(t *testing.T) {
 		expected    []string
 	}{
 		{
 			// The default must be "trust nobody": an empty list
 			// means forwarded headers are ignored, never that
 			// every peer may speak for the client.
 			name:     caseUnsetUsesDefault,
 			set:      false,
-			expected: defaultProxies,
+			expected: []string{},
 		},
 		{
-			name:     "blank value uses default",
+			name:     "blank value trusts nothing",
 			set:      true,
 			value:    "  ",
-			expected: defaultProxies,
+			expected: []string{},
 		},
 		{
 			name:     "set value replaces the default entirely",
 			set:      true,
 			value:    "203.0.113.7",
 			expected: []string{"203.0.113.7/32"},
 		},
 		{
 			name:  caseValidValueParsed,
@@ -853,6 +845,101 @@ func TestEgressAllowlistWarning(t *testing.T) {
 	}
 }
 // TestSharedRateLimitBucketWarning covers the startup warning that
 // tells an operator a deployment behind a reverse proxy shares one
 // rate-limit bucket between every client, which turns the receiver
 // limits into service-wide ceilings and collapses login failure
 // counting. It must fire whenever TRUSTED_PROXIES is empty, in any
 // environment, because behind a proxy every client shares one bucket
 // in dev and prod alike. It stays quiet once proxies are named.
 func TestSharedRateLimitBucketWarning(t *testing.T) {
 	tests := []struct {
 		name           string
 		environment    string
 		trustedProxies string
 		expectWarning  bool
 	}{
 		{
 			name:          "prod without trusted proxies warns",
 			environment:   config.EnvironmentProd,
 			expectWarning: true,
 		},
 		{
 			name:           "prod with trusted proxies is quiet",
 			environment:    config.EnvironmentProd,
 			trustedProxies: cidrPrivateV4,
 			expectWarning:  false,
 		},
 		{
 			name:          "dev without trusted proxies warns",
 			environment:   config.EnvironmentDev,
 			expectWarning: true,
 		},
 		{
 			name:           "dev with trusted proxies is quiet",
 			environment:    config.EnvironmentDev,
 			trustedProxies: cidrPrivateV4,
 			expectWarning:  false,
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			// Cannot use t.Parallel() here because t.Setenv
 			// is incompatible with parallel subtests.
 			t.Setenv("WEBHOOKER_ENVIRONMENT", tt.environment)
 			if tt.trustedProxies == "" {
 				require.NoError(
 					t, os.Unsetenv("TRUSTED_PROXIES"),
 				)
 			} else {
 				t.Setenv("TRUSTED_PROXIES", tt.trustedProxies)
 			}
 			var buf bytes.Buffer
 			log := slog.New(slog.NewJSONHandler(
 				&buf, &slog.HandlerOptions{
 					Level: slog.LevelDebug,
 				},
 			))
 			require.NoError(
 				t,
 				config.WarnSharedRateLimitBucketForTest(log),
 			)
 			if !tt.expectWarning {
 				assert.Empty(t, buf.String())
 				return
 			}
 			logged := buf.String()
 			assert.Contains(t, logged, `"level":"WARN"`)
 			assert.Contains(t, logged, "TRUSTED_PROXIES")
 			assert.Contains(t, logged, "share one bucket")
 			assert.Contains(
 				t, logged, "throttle every other client's failed logins",
 			)
 			// The warning must not claim a lockout the login
 			// endpoint no longer permits: credentials are verified
 			// before any budget is spent.
 			assert.Contains(
 				t, logged, "a correct password still gets in",
 			)
 			// The text must stay accurate for a developer with
 			// nothing in front of the process, where an empty
 			// list costs nothing.
 			assert.Contains(
 				t, logged, "nothing proxying to this process",
 			)
 		})
 	}
 }
 // metricsEnv describes what one subtest below puts in the
 // environment for a single METRICS_ variable. A variable that is
 // set to the empty string and one that is not set at all are
@@ -6,6 +6,21 @@ import "log/slog"
 // the external config_test package so each helper can be covered by
 // its own table-driven test without weakening the package API.
 // WarnSharedRateLimitBucketForTest loads a Config from the current
 // environment and emits its startup warnings to log. The real logger
 // writes to stdout, so this lets the warning's firing condition be
 // asserted against a handler the test controls.
 func WarnSharedRateLimitBucketForTest(log *slog.Logger) error {
 	c, err := loadFromEnv()
 	if err != nil {
 		return err
 	}
 	c.warnSharedRateLimitBucket(log)
 	return nil
 }
 // WarnEgressAllowlistForTest loads a Config from the current
 // environment and emits its egress-allowlist startup warning to
 // log, so a test can assert both that the warning fires only when
@@ -31,11 +31,6 @@ type Event struct {
 	Body        string `gorm:"type:text"   json:"body"`
 	ContentType string `json:"contentType"`
 	// BodyBytes is the size of Body in bytes, recorded when the event
 	// is stored so the recent events list can show it without reading
 	// the body.
 	BodyBytes int64 `gorm:"not null" json:"bodyBytes"`
 	// ResubmittedFromID names the event this one was copied from by
 	// an operator resubmit. It is nil for an event that arrived on
 	// the receiver, which is every event created before the column
@@ -43,13 +43,6 @@ var (
 // permit specific blocks out of this set with
 // ALLOWED_EGRESS_CIDRS; see Guard.
 //
 // A public address belongs on the default blocklist only if it
 // hands credentials, user data or bootstrap material to whatever
 // can reach it, without the caller presenting anything. A
 // provider's other public addresses are not refused, since
 // reaching them can be legitimate and no list of them could be
 // complete.
 //
 //nolint:gochecknoglobals // package-level network list is appropriate here
 var blockedNetworks []*net.IPNet
@@ -2,19 +2,62 @@ package handlers
 import (
 	"net/http"
 	"net/url"
 	"strconv"
 	"strings"
 	"unicode"
 	"sneak.berlin/go/webhooker/internal/database"
 	"sneak.berlin/go/webhooker/internal/logfield"
 	"sneak.berlin/go/webhooker/internal/middleware"
 )
 // maxNextBytes bounds the page to return to after login. The login
 // page writes it into its form, and every page is rendered into a
 // buffer first (see executeTemplate), so without a bound a request
 // would choose the size of that buffer.
 const maxNextBytes = 2048
 // loginDestination returns where a successful login sends the
 // browser: next when it is a path on this site, otherwise "/", which
 // leads to the webhook list.
 //
 // A browser reads "//host" as another site, reads "\" as "/", and
 // drops tabs and newlines before reading at all. So the value must
 // start with exactly one "/" and hold no "\" or control character
 // anywhere: http.Redirect cleans "/a/../\host" down to "/\host". It
 // is checked after percent-decoding, so an encoded form of any of
 // these is refused too.
 func loginDestination(next string) string {
 	if len(next) > maxNextBytes {
 		return "/"
 	}
 	decoded, err := url.PathUnescape(next)
 	if err != nil ||
 		!strings.HasPrefix(decoded, "/") ||
 		strings.HasPrefix(decoded, "//") ||
 		strings.Contains(decoded, `\`) ||
 		strings.ContainsFunc(decoded, unicode.IsControl) {
 		return "/"
 	}
 	return next
 }
 // HandleLoginPage returns a handler for the login page (GET)
 func (h *Handlers) HandleLoginPage() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		next := loginDestination(
 			r.URL.Query().Get(middleware.NextParam),
 		)
 		// Check if already logged in
 		sess, err := h.session.Get(r)
 		if err == nil && h.session.IsAuthenticated(sess) {
-			http.Redirect(w, r, "/", http.StatusSeeOther)
+			http.Redirect( //nolint:gosec // checked by loginDestination
 				w, r, next, http.StatusSeeOther,
 			)
 			return
 		}
@@ -22,6 +65,7 @@ func (h *Handlers) HandleLoginPage() http.HandlerFunc {
 		// Render login page
 		data := map[string]any{
 			tmplKeyError: "",
 			tmplKeyNext:  next,
 		}
 		h.renderTemplate(w, r, "login.html", data)
@@ -77,8 +121,13 @@ func (h *Handlers) HandleLoginSubmit() http.HandlerFunc {
 			"user_id", user.ID,
 		)
-		// Redirect to home page
+		// The form value is the client's to set, so it is checked
-		http.Redirect(w, r, "/", http.StatusSeeOther)
+		// again here rather than trusted from the rendered page.
 		http.Redirect( //nolint:gosec // checked by loginDestination
 			w, r,
 			loginDestination(r.PostFormValue(middleware.NextParam)),
 			http.StatusSeeOther,
 		)
 	}
 }
@@ -91,6 +140,9 @@ func (h *Handlers) renderLoginError(
 ) {
 	data := map[string]any{
 		tmplKeyError: msg,
 		tmplKeyNext: loginDestination(
 			r.PostFormValue(middleware.NextParam),
 		),
 	}
 	w.WriteHeader(status)
@@ -103,10 +155,9 @@ func (h *Handlers) renderLoginError(
 // The credential check runs BEFORE any rate-limit budget is
 // consulted, and only a failed check spends budget. That is what
 // keeps the single administrative path reachable: behind the reverse
-// proxy this deployment requires, when TRUSTED_PROXIES does not cover
+// proxy this deployment requires, with TRUSTED_PROXIES unset, every
-// it, every client shares one bucket, so a limiter spent on arrival
+// client shares one bucket, so a limiter spent on arrival lets any
-// lets any stranger deny the operator's own correct password
+// stranger deny the operator's own correct password indefinitely.
 // indefinitely.
 //
 // Verifying first means every login POST costs an Argon2id hash, so
 // the work is taken under a bounded number of verification slots.
@@ -25,7 +25,7 @@ const (
 	// sharedProxyPeer is the whole point of this file. Production is
 	// required to run behind a TLS-terminating reverse proxy, and
-	// when TRUSTED_PROXIES does not cover it every client — attacker
+	// TRUSTED_PROXIES defaults to empty, so every client — attacker
 	// and operator alike — reaches the process from the proxy's
 	// address and shares one rate-limit bucket. Both parties in
 	// these tests therefore use the same RemoteAddr.
@@ -115,11 +115,11 @@ func floodFailures(
 // done-criterion of https://git.eeqj.de/sneak/webhooker/issues/150.
 //
 // The attacker and the operator share one rate-limit bucket, because
-// behind the mandated reverse proxy, when TRUSTED_PROXIES does not
+// behind the mandated reverse proxy with TRUSTED_PROXIES unset every
-// cover it, every client keys on the proxy's address. The attacker
+// client keys on the proxy's address. The attacker floods the
-// floods the operator's own username — a single-admin product has a
+// operator's own username — a single-admin product has a predictable
-// predictable one — far past the failure limit. The operator must
+// one — far past the failure limit. The operator must still be able
-// still be able to log in with the correct password.
+// to log in with the correct password.
 //
 // This fails if credentials stop being verified ahead of the limiter.
 func TestLogin_StrangersFloodCannotLockOutTheOperator(t *testing.T) {
@@ -454,6 +454,151 @@ func TestLogin_SuccessCreatesSession(t *testing.T) {
 	)
 }
 // TestLogin_ReturnsOnlyToAPathOnThisSite is the security half of
 // https://git.eeqj.de/sneak/webhooker/issues/384: the page a login
 // returns to is client-chosen, so anything that is not a path on this
 // site, plain or percent-encoded, must land on "/", the webhook list.
 func TestLogin_ReturnsOnlyToAPathOnThisSite(t *testing.T) {
 	t.Parallel()
 	var (
 		h  *handlers.Handlers
 		db *database.Database
 	)
 	app := newTestApp(t, &h, &db)
 	app.RequireStart()
 	t.Cleanup(app.RequireStop)
 	seedOperator(t, db)
 	cases := []struct{ next, want string }{
 		{"/source/abc/logs?page=2", "/source/abc/logs?page=2"},
 		{"", "/"},
 		{"https://evil.example/", "/"},
 		{"https%3A%2F%2Fevil.example%2F", "/"},
 		{"//evil.example/", "/"},
 		{"%2F%2Fevil.example/", "/"},
 		{"/%2Fevil.example/", "/"},
 		{`/\evil.example/`, "/"},
 		{"%2F%5Cevil.example/", "/"},
 		{"/%5Cevil.example/", "/"},
 		{`/a/../\evil.example/`, "/"},
 		{"/\t/evil.example/", "/"},
 		{"/%09/evil.example/", "/"},
 		{"/" + strings.Repeat("a", 4096), "/"},
 	}
 	for _, c := range cases {
 		form := url.Values{}
 		form.Set("username", operatorUser)
 		form.Set("password", operatorPassword)
 		form.Set("next", c.next)
 		req := httptest.NewRequestWithContext(
 			context.Background(),
 			http.MethodPost,
 			"/pages/login",
 			strings.NewReader(form.Encode()),
 		)
 		req.Header.Set(
 			"Content-Type", "application/x-www-form-urlencoded",
 		)
 		req.RemoteAddr = sharedProxyPeer
 		w := httptest.NewRecorder()
 		h.HandleLoginSubmit().ServeHTTP(w, req)
 		assert.Equal(t, http.StatusSeeOther, w.Code, "next %q", c.next)
 		assert.Equal(
 			t, c.want, w.Header().Get("Location"), "next %q", c.next,
 		)
 	}
 }
 // loginPageGet renders the login page as a GET with the given next
 // value and cookies.
 func loginPageGet(
 	h *handlers.Handlers, next string, cookies []*http.Cookie,
 ) *httptest.ResponseRecorder {
 	req := httptest.NewRequestWithContext(
 		context.Background(), http.MethodGet,
 		"/pages/login?"+url.Values{"next": {next}}.Encode(), nil,
 	)
 	for _, c := range cookies {
 		req.AddCookie(c)
 	}
 	w := httptest.NewRecorder()
 	h.HandleLoginPage().ServeHTTP(w, req)
 	return w
 }
 // TestLoginPage_CarriesOnlyAPathOnThisSite covers the login page
 // itself: its form carries the requested page only when it is a path
 // on this site, and a browser already logged in goes straight there,
 // or to "/" when it is not.
 func TestLoginPage_CarriesOnlyAPathOnThisSite(t *testing.T) {
 	t.Parallel()
 	var (
 		h    *handlers.Handlers
 		sess *session.Session
 	)
 	app := newTestApp(t, &h, &sess)
 	app.RequireStart()
 	t.Cleanup(app.RequireStop)
 	assert.Contains(
 		t, loginPageGet(h, "/source/abc", nil).Body.String(),
 		`name="next" value="/source/abc"`,
 	)
 	assert.Contains(
 		t, loginPageGet(h, "//evil.example/", nil).Body.String(),
 		`name="next" value="/"`,
 	)
 	cookies := authenticatedCookies(t, sess, "test-user-id", "testuser")
 	cases := []struct{ next, want string }{
 		{"/source/abc", "/source/abc"},
 		{"//evil.example/", "/"},
 		{`/\evil.example/`, "/"},
 	}
 	for _, c := range cases {
 		w := loginPageGet(h, c.next, cookies)
 		assert.Equal(t, http.StatusSeeOther, w.Code, "next %q", c.next)
 		assert.Equal(
 			t, c.want, w.Header().Get("Location"), "next %q", c.next,
 		)
 	}
 }
 // TestLoginPage_HasNoLinkToItself: the navigation bar on the login
 // page offers no link to the login page.
 func TestLoginPage_HasNoLinkToItself(t *testing.T) {
 	t.Parallel()
 	var h *handlers.Handlers
 	app := newTestApp(t, &h)
 	app.RequireStart()
 	t.Cleanup(app.RequireStop)
 	w := loginPageGet(h, "", nil)
 	require.Equal(t, http.StatusOK, w.Code)
 	assert.NotContains(t, w.Body.String(), `href="/pages/login"`)
 }
 // TestLogin_UsernameAtLimitCanLogIn shows that a username of exactly
 // database.MaxUsernameBytes still fits in the session cookie. Past
 // what the cookie can carry, a correct login answers 500.
@@ -204,7 +204,6 @@ func assertEventCopy(
 	assert.Equal(t, original.Method, fresh.Method)
 	assert.Equal(t, original.Headers, fresh.Headers)
 	assert.Equal(t, original.Body, fresh.Body)
 	assert.Equal(t, int64(len(original.Body)), fresh.BodyBytes)
 	assert.Equal(t, original.ContentType, fresh.ContentType)
 	assert.Equal(t, original.EntrypointID, fresh.EntrypointID)
 	assert.Equal(t, original.WebhookID, fresh.WebhookID)
@@ -28,7 +28,7 @@ const (
 	// maxBodyShift is the bit shift for 1 MB body limit.
 	maxBodyShift = 20
 	// recentEventLimit is the number of recent events to show.
-	recentEventLimit = 50
+	recentEventLimit = 20
 	// paginationPerPage is the number of items per page.
 	paginationPerPage = 25
@@ -36,6 +36,9 @@ const (
 	tmplKeyError = "Error"
 	// tmplKeyWebhook is the template data key for a webhook.
 	tmplKeyWebhook = "Webhook"
 	// tmplKeyNext is the template data key for the page to return
 	// to after login.
 	tmplKeyNext = "Next"
 )
 // errInvalidPassword is returned when a password does not match.
@@ -160,7 +160,10 @@ func TestUserRoute_Unauthenticated_RedirectedByMiddleware(t *testing.T) {
 		"handler must not be reached for unauthenticated request",
 	)
 	assert.Equal(t, http.StatusSeeOther, w.Code)
-	assert.Equal(t, "/pages/login", w.Header().Get("Location"))
+	assert.Equal(
 		t, "/pages/login?next=%2Fuser%2Ftestuser",
 		w.Header().Get("Location"),
 	)
 }
 // passwordChangeRequest builds a POST request to the password-change
@@ -1,293 +0,0 @@
 package handlers
 import (
 	"net/http"
 	"slices"
 	"strconv"
 	"time"
 	"github.com/dustin/go-humanize"
 	"gorm.io/gorm"
 	"sneak.berlin/go/webhooker/internal/database"
 )
 // recentEventColumns is the recent events list's projection. It
 // leaves out the body, for the reason maxRenderedBodyBytes gives,
 // and reads its size from body_bytes, recorded when the event was
 // stored.
 const recentEventColumns = "id, created_at, method, content_type, " +
 	"resubmitted_from_id, body_bytes"
 // recentAttemptColumns is the part of a recorded attempt the list
 // uses. The event log's deliveryResultColumns also reads response
 // bodies, which the list does not show.
 const recentAttemptColumns = "delivery_id, status_code, created_at"
 // RecentEventView is one row of the recent events list on a
 // webhook's page.
 type RecentEventView struct {
 	Method      string
 	ContentType string
 	// ResubmittedFromID names the event this one was copied from,
 	// empty for an event that arrived on the receiver.
 	ResubmittedFromID string
 	// Received is how long ago the event arrived, and ReceivedUTC
 	// the full timestamp the page shows on hover.
 	Received    string
 	ReceivedUTC string
 	// Size is the size of the stored body.
 	Size string
 	// ProcessingTime is how long the event's slowest delivery
 	// took; see processingTime.
 	ProcessingTime string
 	// Status is what the webhook's HTTP target answered, and
 	// StatusClass its colour; see targetStatus. Both are empty
 	// unless the webhook has exactly one HTTP target.
 	Status      string
 	StatusClass string
 }
 // recentEventRow is one row of recentEventColumns.
 type recentEventRow struct {
 	ID                string
 	CreatedAt         time.Time
 	Method            string
 	ContentType       string
 	ResubmittedFromID *string
 	BodyBytes         uint64
 }
 // recentAttemptRow is one row of recentAttemptColumns. CreatedAt is
 // when the attempt's result was recorded, which is when the attempt
 // finished.
 type recentAttemptRow struct {
 	DeliveryID string
 	StatusCode int
 	CreatedAt  time.Time
 }
 // singleHTTPTargetID returns the ID of the webhook's HTTP target
 // when it has exactly one, and "" when it has none or several.
 func singleHTTPTargetID(targets []database.Target) string {
 	id := ""
 	count := 0
 	for i := range targets {
 		if targets[i].Type == database.TargetTypeHTTP {
 			id = targets[i].ID
 			count++
 		}
 	}
 	if count != 1 {
 		return ""
 	}
 	return id
 }
 // loadRecentEvents loads the webhook's recentEventLimit newest
 // events for its page, newest first. statusTargetID is the
 // webhook's only HTTP target, or "" when the list shows no status.
 func loadRecentEvents(
 	webhookDB *gorm.DB, webhookID, statusTargetID string,
 ) ([]RecentEventView, error) {
 	var rows []recentEventRow
 	err := webhookDB.Model(&database.Event{}).
 		Select(recentEventColumns).
 		Where("webhook_id = ?", webhookID).
 		Order("created_at DESC").
 		Limit(recentEventLimit).
 		Find(&rows).Error
 	if err != nil {
 		return nil, err
 	}
 	eventIDs := make([]string, len(rows))
 	for i := range rows {
 		eventIDs[i] = rows[i].ID
 	}
 	// Oldest first, so an event's last delivery to a target is its
 	// newest: a replay adds a delivery rather than changing the
 	// earlier one.
 	var deliveries []database.Delivery
 	err = webhookDB.
 		Select("id, event_id, target_id, status, created_at").
 		Where("event_id IN ?", eventIDs).
 		Order("created_at ASC").
 		Find(&deliveries).Error
 	if err != nil {
 		return nil, err
 	}
 	byEvent := make(map[string][]database.Delivery, len(rows))
 	deliveryIDs := make([]string, len(deliveries))
 	for i := range deliveries {
 		eventID := deliveries[i].EventID
 		byEvent[eventID] = append(byEvent[eventID], deliveries[i])
 		deliveryIDs[i] = deliveries[i].ID
 	}
 	attempts, err := loadRecentAttempts(webhookDB, deliveryIDs)
 	if err != nil {
 		return nil, err
 	}
 	views := make([]RecentEventView, len(rows))
 	for i := range rows {
 		views[i] = rows[i].view(
 			byEvent[rows[i].ID], attempts, statusTargetID,
 		)
 	}
 	return views, nil
 }
 // loadRecentAttempts loads the recorded attempts of the listed
 // events' deliveries, keyed by delivery ID, each delivery's in
 // attempt order. The IDs go in chunks for the reason
 // deliveryIDChunkSize gives.
 func loadRecentAttempts(
 	webhookDB *gorm.DB, deliveryIDs []string,
 ) (map[string][]recentAttemptRow, error) {
 	byDelivery := make(map[string][]recentAttemptRow)
 	for chunk := range slices.Chunk(deliveryIDs, deliveryIDChunkSize) {
 		var rows []recentAttemptRow
 		err := webhookDB.Model(&database.DeliveryResult{}).
 			Select(recentAttemptColumns).
 			Where("delivery_id IN ?", chunk).
 			Order("attempt_num ASC").
 			Find(&rows).Error
 		if err != nil {
 			return nil, err
 		}
 		for i := range rows {
 			id := rows[i].DeliveryID
 			byDelivery[id] = append(byDelivery[id], rows[i])
 		}
 	}
 	return byDelivery, nil
 }
 // view projects a loaded row for rendering. deliveries is the
 // event's deliveries, oldest first, and attempts their recorded
 // attempts keyed by delivery ID.
 func (r *recentEventRow) view(
 	deliveries []database.Delivery,
 	attempts map[string][]recentAttemptRow,
 	statusTargetID string,
 ) RecentEventView {
 	v := RecentEventView{
 		Method:         r.Method,
 		ContentType:    r.ContentType,
 		Received:       humanize.Time(r.CreatedAt),
 		ReceivedUTC:    r.CreatedAt.UTC().Format(time.DateTime) + " UTC",
 		Size:           humanize.Bytes(r.BodyBytes),
 		ProcessingTime: processingTime(deliveries, attempts),
 	}
 	if r.ResubmittedFromID != nil {
 		v.ResubmittedFromID = *r.ResubmittedFromID
 	}
 	if statusTargetID != "" {
 		v.Status, v.StatusClass = targetStatus(
 			deliveries, attempts, statusTargetID,
 		)
 	}
 	return v
 }
 // processingTime is how long the event's slowest delivery took,
 // from being queued to its last recorded attempt, time spent
 // waiting between retries included. A delivery is queued when its
 // event is received, or when an operator replays it, so a replay
 // is timed from the replay rather than from the event's arrival.
 // It is "in progress" while any delivery is pending or retrying,
 // and empty for an event with no deliveries.
 func processingTime(
 	deliveries []database.Delivery,
 	attempts map[string][]recentAttemptRow,
 ) string {
 	if len(deliveries) == 0 {
 		return ""
 	}
 	var slowest time.Duration
 	for i := range deliveries {
 		if !deliveries[i].Status.Terminal() {
 			return "in progress"
 		}
 		tries := attempts[deliveries[i].ID]
 		if len(tries) == 0 {
 			continue
 		}
 		last := tries[len(tries)-1].CreatedAt
 		slowest = max(slowest, last.Sub(deliveries[i].CreatedAt))
 	}
 	return slowest.Round(time.Millisecond).String()
 }
 // targetStatus is what the target answered for the event, and the
 // colour to show it in: the HTTP status code of the last attempt of
 // the event's newest delivery to the target. Without a code it is
 // "no response" when that attempt failed before a response
 // arrived, the delivery's status ("pending") before any attempt,
 // and "not sent" when the event has no delivery to the target.
 func targetStatus(
 	deliveries []database.Delivery,
 	attempts map[string][]recentAttemptRow,
 	targetID string,
 ) (string, string) {
 	newest := -1
 	for i := range deliveries {
 		if deliveries[i].TargetID == targetID {
 			newest = i
 		}
 	}
 	if newest < 0 {
 		return "not sent", "text-gray-400"
 	}
 	tries := attempts[deliveries[newest].ID]
 	if len(tries) == 0 {
 		return string(deliveries[newest].Status), "text-gray-400"
 	}
 	code := tries[len(tries)-1].StatusCode
 	switch {
 	case code == 0:
 		return "no response", "text-red-600"
 	case code >= http.StatusInternalServerError:
 		return strconv.Itoa(code), "text-red-600"
 	case code >= http.StatusBadRequest:
 		return strconv.Itoa(code), "text-yellow-600"
 	case code >= http.StatusMultipleChoices:
 		return strconv.Itoa(code), "text-gray-500"
 	case code >= http.StatusOK:
 		return strconv.Itoa(code), "text-green-600"
 	default:
 		return strconv.Itoa(code), "text-gray-500"
 	}
 }
@@ -1,362 +0,0 @@
 package handlers_test
 import (
 	"context"
 	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"strings"
 	"testing"
 	"time"
 	"github.com/go-chi/chi"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"gorm.io/gorm"
 	"gorm.io/gorm/clause"
 	"sneak.berlin/go/webhooker/internal/database"
 	"sneak.berlin/go/webhooker/internal/handlers"
 	"sneak.berlin/go/webhooker/internal/session"
 )
 // statusTitle marks the status column's cell in a recent events
 // row; it is absent from the page when the column is not shown.
 const statusTitle = `title="HTTP status from the HTTP target"`
 // recentEventsFixture is one started app and a webhook whose
 // recent events list a test fills.
 type recentEventsFixture struct {
 	h         *handlers.Handlers
 	sess      *session.Session
 	db        *database.Database
 	webhook   *database.Webhook
 	webhookDB *gorm.DB
 }
 func newRecentEventsFixture(t *testing.T) *recentEventsFixture {
 	t.Helper()
 	f := &recentEventsFixture{}
 	var dbMgr *database.WebhookDBManager
 	app := newTestApp(t, &f.h, &f.sess, &f.db, &dbMgr)
 	app.RequireStart()
 	t.Cleanup(app.RequireStop)
 	f.webhook = seedWebhook(t, f.db)
 	webhookDB, err := dbMgr.GetDB(f.webhook.ID)
 	require.NoError(t, err)
 	f.webhookDB = webhookDB
 	return f
 }
 func (f *recentEventsFixture) render(t *testing.T) string {
 	t.Helper()
 	return renderSourceDetailPage(t, f.h, f.sess, f.webhook.ID)
 }
 // event records an event received at receivedAt, with its body's
 // size as the receiver records it.
 func (f *recentEventsFixture) event(
 	t *testing.T, contentType, body string, receivedAt time.Time,
 ) *database.Event {
 	t.Helper()
 	event := &database.Event{
 		WebhookID:   f.webhook.ID,
 		Method:      http.MethodPost,
 		Body:        body,
 		BodyBytes:   int64(len(body)),
 		ContentType: contentType,
 	}
 	event.CreatedAt = receivedAt
 	require.NoError(t, f.webhookDB.Omit(
 		clause.Associations,
 	).Create(event).Error)
 	return event
 }
 // delivery records a delivery of the event to the target, queued
 // when the event was received.
 func (f *recentEventsFixture) delivery(
 	t *testing.T,
 	event *database.Event,
 	targetID string,
 	status database.DeliveryStatus,
 ) *database.Delivery {
 	t.Helper()
 	return f.deliveryQueuedAt(
 		t, event, targetID, status, event.CreatedAt,
 	)
 }
 // deliveryQueuedAt records a delivery of the event to the target,
 // queued at queuedAt, as a replay is.
 func (f *recentEventsFixture) deliveryQueuedAt(
 	t *testing.T,
 	event *database.Event,
 	targetID string,
 	status database.DeliveryStatus,
 	queuedAt time.Time,
 ) *database.Delivery {
 	t.Helper()
 	dlv := &database.Delivery{
 		EventID:  event.ID,
 		TargetID: targetID,
 		Status:   status,
 	}
 	dlv.CreatedAt = queuedAt
 	require.NoError(t, f.webhookDB.Omit(
 		clause.Associations,
 	).Create(dlv).Error)
 	return dlv
 }
 // attempt records one attempt of the delivery that finished took
 // after the delivery was queued, with HTTP status code (0 for no
 // response).
 func (f *recentEventsFixture) attempt(
 	t *testing.T, dlv *database.Delivery, code int, took time.Duration,
 ) {
 	t.Helper()
 	result := &database.DeliveryResult{
 		DeliveryID: dlv.ID,
 		AttemptNum: 1,
 		StatusCode: code,
 	}
 	result.CreatedAt = dlv.CreatedAt.Add(took)
 	require.NoError(t, f.webhookDB.Omit(
 		clause.Associations,
 	).Create(result).Error)
 }
 // statusCell is the status column's cell as the page renders it.
 func statusCell(class, text string) string {
 	return `<span class="font-medium ` + class + `" ` + statusTitle +
 		`>` + text + `</span>`
 }
 // TestHandleSourceDetail_ShowsFiftyNewestEvents proves the list is
 // headed "50 Most Recent Events" and holds the 50 newest events,
 // newest first, and not one more.
 func TestHandleSourceDetail_ShowsFiftyNewestEvents(t *testing.T) {
 	t.Parallel()
 	f := newRecentEventsFixture(t)
 	base := time.Now().Add(-time.Hour)
 	for i := range 51 {
 		f.event(
 			t, fmt.Sprintf("application/x-recent-%02d", i), "{}",
 			base.Add(time.Duration(i)*time.Second),
 		)
 	}
 	body := f.render(t)
 	assert.Contains(t, body, ">50 Most Recent Events</h2>")
 	assert.Equal(t, 50, strings.Count(body, `title="Body size"`))
 	assert.NotContains(t, body, "application/x-recent-00")
 	assert.Contains(t, body, "application/x-recent-01")
 	assert.Less(
 		t,
 		strings.Index(body, "application/x-recent-50"),
 		strings.Index(body, "application/x-recent-49"),
 	)
 }
 // TestHandleSourceDetail_RecentEventColumns proves a row shows its
 // time relative with the UTC timestamp on hover, its body size,
 // and its processing time once every delivery has finished.
 func TestHandleSourceDetail_RecentEventColumns(t *testing.T) {
 	t.Parallel()
 	f := newRecentEventsFixture(t)
 	logTarget := seedTarget(t, f.db, f.webhook.ID, database.TargetTypeLog)
 	receivedAt := time.Now().Add(-210 * time.Second).
 		UTC().Truncate(time.Second)
 	done := f.event(
 		t, contentTypeJSON, strings.Repeat("x", 2048), receivedAt,
 	)
 	f.attempt(
 		t,
 		f.delivery(t, done, logTarget.ID, database.DeliveryStatusDelivered),
 		0, 1500*time.Millisecond,
 	)
 	waiting := f.event(t, "text/plain", "{}", receivedAt)
 	f.delivery(t, waiting, logTarget.ID, database.DeliveryStatusPending)
 	body := f.render(t)
 	assert.Contains(
 		t, body,
 		`<span title="`+receivedAt.Format(time.DateTime)+
 			` UTC">3 minutes ago</span>`,
 	)
 	assert.Contains(t, body, `<span title="Body size">2.0 kB</span>`)
 	assert.Contains(t, body, ">1.5s</span>")
 	assert.Contains(t, body, ">in progress</span>")
 }
 // TestHandleSourceDetail_StatusWithSingleHTTPTarget proves that a
 // webhook with exactly one HTTP target shows, colour-coded, what
 // that target answered for each event. The log target beside it
 // does not count against "exactly one".
 func TestHandleSourceDetail_StatusWithSingleHTTPTarget(t *testing.T) {
 	t.Parallel()
 	f := newRecentEventsFixture(t)
 	target := seedTarget(t, f.db, f.webhook.ID, database.TargetTypeHTTP)
 	seedTarget(t, f.db, f.webhook.ID, database.TargetTypeLog)
 	now := time.Now()
 	for _, code := range []int{204, 302, 404, 503, 0} {
 		dlv := f.delivery(
 			t, f.event(t, contentTypeJSON, "{}", now), target.ID,
 			database.DeliveryStatusDelivered,
 		)
 		f.attempt(t, dlv, code, time.Second)
 	}
 	f.delivery(
 		t, f.event(t, contentTypeJSON, "{}", now), target.ID,
 		database.DeliveryStatusPending,
 	)
 	f.event(t, contentTypeJSON, "{}", now)
 	// A replay is a newer delivery, and its answer is the one shown.
 	replayed := f.event(t, contentTypeJSON, "{}", now)
 	f.attempt(t, f.delivery(
 		t, replayed, target.ID, database.DeliveryStatusFailed,
 	), 502, time.Second)
 	f.attempt(t, f.deliveryQueuedAt(
 		t, replayed, target.ID, database.DeliveryStatusDelivered,
 		now.Add(time.Minute),
 	), 200, time.Second)
 	body := f.render(t)
 	assert.Contains(t, body, statusCell("text-green-600", "204"))
 	assert.Contains(t, body, statusCell("text-gray-500", "302"))
 	assert.Contains(t, body, statusCell("text-yellow-600", "404"))
 	assert.Contains(t, body, statusCell("text-red-600", "503"))
 	assert.Contains(t, body, statusCell("text-red-600", "no response"))
 	assert.Contains(t, body, statusCell("text-gray-400", "pending"))
 	assert.Contains(t, body, statusCell("text-gray-400", "not sent"))
 	assert.Contains(t, body, statusCell("text-green-600", "200"))
 	assert.NotContains(t, body, ">502<")
 }
 // TestHandleSourceDetail_NoStatusWithoutSingleHTTPTarget proves the
 // status column is absent when the webhook has no HTTP target or
 // more than one.
 func TestHandleSourceDetail_NoStatusWithoutSingleHTTPTarget(
 	t *testing.T,
 ) {
 	t.Parallel()
 	cases := map[string][]database.TargetType{
 		"none":    {database.TargetTypeLog},
 		"several": {database.TargetTypeHTTP, database.TargetTypeHTTP},
 	}
 	for name, types := range cases {
 		t.Run(name, func(t *testing.T) {
 			t.Parallel()
 			f := newRecentEventsFixture(t)
 			event := f.event(t, contentTypeJSON, "{}", time.Now())
 			for _, tt := range types {
 				target := seedTarget(t, f.db, f.webhook.ID, tt)
 				f.attempt(t, f.delivery(
 					t, event, target.ID,
 					database.DeliveryStatusDelivered,
 				), 200, time.Second)
 			}
 			body := f.render(t)
 			assert.Contains(t, body, `title="Body size"`)
 			assert.NotContains(t, body, statusTitle)
 		})
 	}
 }
 // TestHandleWebhook_RecordsBodySize proves the receiver records the
 // body's size in bytes, not characters, with the event it stores.
 func TestHandleWebhook_RecordsBodySize(t *testing.T) {
 	t.Parallel()
 	f := newRecentEventsFixture(t)
 	seedEntrypoint(t, f.db, f.webhook.ID)
 	// Two bytes per character.
 	body := strings.Repeat("é", 1024)
 	req := httptest.NewRequestWithContext(
 		context.Background(), http.MethodPost, "/webhook/x",
 		strings.NewReader(body),
 	)
 	rctx := chi.NewRouteContext()
 	rctx.URLParams.Add("uuid", "ep-"+f.webhook.ID)
 	req = req.WithContext(context.WithValue(
 		req.Context(), chi.RouteCtxKey, rctx,
 	))
 	w := httptest.NewRecorder()
 	f.h.HandleWebhook().ServeHTTP(w, req)
 	require.Equal(t, http.StatusOK, w.Code)
 	var stored database.Event
 	require.NoError(t, f.webhookDB.First(&stored).Error)
 	assert.Equal(t, int64(2048), stored.BodyBytes)
 }
 // TestHandleSourceDetail_FailedLoadIsAnError proves that when the
 // list cannot be loaded the page answers with an error, rather than
 // an empty list claiming the webhook has no events.
 func TestHandleSourceDetail_FailedLoadIsAnError(t *testing.T) {
 	t.Parallel()
 	f := newRecentEventsFixture(t)
 	target := seedTarget(t, f.db, f.webhook.ID, database.TargetTypeHTTP)
 	f.attempt(t, f.delivery(
 		t, f.event(t, contentTypeJSON, "{}", time.Now()), target.ID,
 		database.DeliveryStatusDelivered,
 	), 200, time.Second)
 	// The attempts are the list's last query, so its events and
 	// deliveries have already loaded when it fails.
 	require.NoError(t, f.webhookDB.Exec(
 		"DROP TABLE delivery_results",
 	).Error)
 	w := serveSourceDetailPage(t, f.h, f.sess, f.webhook.ID)
 	assert.Equal(t, http.StatusInternalServerError, w.Code)
 	assert.NotContains(t, w.Body.String(), "No events received yet.")
 }
@@ -62,23 +62,6 @@ func renderSourceDetailPage(
 ) string {
 	t.Helper()
 	w := serveSourceDetailPage(t, h, sess, webhookID)
 	require.Equal(t, http.StatusOK, w.Code)
 	return w.Body.String()
 }
 // serveSourceDetailPage runs the real source detail handler for a
 // webhook and returns its response, whatever its status.
 func serveSourceDetailPage(
 	t *testing.T,
 	h *handlers.Handlers,
 	sess *session.Session,
 	webhookID string,
 ) *httptest.ResponseRecorder {
 	t.Helper()
 	req := httptest.NewRequestWithContext(
 		context.Background(),
 		http.MethodGet,
@@ -104,7 +87,9 @@ func serveSourceDetailPage(
 	w := httptest.NewRecorder()
 	h.HandleSourceDetail().ServeHTTP(w, req)
-	return w
+	require.Equal(t, http.StatusOK, w.Code)
 	return w.Body.String()
 }
 // TestHandleSourceDetail_MasksSlackWebhookURL is the
@@ -415,23 +415,16 @@ func (h *Handlers) renderSourceDetail(
 		"webhook_id = ?", webhook.ID,
 	).Find(&targets)
-	var events []RecentEventView
+	var events []database.Event
 	if h.dbMgr.DBExists(webhook.ID) {
-		webhookDB, err := h.dbMgr.GetDB(webhook.ID)
+		webhookDB, dbErr := h.dbMgr.GetDB(webhook.ID)
-		if err != nil {
+		if dbErr == nil {
-			h.serverError(w, "failed to get webhook database", err)
+			webhookDB.Where(
-
+				"webhook_id = ?", webhook.ID,
-			return
+			).Order("created_at DESC").Limit(
-		}
+				recentEventLimit,
-
+			).Find(&events)
 		events, err = loadRecentEvents(
 			webhookDB, webhook.ID, singleHTTPTargetID(targets),
 		)
 		if err != nil {
 			h.serverError(w, "failed to load recent events", err)
 			return
 		}
 	}
@@ -230,7 +230,6 @@ func (s eventSource) event() *database.Event {
 		Method:            s.Method,
 		Headers:           s.HeadersJSON,
 		Body:              string(s.Body),
 		BodyBytes:         int64(len(s.Body)),
 		ContentType:       s.ContentType,
 		ResubmittedFromID: s.ResubmittedFromID,
 	}
@@ -108,10 +108,10 @@ type failureWindow struct {
 //
 // A limiter that spends budget on arrival cannot protect a
 // single-admin product: behind the reverse proxy the deployment
-// requires, when TRUSTED_PROXIES does not cover it, every client
+// requires, with TRUSTED_PROXIES unset, every client keys on the
-// keys on the proxy, so a stranger trickling five POSTs a minute
+// proxy, so a stranger trickling five POSTs a minute keeps the one
-// keeps the one bucket full and the operator's own correct password
+// bucket full and the operator's own correct password is answered 429
-// is answered 429 forever. There is no second administrative path.
+// forever. There is no second administrative path.
 //
 // So budget is spent only by a FAILED verification. A correct
 // password is never throttled, whatever the counters say, which is
@@ -6,6 +6,7 @@ import (
 	"log/slog"
 	"net"
 	"net/http"
 	"net/url"
 	"sync"
 	"time"
@@ -366,6 +367,24 @@ func (s *Middleware) CORS() func(http.Handler) http.Handler {
 	}
 }
 // NextParam is the query parameter on the login redirect, and the
 // login form field, that holds the page to return to after login.
 const NextParam = "next"
 // loginURL is the login page RequireAuth redirects to. A GET carries
 // its own path and query in NextParam so that logging in returns to
 // it; HandleLoginSubmit decides whether that value is safe to follow.
 // Other methods carry nothing, since a redirect cannot repeat them.
 func loginURL(r *http.Request) string {
 	if r.Method != http.MethodGet {
 		return "/pages/login"
 	}
 	return "/pages/login?" + url.Values{
 		NextParam: {r.URL.RequestURI()},
 	}.Encode()
 }
 // RequireAuth returns middleware that checks for a valid session.
 // Unauthenticated users are redirected to the login page.
 func (s *Middleware) RequireAuth() func(http.Handler) http.Handler {
@@ -381,7 +400,7 @@ func (s *Middleware) RequireAuth() func(http.Handler) http.Handler {
 					"error", err,
 				)
 				http.Redirect(
-					w, r, "/pages/login", http.StatusSeeOther,
+					w, r, loginURL(r), http.StatusSeeOther,
 				)
 				return
@@ -409,7 +428,7 @@ func (s *Middleware) RequireAuth() func(http.Handler) http.Handler {
 					),
 				)
 				http.Redirect(
-					w, r, "/pages/login", http.StatusSeeOther,
+					w, r, loginURL(r), http.StatusSeeOther,
 				)
 				return
@@ -338,6 +338,42 @@ func TestRequireAuth_NoSession_RedirectsToLogin(t *testing.T) {
 			"unauthenticated request",
 	)
 	assert.Equal(t, http.StatusSeeOther, w.Code)
 	assert.Equal(
 		t, "/pages/login?next=%2Fdashboard", w.Header().Get("Location"),
 	)
 }
 // TestRequireAuth_LoginRedirectCarriesOnlyAGet pins what the login
 // redirect carries: a GET's path and query, so logging in can return
 // there, and nothing for a POST, which a redirect cannot repeat.
 func TestRequireAuth_LoginRedirectCarriesOnlyAGet(t *testing.T) {
 	t.Parallel()
 	m, _ := testMiddleware(t, config.EnvironmentDev)
 	handler := m.RequireAuth()(http.HandlerFunc(
 		func(_ http.ResponseWriter, _ *http.Request) {},
 	))
 	get := httptest.NewRequestWithContext(
 		context.Background(),
 		http.MethodGet, "/source/abc/logs?page=2", nil,
 	)
 	w := httptest.NewRecorder()
 	handler.ServeHTTP(w, get)
 	assert.Equal(
 		t, "/pages/login?next=%2Fsource%2Fabc%2Flogs%3Fpage%3D2",
 		w.Header().Get("Location"),
 	)
 	post := httptest.NewRequestWithContext(
 		context.Background(),
 		http.MethodPost, "/source/abc/delete", nil,
 	)
 	w = httptest.NewRecorder()
 	handler.ServeHTTP(w, post)
 	assert.Equal(t, "/pages/login", w.Header().Get("Location"))
 }
@@ -443,7 +479,9 @@ func TestRequireAuth_UnauthenticatedSession_RedirectsToLogin(
 			"unauthenticated session",
 	)
 	assert.Equal(t, http.StatusSeeOther, w.Code)
-	assert.Equal(t, "/pages/login", w.Header().Get("Location"))
+	assert.Equal(
 		t, "/pages/login?next=%2Fdashboard", w.Header().Get("Location"),
 	)
 }
 // --- RequireAuth Session Expiry Tests ---
@@ -541,7 +579,9 @@ func TestRequireAuth_IdleExpiredSession_RedirectsToLogin(
 		"handler should not run for an idle-expired session",
 	)
 	assert.Equal(t, http.StatusSeeOther, w.Code)
-	assert.Equal(t, "/pages/login", w.Header().Get("Location"))
+	assert.Equal(
 		t, "/pages/login?next=%2Fdashboard", w.Header().Get("Location"),
 	)
 	assert.Empty(
 		t, sessionCookies(w),
 		"an expired session must not be refreshed",
@@ -123,8 +123,9 @@ func bucketKey(addr netip.Addr) string {
 	return prefix.String()
 }
-// isTrustedProxy reports whether addr belongs to a network in
+// isTrustedProxy reports whether addr belongs to a network the
-// TRUSTED_PROXIES, which by default is the RFC 1918 private ranges.
+// operator listed in TRUSTED_PROXIES. The list is empty by default,
 // so by default nothing is trusted.
 func (m *Middleware) isTrustedProxy(addr netip.Addr) bool {
 	for _, prefix := range m.params.Config.TrustedProxies {
 		if prefix.Contains(addr) {
@@ -384,8 +384,8 @@ const (
 	// trustedProxyCIDR is the proxy network the forwarded-path
 	// tests configure, and trustedPeer an address inside it. A
 	// production deployment is required to run behind a reverse
-	// proxy that TRUSTED_PROXIES covers, either by the default or by
+	// proxy with TRUSTED_PROXIES set, so this is the shape the
-	// a set value, so this is the shape the bucketing has to hold in.
+	// bucketing has to hold in.
 	trustedProxyCIDR = "10.0.0.0/8"
 	trustedPeer      = "10.0.0.1:44444"
 )
@@ -426,8 +426,8 @@ func assertSharedBucket(
 }
 // TestRateLimitKey_SpoofedForwardedFromUntrustedPeer is the test
-// this gating exists for: from a peer that is not a trusted
+// this gating exists for: with no trusted proxies configured (the
-// proxy, a client that rotates a forwarded header on every
+// default), a client that rotates a forwarded header on every
 // request must stay in one bucket. If forwarded headers were
 // trusted unconditionally, each spoofed value would mint a fresh
 // bucket and the limit would stop no one.
@@ -1097,9 +1097,8 @@ func TestPostRateLimit_IPv4IndependentPerAddress(t *testing.T) {
 // that arrives from trustedPeer — a configured trusted proxy — and
 // names forwarded as its client in X-Forwarded-For. That is the
 // production path: a deployment is required to run behind a reverse
-// proxy that TRUSTED_PROXIES covers, either by the default or by a
+// proxy with TRUSTED_PROXIES set, so the forwarded address, not the
-// set value, so the forwarded address, not the peer, is what the
+// peer, is what the limiters bucket on there.
 // limiters bucket on there.
 func forwardedKeyFor(
 	t *testing.T, m *middleware.Middleware, forwarded string,
 ) string {
@@ -1179,9 +1178,9 @@ func TestRateLimitKey_ForwardedIPv6BucketsByPrefix(t *testing.T) {
 //
 // Every existing test of this fallback uses an IPv4 proxy, where
 // bucketKey is the identity function, so replacing the call with
-// peer.String() leaves the whole suite green. Only addresses inside
+// peer.String() leaves the whole suite green. Only operator-listed
-// TRUSTED_PROXIES reach this line and the fallback is fail-closed, so
+// addresses reach this line and the fallback is fail-closed, so this
-// this pins behaviour rather than fixing a defect.
+// pins behaviour rather than fixing a defect.
 func TestRateLimitKey_TrustedPeerUnusableForwardedMasksPeer(
 	t *testing.T,
 ) {
@@ -154,12 +154,11 @@ func (s *Server) setupPageRoutes() {
 		r.Use(s.mw.NoCache())
 		// The login POST carries no pre-emptive rate limiter. Behind
-		// the reverse proxy production requires, when TRUSTED_PROXIES
+		// the reverse proxy production requires, with TRUSTED_PROXIES
-		// does not cover it, every client shares one bucket, so a
+		// unset, every client shares one bucket, so a limiter spent
-		// limiter spent on arrival lets any stranger deny the operator
+		// on arrival lets any stranger deny the operator the only
-		// the only administrative path. The handler verifies
+		// administrative path. The handler verifies credentials first
-		// credentials first and charges only failures; see
+		// and charges only failures; see Handlers.authenticateUser.
 		// Handlers.authenticateUser.
 		r.Get("/login", s.h.HandleLoginPage())
 		r.Post("/login", s.h.HandleLoginSubmit())
@@ -680,6 +680,44 @@ func TestPagesLogin_CookiesFromAnEarlierDatabase(t *testing.T) {
 	)
 }
 // TestPagesLogin_ReturnsToTheRequestedPage is
 // https://git.eeqj.de/sneak/webhooker/issues/384: a page opened while
 // logged out leads to the login page, and logging in from there lands
 // on that page, query included.
 func TestPagesLogin_ReturnsToTheRequestedPage(t *testing.T) {
 	t.Parallel()
 	const (
 		username = "operator"
 		password = "correct-horse-battery-staple"
 	)
 	env := newTestEnv(t)
 	userID, _ := env.seedUser(t, username, password)
 	asked := "/source/" + env.seedWebhook(t, userID).ID + "/logs?page=2"
 	bounced := env.get(asked, nil)
 	require.Equal(t, http.StatusSeeOther, bounced.Code)
 	loginPage := bounced.Header().Get("Location")
 	match := regexp.MustCompile(`name="next" value="([^"]*)"`).
 		FindStringSubmatch(env.get(loginPage, nil).Body.String())
 	require.Len(t, match, 2, "the login form must carry the page")
 	token, cookies := env.csrfFrom(t, loginPage, nil)
 	form := url.Values{}
 	form.Set("csrf_token", token)
 	form.Set("username", username)
 	form.Set("password", password)
 	form.Set("next", html.UnescapeString(match[1]))
 	w := env.post("/pages/login", form, cookies)
 	require.Equal(t, http.StatusSeeOther, w.Code)
 	assert.Equal(t, asked, w.Header().Get("Location"))
 }
 // --- /user/{username} group ---
 // TestPasswordChange_OversizeBody_RejectedAndPasswordUnchanged
@@ -830,7 +868,10 @@ func TestSourceLogsBody_OtherUser404s(t *testing.T) {
 	anon := env.get(path, nil)
 	assert.Equal(t, http.StatusSeeOther, anon.Code)
-	assert.Equal(t, "/pages/login", anon.Header().Get("Location"))
+	assert.Equal(
 		t, "/pages/login?next="+url.QueryEscape(path),
 		anon.Header().Get("Location"),
 	)
 }
 // TestDeliveryReplay_PostOnlyAndCSRFProtected walks the replay action
@@ -24,6 +24,7 @@
            <form method="POST" action="/pages/login" class="space-y-6">
                <input type="hidden" name="csrf_token" value="{{.CSRFToken}}">
                <input type="hidden" name="next" value="{{.Next}}">
                <div class="form-group">
                    <label for="username" class="label">Username</label>
                    <input
@@ -6,12 +6,14 @@
        </div>
        <!-- Mobile menu button -->
        {{if .User}}
        <button @click="open = !open" class="md:hidden p-2 rounded-md text-gray-500 hover:bg-gray-100">
            <svg class="w-6 h-6" fill="none" stroke="currentColor" viewBox="0 0 24 24">
                <path x-show="!open" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 6h16M4 12h16M4 18h16"/>
                <path x-show="open" x-cloak stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12"/>
            </svg>
        </button>
        {{end}}
        <!-- Desktop navigation -->
        <div class="hidden md:flex items-center gap-4">
@@ -28,8 +30,6 @@
                <input type="hidden" name="csrf_token" value="{{.CSRFToken}}">
                <button type="submit" class="btn-text">Logout</button>
            </form>
            {{else}}
            <a href="/pages/login" class="btn-primary">Login</a>
            {{end}}
        </div>
    </div>
@@ -44,8 +44,6 @@
                <input type="hidden" name="csrf_token" value="{{.CSRFToken}}">
                <button type="submit" class="btn-text w-full text-left">Logout</button>
            </form>
            {{else}}
            <a href="/pages/login" class="btn-primary w-full">Login</a>
            {{end}}
        </div>
    </div>
@@ -181,30 +181,18 @@
    <!-- Recent Events -->
    <div class="card mt-6">
        <div class="p-4 border-b border-gray-200 flex justify-between items-center">
-            <h2 class="text-lg font-medium text-gray-900">50 Most Recent Events</h2>
+            <h2 class="text-lg font-medium text-gray-900">Recent Events</h2>
            <a href="/source/{{.Webhook.ID}}/logs" class="btn-text text-sm">View All</a>
        </div>
        <div class="divide-y divide-gray-100">
            {{range .Events}}
            <div class="p-4">
-                <div class="flex flex-wrap items-center justify-between gap-3">
+                <div class="flex items-center justify-between">
-                    <div class="flex flex-wrap items-center gap-3">
+                    <div class="flex items-center gap-3">
                        <span class="badge-info">{{.Method}}</span>
-                        <span class="text-sm text-gray-500 break-all">{{.ContentType}}</span>
+                        <span class="text-sm text-gray-500">{{.ContentType}}</span>
                        {{if .ResubmittedFromID}}
                        <span class="text-xs text-gray-500" title="This event is a copy of {{.ResubmittedFromID}}">resubmitted copy</span>
                        {{end}}
                    </div>
                    <div class="flex flex-wrap items-center gap-3 text-xs text-gray-400">
                        <span title="Body size">{{.Size}}</span>
                        {{if .ProcessingTime}}
                        <span title="Processing time: how long the slowest delivery took, from being queued to its last attempt">{{.ProcessingTime}}</span>
                        {{end}}
                        {{if .Status}}
                        <span class="font-medium {{.StatusClass}}" title="HTTP status from the HTTP target">{{.Status}}</span>
                        {{end}}
                        <span title="{{.ReceivedUTC}}">{{.Received}}</span>
                    </div>
                    <span class="text-xs text-gray-400">{{.CreatedAt.Format "2006-01-02 15:04:05 UTC"}}</span>
                </div>
            </div>
            {{else}}