Use one recovery routine at start and on every sweep tick (closes #542)

Start-up recovery and the 60-second sweep were two parallel sets of
functions doing the same job. recoverDeliveries now does it, run once at
start and then on every tick from one goroutine. A retrying delivery is
scheduled after what is left of its backoff, now if nothing is left, so
backoffElapsed is gone. The run at start still takes every pending
delivery and opens a webhook database whose file is missing; a tick
still takes only pending deliveries untouched for 15 minutes, at most
500, and skips a missing file. A retrying delivery is taken before its
event is read. The README describes one routine.

Model: opus-5-5

Dockerfile

@@ -76,8 +76,6 @@ RUN --network=none node_modules/.bin/prettier --check '**/*.md'
 # depends on it.
 #
 # golangci/golangci-lint:v2.14.0 (Debian-based), 2026-09-24
-# Using Debian-based image because mattn/go-sqlite3 (CGO) does not
-# compile on Alpine musl (off64_t is a glibc type).
 FROM golangci/golangci-lint:v2.14.0@sha256:ad862ba6b3798cbe0fd9fd7408d498fd74fbd2623a92406b2fd3898faf0bf98f AS lint
 
 WORKDIR /src
@@ -167,9 +165,7 @@ RUN --mount=type=tmpfs,target=/tmp/tests,size=512m \
 
 # Build stage
 # golang:1.26.1-bookworm (Debian-based), 2026-03-17
-# Using Debian-based image because gorm.io/driver/sqlite pulls in
+# The image ships git and make, which the version step below uses.
-# mattn/go-sqlite3 (CGO), which does not compile on Alpine musl. The image
-# ships git and make, which the version step below uses.
 FROM golang:1.26.1-bookworm@sha256:4465644228bc2857a954b092167e12aa59c006a3492282a6c820bf4755fd64a4 AS builder
 
 # Nothing is wanted from the lint and test phases or from the stylesheet and
@@ -211,26 +207,11 @@ RUN version="$(make version VERSION="$VERSION")"; \
     fi
 
 # Builds through the Makefile's build target, which runs script/assets
-# (Alpine.js, extracted from its tarball in 3p/) first.
+# (Alpine.js, extracted from its tarball in 3p/) first. The target builds
+# with cgo off, so the binary is statically linked and runs on the Alpine
+# runtime image below as it is.
 RUN make build VERSION="$VERSION"
 
-# Rebuild with static linking for the Alpine runtime. The cgo binary the
-# step above builds is dynamically linked against glibc, which Alpine
-# (musl) does not have.
-#
-# A statically linked glibc still loads shared libraries at run time for
-# getaddrinfo and dlopen, and Alpine has none to load, so the build tags
-# keep both out of the binary: netgo and osusergo select Go's own DNS
-# resolver and user lookup instead of glibc's, and
-# sqlite_omit_load_extension leaves out SQLite extension loading, which
-# webhooker never uses.
-#
-# The static flags and tags go in through GO_LDFLAGS and GO_TAGS rather
-# than a -ldflags of their own: the build target composes them with the
-# -X that stamps the version, so this relink cannot silently drop the
-# stamp.
-RUN CGO_ENABLED=1 make build VERSION="$VERSION" GO_TAGS=netgo,osusergo,sqlite_omit_load_extension GO_LDFLAGS='-extldflags "-static"'
-
 # Runtime stage
 # alpine:3.21, 2026-03-17
 FROM alpine:3.21@sha256:c3f8e73fdb79deaebaa2037150150191b9dcbfba68b4a46d70103204c53f4709
@@ -274,8 +255,17 @@ EXPOSE 8080
 # port.
 ENV BIND_ADDRESS=0.0.0.0
 
+# The probe requests the container's own address, not loopback, so a
+# listener that answers only on loopback (an empty or loopback
+# BIND_ADDRESS) fails it. On a network with IPv4, hostname -i prints the
+# container's IPv4 address, which 0.0.0.0 and :: both answer. On an
+# IPv6-only network it prints none, and the probe requests the IPv6
+# address /etc/hosts lists under the container's hostname instead, which
+# only :: answers.
 HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
-    CMD wget --no-verbose --tries=1 --spider http://localhost:8080/.well-known/healthcheck || exit 1
+    CMD addr="$(hostname -i 2>/dev/null | cut -d ' ' -f 1)"; \
+        [ -n "$addr" ] || addr="[$(getent hosts "$(hostname)" | cut -d ' ' -f 1)]"; \
+        wget --no-verbose --tries=1 --spider "http://$addr:8080/.well-known/healthcheck" || exit 1
 
 ENTRYPOINT ["/usr/local/bin/docker-entrypoint.sh"]
 CMD ["/app/webhooker"]

Makefile

@@ -16,17 +16,6 @@ VERSION ?= $(shell script/version)
 # exists to correct.
 override VERSION := $(or $(strip $(VERSION)),$(shell script/version))
 
-# Extra linker flags and build tags for the build target. The static
-# relink in the Dockerfile passes -extldflags and its build tags through
-# these rather than a -ldflags of its own, so composing flags cannot drop
-# the version stamp.
-#
-# The build target itself always passes -trimpath and -s -w, as the Go
-# Dockerfile in REPO_POLICIES.md does: no build paths, symbol table or
-# debug information in the binary.
-GO_LDFLAGS ?=
-GO_TAGS ?=
-
 bootstrap:
 	@script/bootstrap
 
@@ -54,8 +43,12 @@ fmt-check:
 check:
 	@script/check
 
+# Built with cgo off, -trimpath and -s -w, as the Go Dockerfile in
+# REPO_POLICIES.md does: the binary carries no build paths, symbol table or
+# debug information, and on Linux, the image's included, it is statically
+# linked.
 build: assets
-	go build -trimpath -tags '$(GO_TAGS)' -ldflags '$(strip -s -w -X main.version=$(VERSION) $(GO_LDFLAGS))' -o bin/webhooker ./cmd/webhooker
+	CGO_ENABLED=0 go build -trimpath -ldflags '-s -w -X main.version=$(VERSION)' -o bin/webhooker ./cmd/webhooker
 
 run: build
 	./bin/webhooker

README.md

@@ -310,16 +310,17 @@ the namespace, whatever the process bound. Exposure is decided at the publish
 flag instead — `-p 127.0.0.1:8080:8080` rather than `-p 8080:8080` — which is
 the operator's to choose and is what [Running with Docker](#running-with-docker)
 shows. A loopback bind inside a container buys nothing and makes the process
-unreachable through its own published port.
+unreachable through its own published port. A container on an IPv6-only Docker
+network has no IPv4 address for `0.0.0.0` to answer on, so there it needs
+`BIND_ADDRESS=::`.
 
 The value must be an IP address literal:
 
 - `127.0.0.1` — loopback only (the binary's default). Use this with a reverse
   proxy on the same host.
-- `0.0.0.0` — every IPv4 address. The image's default; on a bare host, only
+- `0.0.0.0` — every IPv4 address and no IPv6 address. The image's default; on a
-  behind a firewall on the port.
+  bare host, only behind a firewall on the port.
-- `::` — every address, IPv6 and (on Linux, with the default
+- `::` — every IPv6 address and every IPv4 address.
-  `net.ipv6.bindv6only=0`) IPv4 as well.
 - A specific address such as `10.0.0.5` — that interface only.
 
 An **empty** value is treated as unset, as everywhere else here, and takes the
@@ -340,7 +341,8 @@ machine that has no such interface — is a valid literal, so it reaches the
 listener and fails there. The process logs the bind error and exits non-zero
 rather than staying up with nothing listening. The effective value is in the
 `bindAddress` field of the startup log line, which is the way to check what a
-running deployment actually bound.
+running deployment actually bound. On a bare host, `ss -ltn` lists the socket
+itself as `0.0.0.0:8080` for a `0.0.0.0` bind and as `*:8080` for `::`.
 
 #### Metrics credentials
 
@@ -668,9 +670,9 @@ Either set a literal or leave the variable out entirely.
 Overriding `BIND_ADDRESS` to a loopback address in a container — by that route
 or deliberately — makes the container unreachable from outside its namespace
 even with `-p`. The published port answers nothing, and the health check fails
-too: it requests `http://localhost:8080`, `localhost` resolves to `::1` first,
+too: it requests the container's own address (its IPv4 address, or its IPv6
-and a `127.0.0.1` bind is not listening there. The container then goes
+address on an IPv6-only network), where a loopback bind is not listening. The
-`unhealthy` about **65 seconds** after start — from
+container then goes `unhealthy` about **65 seconds** after start — from
 `HEALTHCHECK --start-period=5s --interval=30s --retries=3`, so failing probes at
 5s, 35s and 65s, and `unhealthy` on the third. (Docker's probe cadence during
 the start period has changed between versions; re-derive from those three values
@@ -726,8 +728,8 @@ the credentials.
       address (directly, or through anything 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
+      that address; the health check's own lines show the container's own
-      [Trusted proxies](#trusted-proxies).
+      address. 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`.
     - Everything else is optional; see [Configuration](#configuration).
@@ -802,7 +804,12 @@ comes up, serves pages, and is broken in a way nothing reports.
    proxy's log names it regardless. nginx's default `combined` format already
    logs `$remote_addr`; do not replace it with one that drops the client
    address, and retain those logs as long as you would want to answer a question
-   about traffic.
+   about traffic. That log also records the full request path, so it holds the
+   entrypoint UUID of every event a sender posts. webhooker's own log does not,
+   apart from the line a `log` target writes. Protect the proxy's log as you
+   would the entrypoint URLs themselves: anyone who can read it can post events
+   to every entrypoint in it (see
+   [The entrypoint URL is the authentication secret](#the-entrypoint-url-is-the-authentication-secret)).
 
 ### nginx
 
@@ -828,7 +835,9 @@ server {
     client_max_body_size 1m;
 
     # $remote_addr is the client. webhooker's own log names it, as
-    # clientIP, only while TRUSTED_PROXIES covers this proxy.
+    # clientIP, only while TRUSTED_PROXIES covers this proxy. The
+    # request path in this log holds the entrypoint UUID, so protect
+    # the file like the entrypoint URL itself.
     access_log /var/log/nginx/webhooker.access.log combined;
 
     location / {
@@ -1160,7 +1169,16 @@ What that means for an operator:
 
 - **The URL is a capability, so treat it as a secret.** Keep it out of logs,
   ticket bodies, chat messages and screenshots. Anyone who reads it anywhere can
-  post events as that sender.
+  post events as that sender. Apart from a `log` target's line, webhooker's own
+  log lines never carry the UUID: they name a request to the receiver by the
+  route pattern `/h/{uuid}`, the `webhook request received` line names the
+  entrypoint by its `entrypoint_id`, and the access log keeps only the scheme
+  and host of a `Referer`. A `log` target writes the request's headers as
+  received, so a `Referer` naming the entrypoint URL appears in its line, as it
+  does when a sender has followed a redirect from `http://` to `https://`. The
+  reverse proxy's access log does carry the UUID, in the request path, so it
+  must be protected like the URL itself (see
+  [Deployment behind a reverse proxy](#deployment-behind-a-reverse-proxy)).
 - **Rotating means minting a new entrypoint, not changing a key.** There is no
   way to rotate the UUID in place. To retire one, delete the entrypoint (or
   deactivate it, which answers `410`) and create a new one, then point the
@@ -1235,34 +1253,37 @@ markup. The CSP build runs no expressions, so every Alpine directive in
 `static/js/app.js`: `x-data="collapsible"` and `@click="toggle"`, never
 `x-data="{ open: false }"` or `@click="open = !open"`.
 
-A browser test in `internal/server` loads the webhook page, its edit pages and
+A browser test in `internal/server` loads the sign-in page, the webhook page,
-the event log under the real policy and checks that: the add entrypoint form
+its edit pages, the event log, the webhook list, the settings page, the profile
-stays hidden until Add is clicked; for every target type, the targets section's
+page and the `404` error page shown for a path that does not exist, under the
-Add shows only a choice of type with Next and Cancel, Next shows only that
+real policy and checks that: the add entrypoint form stays hidden until Add is
-type's fields (no url field for `database` or `log`), Cancel at either step
+clicked; for every target type, the targets section's Add shows only a choice of
-closes the form, and saving adds the target; a refused target comes back with
+type with Next and Cancel, Next shows only that type's fields (no url field for
-its form open, the values entered and the reason, and after Cancel the next Add
+`database` or `log`), Cancel at either step closes the form, and saving adds the
-starts with an empty form and no reason; a refused save on the target edit page
+target; a refused target comes back with its form open, the values entered and
-and on the webhook edit page comes back with the reason and every value entered;
+the reason, and after Cancel the next Add starts with an empty form and no
-the Copy button beside an entrypoint URL reads "Copied" once clicked; an
+reason; a refused save on the target edit page and on the webhook edit page
-entrypoint's Edit button shows its edit form in place of its description and
+comes back with the reason and every value entered; the Copy button beside an
-hides until the form closes, Cancel hides the form and drops what was typed, as
+entrypoint URL reads "Copied" once clicked; an entrypoint's Edit button shows
-does leaving the page and going back to it, and Save changes the description; of
+its edit form in place of its description and hides until the form closes,
-the recent events on the webhook page only the newest starts expanded, each
+Cancel hides the form and drops what was typed, as does leaving the page and
-expands and collapses, and Open leads to the event's own page; of the events in
+going back to it, and Save changes the description; of the recent events on the
-the event log only the newest starts expanded, and an event there expands and
+webhook page only the newest starts expanded, each expands and collapses, and
-collapses when its row's caret or its ID is clicked, and from the keyboard, but
+Open leads to the event's own page; of the events in the event log only the
-not when its ID is selected with the mouse, and a delivery's attempts inside it
+newest starts expanded, and an event there expands and collapses when its row's
-expand and collapse; and at phone width the menu button opens and closes the
+caret or its ID is clicked, and from the keyboard, but not when its ID is
-mobile menu, and neither the webhook page nor the event log, with a delivery's
+selected with the mouse, and a delivery's attempts inside it expand and
-attempts open, scrolls sideways or cuts anything off at the page's or a card's
+collapse; at phone width the menu button opens and closes the mobile menu, and
-edge. It also fails if the browser reports a console warning or error, an
+neither the webhook page nor the event log, with a delivery's attempts open,
-uncaught exception, or anything the policy refused. `make check` and the image
+scrolls sideways or cuts anything off at the page's or a card's edge; and a
-build lint it but do not run it, and `make test` leaves it out (its file is
+target's Delete asks first, naming the target, sends nothing when the answer is
-built only with the `browser` build tag). Run it with `make test-browser` after
+no and deletes the target when it is yes. It also fails if the browser reports a
-changing `templates/` or `static/js/`: that builds `Dockerfile.browser`, which
+console warning or error, an uncaught exception, or anything the policy refused.
-runs the test in a digest-pinned headless browser image, so the host needs no
+`make check` and the image build lint it but do not run it, and `make test`
-browser.
+leaves it out (its file is built only with the `browser` build tag). Run it with
+`make test-browser` after changing `templates/` or `static/js/`: that builds
+`Dockerfile.browser`, which runs the test in a digest-pinned headless browser
+image, so the host needs no browser.
 
 The package's tarball is committed as `3p/alpinejs-csp-3.14.9.tgz`, byte for
 byte as the npm registry publishes it. It is a dependency, not this repo's build
@@ -1295,7 +1316,9 @@ and commit the regenerated file with the change. Tailwind takes classes only
 from the files that `input.css` names in its `@source` lines; a class written in
 any other file is not generated until that file is named there too. `make check`
 and the image build fail when the committed file differs from what `make css`
-generates. `static/css/style.css` is hand-written and is not generated.
+generates. `static/css/style.css` is hand-written and is not generated. The
+pages' Content-Security-Policy refuses inline styles, so a template styles an
+element with a class, never a `style` attribute.
 
 `make css` runs the Tailwind standalone CLI in Docker, at the version and sha256
 pinned in the Dockerfile's stylesheet stages; it is never installed on the host.
@@ -1317,20 +1340,22 @@ webhooker solves this by acting as a durable intermediary:
    nothing is lost if downstream targets are unavailable.
 
 2. **Guaranteed delivery** — Events are queued for delivery to each configured
-   target. Failed deliveries are retried with configurable backoff. Every
+   target. Failed deliveries are retried with configurable backoff. Delivery
-   delivery attempt is logged with status codes, response bodies, and timing.
+   attempts are logged with status codes, response bodies, and timing.
 
     **That guarantee is at-least-once, not exactly-once.** When a send reaches
     its target but the write recording that outcome fails, the delivery is
     deliberately left in a recoverable state rather than marked done — losing a
-    delivery is the worse failure — so the pending sweep picks it up about
+    delivery is the worse failure — so the sweep picks it up about fifteen
-    fifteen minutes later, or the next restart does, and the target receives a
+    minutes later, or the next restart does, and the target receives a payload
-    payload it already got. webhooker adds no delivery identifier of its own to
+    it already got. A send still in flight when the service stops is left the
-    an outbound request, so **make your receiver idempotent** against whatever
+    same way: its attempt is not recorded, and the next start sends it again
-    the payload itself carries.
+    (see Shutdown). webhooker adds no delivery identifier of its own to an
+    outbound request, so **make your receiver idempotent** against whatever the
+    payload itself carries.
 
 3. **Observability** — Full request/response logging for every webhook received
-   and every delivery attempted. Prometheus metrics expose volume, latency, and
+   and for delivery attempts. Prometheus metrics expose volume, latency, and
    error rates. The web UI provides real-time visibility into event flow.
 
 4. **Fan-out** — A single incoming webhook can be delivered to multiple targets
@@ -1368,10 +1393,10 @@ It uses:
   management
 - **[go-chi](https://github.com/go-chi/chi)** for HTTP routing
 - **[GORM](https://gorm.io)** for database access with
-  **[modernc.org/sqlite](https://pkg.go.dev/modernc.org/sqlite)** as the runtime
+  **[modernc.org/sqlite](https://pkg.go.dev/modernc.org/sqlite)**, which is pure
-  SQLite driver. Note: `gorm.io/driver/sqlite` transitively depends on
+  Go, as the SQLite driver. `gorm.io/driver/sqlite` also imports
-  `mattn/go-sqlite3`, which requires CGO at build time (see [Docker](#docker)
+  `mattn/go-sqlite3`, whose stub for builds without cgo is linked into the
-  section)
+  binary but never used
 - **[slog](https://pkg.go.dev/log/slog)** (stdlib) for structured logging with
   TTY detection (text for dev, JSON for prod)
 - **[gorilla/sessions](https://github.com/gorilla/sessions)** for encrypted
@@ -1494,47 +1519,35 @@ the rotation chosen below that (none, monthly, daily or hourly). Both are
 validated as on the add target form, and the webhook and its targets are created
 together or not at all.
 
-| Field            | Type    | Description                                                 |
+| Field            | Type    | Description                                   |
-| ---------------- | ------- | ----------------------------------------------------------- |
+| ---------------- | ------- | --------------------------------------------- |
-| `id`             | UUID    | Primary key                                                 |
+| `id`             | UUID    | Primary key                                   |
-| `user_id`        | UUID    | Foreign key → User                                          |
+| `user_id`        | UUID    | Foreign key → User                            |
-| `name`           | string  | Human-readable name                                         |
+| `name`           | string  | Human-readable name                           |
-| `description`    | string  | Optional description                                        |
+| `description`    | string  | Optional description                          |
-| `retention_days` | integer | Days to retain events (default: 30; 0 means retain forever) |
+| `retention_days` | integer | Days to retain events; 0 means retain forever |
 
 **Relations:** Belongs to User. Has many Entrypoints. Has many Targets.
 
 The `retention_days` field controls how long event data is kept in the webhook's
 dedicated database before automatic cleanup.
 
-Setting `retention_days` to `0` means "retain events forever". Because the
+The value is stored as entered. Setting `retention_days` to `0` means "retain
-column carries a default of 30, a literal zero cannot survive an insert, so a
+events forever": the retention reaper skips the webhook entirely, and the web UI
-zero is rewritten on save to a sentinel of `365 * 1000` days
+displays its retention as "forever" rather than as a day count.
-(`database.RetentionForeverDays`). The retention reaper recognises that sentinel
-and skips the webhook entirely, and the web UI displays such a webhook's
-retention as "forever" rather than as a day count.
 
-Submitted `retention_days` values therefore fall into three bands, not two:
+The new webhook and edit forms accept `0`, or a whole number of days from `1` up
-
+to `database.MaxFiniteRetentionDays` (106751 days, about 292 years). Anything
-- `1` up to `database.MaxFiniteRetentionDays` (106751 days, about 292 years) is
+else, a negative value or one above that cap included, is rejected with a 400. A
-  accepted as a finite retention.
+blank field gives the default of 30 days (`database.DefaultRetentionDays`) on
-- Above that ceiling but below the retain-forever sentinel of 365000
+the new webhook form, and leaves the stored value unchanged on the edit form.
-  (`database.RetentionForeverDays`) is rejected with a 400. This is the band the
-  cap exists for.
-- `0`, and `365000` or above, are accepted and mean retain forever, collapsing
-  to the sentinel — `0` in `Webhook.BeforeSave`, the large values in
-  `parseRetentionDays`. The large values are not out of range: the edit form
-  pre-fills the sentinel for a retain-forever webhook, so submitting that form
-  back unchanged has to keep meaning "forever".
-
-A negative value is in none of the three: `parseRetentionDays` rejects it with a
-400 before `BeforeSave` ever sees it.
 
 The cap is not arbitrary: the reaper computes its cutoff as a `time.Duration`,
 an int64 nanosecond count, and a longer period overflows it. An overflowed
 cutoff lands in the future, where it matches every row, so the sweep would
 delete every event the webhook has instead of none. The reaper also clamps the
-value it reads to the cap, so no stored value can trigger that either.
+value it reads to the cap, and reads a negative value as forever, so no stored
+value can trigger that either.
 
 #### Entrypoint
 
@@ -1566,29 +1579,27 @@ did not arrive on the URL and counts in neither.
 A delivery destination for events. Each target defines where and how events
 should be forwarded.
 
-| Field         | Type       | Description                                                                                                                                                                                                                                                                                                                                                 |
+| Field          | Type       | Description                                                                                                                                                                             |
-| ------------- | ---------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| -------------- | ---------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `id`          | UUID       | Primary key                                                                                                                                                                                                                                                                                                                                                 |
+| `id`           | UUID       | Primary key                                                                                                                                                                             |
-| `webhook_id`  | UUID       | Foreign key → Webhook                                                                                                                                                                                                                                                                                                                                       |
+| `webhook_id`   | UUID       | Foreign key → Webhook                                                                                                                                                                   |
-| `name`        | string     | Human-readable name                                                                                                                                                                                                                                                                                                                                         |
+| `name`         | string     | Human-readable name                                                                                                                                                                     |
-| `type`        | TargetType | One of: `http`, `slack`, `database`, `log`                                                                                                                                                                                                                                                                                                                  |
+| `type`         | TargetType | One of: `http`, `slack`, `database`, `log`                                                                                                                                              |
-| `active`      | boolean    | Whether deliveries are enabled (default: true)                                                                                                                                                                                                                                                                                                              |
+| `active`       | boolean    | Whether deliveries are enabled (default: true)                                                                                                                                          |
-| `config`      | JSON text  | Type-specific configuration                                                                                                                                                                                                                                                                                                                                 |
+| `config`       | JSON text  | Type-specific configuration                                                                                                                                                             |
-| `max_retries` | integer    | Total delivery attempts for `http` and `slack` targets, not retries on top of the first: 0 is a single fire-and-forget attempt with no retries and no circuit breaker, and a value of N makes N attempts in all, with exponential backoff and a per-target circuit breaker. Ignored by `database` and `log` targets. The web UI labels it Delivery attempts |
+| `max_attempts` | integer    | How many times an `http` or `slack` target attempts each delivery in all: at least 1, and 1 by default. Ignored by `database` and `log` targets. The web UI labels it Delivery attempts |
 
 **Relations:** Belongs to Webhook. Has many Deliveries.
 
 **Target types:**
 
-- **`http`** — Forward the event as an HTTP POST to a configured URL.
+- **`http`** — Forward the event as an HTTP POST to a configured URL. With
-  `max_retries` is the total number of delivery attempts, not retries on top of
+  `max_attempts` at 1 the target makes a single attempt; above 1 it retries a
-  the first: when `max_retries` is 0 (the default), the target operates in
+  failed delivery with exponential backoff, up to that many attempts in all,
-  fire-and-forget mode, a single attempt with no retries and no circuit breaker;
+  behind a per-target circuit breaker.
-  a value of N makes up to N attempts in all, retrying failed deliveries with
-  exponential backoff and protecting them with a per-target circuit breaker.
 - **`slack`** — Post the event as a formatted message to a Slack-compatible
   incoming webhook URL (`webhookUrl` in `config`). It is built on the same HTTP
-  core as `http` and honours `max_retries` identically, circuit breaker
+  core as `http` and honours `max_attempts` identically, circuit breaker
   included. See the Slack target section under "Per-Webhook Event Databases" for
   the message format.
 - **`database`** — Archive the full event as a row into the target's own archive
@@ -1768,7 +1779,7 @@ is what bounds it.
 #### DeliveryResult
 
 The result of a single delivery attempt. Every attempt (including retries) is
-individually logged for full observability.
+individually logged, except one cut off by a stop (see Shutdown).
 
 | Field           | Type    | Description                               |
 | --------------- | ------- | ----------------------------------------- |
@@ -1854,15 +1865,15 @@ These indexes on the per-webhook event databases are created by
 `internal/db/migrations/events/001_schema.sql`, and declared in the model tags
 to match:
 
-| Table              | Columns                                                            | Serves                                                                                                                                                                                                                                                                                                                                                                                             |
+| Table              | Columns                                                            | Serves                                                                                                                                                                                                                                                                                                                                                                             |
-| ------------------ | ------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ------------------ | ------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `deliveries`       | `status`, `deleted_at`, `finished_at`, `target_id`                 | Startup recovery, the retry and pending sweeps every 60 seconds and the queue-depth sampler every 30 seconds, which select deliveries by status, the webhook page's statistics and target list and the webhook list, which count each target's deliveries by status and when they finished, and the event log, which lists and counts the events with a failed delivery or one pending or retrying |
+| `deliveries`       | `status`, `deleted_at`, `finished_at`, `target_id`                 | Delivery recovery at start and every 60 seconds and the queue-depth sampler every 30 seconds, which select deliveries by status, the webhook page's statistics and target list and the webhook list, which count each target's deliveries by status and when they finished, and the event log, which lists and counts the events with a failed delivery or one pending or retrying |
-| `deliveries`       | `event_id`, `deleted_at`                                           | The event log, which loads each event's deliveries, and retention, which counts and deletes the deliveries of expired events                                                                                                                                                                                                                                                                       |
+| `deliveries`       | `event_id`, `deleted_at`                                           | The event log, which loads each event's deliveries, and retention, which counts and deletes the deliveries of expired events                                                                                                                                                                                                                                                       |
-| `delivery_results` | `delivery_id`, `deleted_at`                                        | The event log, which loads the attempts of a page's deliveries, and retention, which deletes the attempts of expired events                                                                                                                                                                                                                                                                        |
+| `delivery_results` | `delivery_id`, `deleted_at`                                        | The event log, which loads the attempts of a page's deliveries, and retention, which deletes the attempts of expired events                                                                                                                                                                                                                                                        |
-| `events`           | `deleted_at`, `created_at`                                         | The webhook page's statistics, which count recent events                                                                                                                                                                                                                                                                                                                                           |
+| `events`           | `deleted_at`, `created_at`                                         | The webhook page's statistics, which count recent events                                                                                                                                                                                                                                                                                                                           |
-| `events`           | `resubmitted_from_id`, `deleted_at`                                | The event log, which counts the events resubmitted from each event on a page                                                                                                                                                                                                                                                                                                                       |
+| `events`           | `resubmitted_from_id`, `deleted_at`                                | The event log, which counts the events resubmitted from each event on a page                                                                                                                                                                                                                                                                                                       |
-| `events`           | `entrypoint_id`, `deleted_at`, `resubmitted_from_id`, `created_at` | The webhook page's entrypoint list, which counts the events that arrived on each entrypoint's URL within the retention period                                                                                                                                                                                                                                                                      |
+| `events`           | `entrypoint_id`, `deleted_at`, `resubmitted_from_id`, `created_at` | The webhook page's entrypoint list, which counts the events that arrived on each entrypoint's URL within the retention period                                                                                                                                                                                                                                                      |
-| `events`           | `created_at`                                                       | Retention, which selects expired events by age                                                                                                                                                                                                                                                                                                                                                     |
+| `events`           | `created_at`                                                       | Retention, which selects expired events by age                                                                                                                                                                                                                                                                                                                                     |
 
 GORM's soft delete adds `deleted_at IS NULL` to these queries; retention leaves
 it out. SQLite keeps no statistics on these tables, and without them it rates
@@ -2089,15 +2100,15 @@ writes go on meanwhile, since under WAL a reader never blocks a writer. Until
 the open file is closed its `-wal` cannot be checkpointed past what the download
 reads, so a long download lets that `-wal` grow.
 
-Deleting a webhook releases its archives: the delivery engine's cached archive
+Deleting a webhook releases its archives: its cached archive writers are dropped
-writers are dropped and their file handles closed, so nothing lingers after the
+and their file handles closed, so nothing lingers after the webhook is gone. The
-webhook is gone. The archive **files themselves are deliberately left on disk**.
+archive **files themselves are deliberately left on disk**. Unlike the event
-Unlike the event database — per-webhook working storage that is hard-deleted
+database — per-webhook working storage that is hard-deleted with the webhook —
-with the webhook — an archive is long-term storage an operator may still want to
+an archive is long-term storage an operator may still want to keep or move away
-keep or move away for offline retention, and destroying it as a side effect of
+for offline retention, and destroying it as a side effect of deleting a webhook
-deleting a webhook would be unrecoverable. Removing an `archive-….db` is the
+would be unrecoverable. Removing an `archive-….db` is the operator's call.
-operator's call. Deleting a `database` target releases its writer the same way,
+Deleting a `database` target releases its writer the same way, and for the same
-and for the same reason leaves its file alone.
+reason leaves its file alone.
 
 The **Slack target type** sends webhook events as formatted messages to any
 Slack-compatible incoming webhook URL (works with Slack, Mattermost, and other
@@ -2110,9 +2121,7 @@ endpoint. That is the JSON key; the error text for a missing one reads
 `webhook_url is required`, which is the message, not the key.
 
 The database uses the
-[modernc.org/sqlite](https://pkg.go.dev/modernc.org/sqlite) driver at runtime,
+[modernc.org/sqlite](https://pkg.go.dev/modernc.org/sqlite) driver.
-though CGO is required at build time due to the transitive `mattn/go-sqlite3`
-dependency from `gorm.io/driver/sqlite`.
 
 #### Schema
 
@@ -2163,11 +2172,11 @@ External Service
                               ▼                ▼                    ▼
                        ┌────────────┐   ┌────────────┐      ┌────────────┐
                        │ HTTP Target│   │ HTTP Target│      │ Log Target │
-                       │(max_retries│   │(max_retries│      │ (stdout)   │
+                       │max_attempts│   │max_attempts│      │ (stdout)   │
-                       │   == 0)    │   │   > 0,     │      └────────────┘
+                       │   == 1,    │   │   > 1,     │      └────────────┘
-                       │ fire+forget│   │ backoff +  │
+                       │ one attempt│   │ backoff +  │
                        └────────────┘   │ circuit    │
-                                        │ breaker)   │
+                                        │ breaker    │
                                         └────────────┘
 ```
 
@@ -2190,7 +2199,7 @@ preventing goroutine explosions regardless of queue depth.
   Workers are the ONLY goroutines doing actual HTTP delivery.
 - **Retry backpressure with DB fallback:** When a retry timer fires and the
   retry channel is full, the timer is dropped — the delivery stays in `retrying`
-  status in the database. A periodic sweep (every 60s) scans for these
+  status in the database. The sweep (every 60s, see Recovery below) finds these
   "orphaned" retries and re-queues them. No blocked goroutines, no unbounded
   timer chains.
 - **Bounded concurrency:** At most N deliveries (N = number of workers) are
@@ -2206,31 +2215,47 @@ This means:
   buffer rather than spawning more goroutines.
 - **Independent results** — each worker records its own delivery result in the
   per-webhook database without coordination.
-- **Graceful shutdown** — cancel the context, workers finish their current task
+- **Graceful shutdown** — the stop hook cancels the workers' context. A worker
-  and exit. The stop hook waits for the pool via `lifecycle.WaitForShutdown`,
+  may still take tasks already queued before it exits. An `http` or `slack`
-  which bounds that wait by fx's stop timeout rather than blocking forever on a
+  request in flight is cut off, and one started after the cancel fails at once.
-  wedged worker. On timeout it logs at `ERROR` and returns an error, and the
+  Neither is recorded or counted in the metrics, and the next start sends the
-  goroutines that did not finish are still running — an unclean shutdown is
+  delivery again (see Shutdown). A `database` or `log` task runs as normal. The
-  reported rather than hidden.
+  stop hook waits for the pool via `lifecycle.WaitForShutdown`, which bounds
+  that wait by fx's stop timeout rather than blocking forever on a wedged
+  worker. On timeout it logs at `ERROR` and returns an error, and the goroutines
+  that did not finish are still running — an unclean shutdown is reported rather
+  than hidden.
 
-**Recovery paths:**
+**Recovery:** one routine finds the deliveries the engine is not working on and
+hands them back. It runs once when the engine starts, and then every 60 seconds;
+that periodic run is the sweep. For every webhook it reads the `pending` and
+`retrying` deliveries. One that already has a successful attempt is marked
+`delivered` and not sent again. A `retrying` delivery gets a backoff timer for
+what is left of its backoff, and is queued at once if nothing is left. A
+`pending` delivery is queued on the delivery channel. A delivery the engine has
+queued, is attempting, or holds a backoff timer for is left alone, at start as
+on every sweep. This is what catches "orphaned" retries, whose in-memory timer
+was dropped because the retry channel was full, and deliveries a stop or a crash
+cut off: the database is the durable fallback that ensures no delivery is
+permanently lost, even under extreme backpressure.
 
-1. **Startup recovery:** When the engine starts, it scans all per-webhook
+The run at start and the sweep differ in two ways:
-   databases for `pending` and `retrying` deliveries. Pending deliveries are
+
-   sent to the delivery channel; retrying deliveries get backoff timers
+- At start every `pending` delivery is taken, however recent, so one a stop cut
-   scheduled.
+  off moments ago is sent again at once (see Shutdown). The sweep takes only
-2. **Periodic retry sweep (DB-mediated fallback):** Every 60 seconds the engine
+  `pending` deliveries untouched for 15 minutes, at most 500 per webhook each
-   scans for `retrying` deliveries whose backoff period has elapsed. This
+  time, so a delivery whose outcome the database will not record is sent again
-   catches "orphaned" retries — ones whose in-memory timer was dropped because
+  every 15 minutes rather than every minute.
-   the retry channel was full. The database is the durable fallback that ensures
+- At start every webhook's database is opened, so that a missing one is reported
-   no retry is permanently lost, even under extreme backpressure.
+  then (see Per-Webhook Event Databases). The sweep skips a webhook whose
+  database file is missing rather than create it.
 
 **Changing a target's type does not migrate in-flight deliveries.** Only `http`
 and `slack` targets own durable retries; `database` and `log` targets are
 fire-and-forget and never produce a `retrying` delivery. If a target's `type` is
 edited from a retrying type to a non-retrying (or unknown) one while one of its
-deliveries is still `retrying`, both recovery paths above terminally mark that
+deliveries is still `retrying`, the recovery routine above terminally marks that
-delivery `failed` and record a `DeliveryResult` naming the current target type
+delivery `failed` and records a `DeliveryResult` naming the current target type
 as the reason, logging it at warn level. The delivery is not re-dispatched under
 the new type — the operator never asked for that delivery — and the event itself
 remains stored in the per-webhook event database. Nothing is lost: the delivery
@@ -2240,11 +2265,11 @@ re-inject it to every currently active target.
 
 ### Circuit Breaker (HTTP and Slack Targets with Retries)
 
-`http` and `slack` targets with `max_retries` > 0 are protected by a
+`http` and `slack` targets with `max_attempts` > 1 are protected by a
 **per-target circuit breaker** that prevents hammering a down target with
 repeated failed delivery attempts. The circuit breaker is in-memory only and
-resets on restart (which is fine — startup recovery rescans the database
+resets on restart (which is fine — the recovery routine rescans the database at
-anyway).
+start anyway).
 
 **States:**
 
@@ -2281,10 +2306,10 @@ anyway).
 - **Cooldown:** 30 seconds in open state before probing
 
 **Scope:** Circuit breakers apply to **`http` and `slack` targets with
-`max_retries` > 0**. The Slack target is built on the same HTTP core and hands
+`max_attempts` > 1**. The Slack target is built on the same HTTP core and hands
-its own `max_retries` to the same retry path, so it gets a breaker with the same
+its own `max_attempts` to the same retry path, so it gets a breaker with the
-5-failure / 30-second defaults. Fire-and-forget targets of either type
+same 5-failure / 30-second defaults. Single-attempt targets of either type
-(`max_retries` == 0), database targets (local operations), and log targets
+(`max_attempts` == 1), database targets (local operations), and log targets
 (stdout) do not use circuit breakers.
 
 When a circuit is open and a new delivery arrives, the engine marks the delivery
@@ -2317,7 +2342,7 @@ getting anywhere.
 | Metric                                 | Type      | Meaning                                                                                                                                                                                                                                                                                                   |
 | -------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `webhooker_events_received_total`      | counter   | Events received and durably stored. Compare against the delivery counters on one dashboard                                                                                                                                                                                                                |
-| `webhooker_delivery_attempts_total`    | counter   | Delivery attempts actually dispatched to a target. A delivery a circuit breaker refused is not one: it is counted as a retry instead, but only when the refusal moves it into `retrying`                                                                                                                  |
+| `webhooker_delivery_attempts_total`    | counter   | Delivery attempts actually dispatched to a target. A delivery a circuit breaker refused is not one: it is counted as a retry instead, but only when the refusal moves it into `retrying`. An attempt cut off by a stop is not counted (see Shutdown)                                                      |
 | `webhooker_deliveries_succeeded_total` | counter   | Deliveries that reached `delivered`                                                                                                                                                                                                                                                                       |
 | `webhooker_deliveries_failed_total`    | counter   | Deliveries that failed terminally and will not be retried                                                                                                                                                                                                                                                 |
 | `webhooker_delivery_retries_total`     | counter   | Deliveries put back into `retrying`                                                                                                                                                                                                                                                                       |
@@ -2416,27 +2441,32 @@ log volume it caps rather than eliminates. A path that names no entrypoint is
 recorded by the handler at `DEBUG`, and the aggregate limiter logs its own
 rejections at `DEBUG` and without the path, so neither appears at all under the
 default level. The per-entrypoint limiter is the loud one: it logs every
-rejection at `WARN` with the request path, which on this route is
+rejection at `WARN`, naming the route pattern `/h/{uuid}` rather than the
-attacker-controlled text. A client hammering a single invented path is served
+request path. A client hammering a single invented path is served
 `RECEIVER_RATE_LIMIT` requests and has the rest of its aggregate budget rejected
 there, so the aggregate limit is what bounds the _number_ of those `WARN` lines
 — to under ten times `RECEIVER_RATE_LIMIT` per minute per client IP, 1080 at the
-defaults, where before it there was no bound at all. Their _width_ is bounded by
+defaults, where before it there was no bound at all. The access log is bounded
-the field budgets below, the same ones the access log spends. The access log is
+by neither limit: every request is recorded once at `INFO`, served or rejected
-bounded by neither limit: every request is recorded once at `INFO`, served or
+alike.
-rejected alike.
 
-What the access log does bound is the _content_ of those lines. A 3xx or 4xx
+What the access log does bound is the _content_ of those lines. On the receiver
-response logs the chi route pattern — `/h/{uuid}`, `/user/{username}//`, or the
+route it logs the route pattern `/h/{uuid}` whatever the status, because the
-literal `(unmatched)` when the request hit no route at all — in place of the
+concrete path carries the entrypoint UUID, which is the entrypoint's credential
-concrete URL. Those are the outcomes an unauthenticated client can drive for
+(see
-free: 404 and 429 on any invented receiver path, a login redirect on any
+[The entrypoint URL is the authentication secret](#the-entrypoint-url-is-the-authentication-secret)).
-invented profile path. Logging the URL there would let a flood write text of its
+A request chi never routed, because it matched no route or because a middleware
-own choosing, at a length of its own choosing, into the log. 2xx and 5xx
+answered it first, logs the literal `(unmatched)` whatever the status. In the
-responses keep the concrete path — a success resolved against a static route or
+`dev` environment the CORS middleware answers a preflight that way, so a
-against the operator's own data (on the receiver, against a stored entrypoint
+preflight to the receiver does not log its UUID either. On every other route, a
-UUID), and a 5xx is a bug in this service, where the exact path is the evidence
+3xx or 4xx response logs the chi route pattern, such as `/user/{username}//`, in
-and no client can provoke one at will.
+place of the concrete URL. Those are the outcomes an unauthenticated client can
+drive for free: a 404 on any invented path, a login redirect on any invented
+profile path. Logging the URL there would let a flood write text of its own
+choosing, at a length of its own choosing, into the log. 2xx and 5xx responses
+keep the concrete path — a success resolved against a static route or against
+the operator's own data, and a 5xx is a bug in this service, where the exact
+path is the evidence and no client can provoke one at will.
 
 The query string is never logged; it is replaced by the fixed marker
 `?(redacted)`. It is client-chosen on every route, and
@@ -2448,6 +2478,11 @@ to, `notice`, which names the line a page shows after an action, and the event
 log's `show`, which picks the events it lists. A query string sent to an
 entrypoint is not lost either: the event stores it, and the event log shows it.
 
+The `referer` field keeps only the scheme and host of the request's `Referer`,
+and logs `(redacted)` for one without them, because its path can be an
+entrypoint URL: a sender that follows the `http://` to `https://` redirect in
+the nginx example sends the URL it was redirected from.
+
 Client-supplied request content does not leave the host by the other route
 either. The Sentry SDK attaches the request to every event it captures,
 independently of the access log, and `SendDefaultPII=false` does not cover all
@@ -2457,14 +2492,18 @@ are both taken unconditionally, the body precisely because these handlers call
 body with `(redacted)`, drops cookies and the remote-address environment, and
 reduces the headers to a fixed allowlist — `Accept`, `Content-Length`,
 `Content-Type`, `Host`, `Origin`, `Referer`, `User-Agent` and `X-Request-Id`.
+`Referer` is sent as its scheme and host only, because its path can be an
+entrypoint URL; `internal/referer.SchemeAndHost` does that reduction for both
+the access log's `referer` field and this hook.
 
 The same hook rewrites the request URL. The SDK builds it as
 `scheme://host/path` from the concrete path, which on the receiver route is
 `/h/<uuid>` in full — and that UUID is a write capability, not an identifier:
 anyone holding it can post events this service accepts and its targets then
-deliver. A tracker has its own retention, access control and deletion policy, so
+deliver. What is sent is the chi route pattern instead: `http://host/h/{uuid}`.
-the rule the access log follows above does not carry across that boundary. What
+A tracker has its own retention, access control and deletion policy, so the
-is sent is the chi route pattern instead: `http://host/h/{uuid}`.
+pattern is sent on every route, including the 2xx and 5xx responses outside the
+receiver for which the access log keeps the concrete path.
 
 The scheme and the host are kept, and everything else in the URL is discarded
 rather than edited, so a future SDK version that starts appending a query string
@@ -2526,8 +2565,9 @@ receiver route. What survives still names the failing route — scheme, host,
 route pattern, method — and `X-Request-Id` ties the event to the local access
 log line that holds the rest. Nothing dropped is needed for the likeliest use,
 debugging a CSRF rejection. Its three inputs are the TLS decision, `Origin` and
-`Referer`; the latter two are kept, and the first is the scheme of the retained
+`Referer`; the latter two are kept (`Referer` as its scheme and host, which is
-URL, because the SDK derives that scheme from
+all the check compares), and the first is the scheme of the retained URL,
+because the SDK derives that scheme from
 `r.TLS != nil || r.Header.Get("X-Forwarded-Proto") == "https"`. That predicate
 is the SDK's own and is stricter than `internal/reqtls.IsTLS`, which this
 service now uses everywhere it decides transport: the SDK reports `http` for the
@@ -2593,9 +2633,7 @@ than it:
 | ------------------------------------------ | ------- | ------------------- | ------------------------------------------ |
 | `request body exceeds limit` (413)         | `WARN`  | path, method        | yes — `MaxBodySize` precedes `RequireAuth` |
 | `csrf: token validation failed` (403)      | `WARN`  | path, method        | yes — `CSRF` precedes `RequireAuth`        |
-| `... rate limit exceeded` (429)            | `WARN`  | path                | yes, on the receiver                       |
 | `auth middleware: unauthenticated request` | `DEBUG` | path, method        | yes, by definition                         |
-| `entrypoint not found`                     | `DEBUG` | entrypoint UUID     | yes, on the receiver                       |
 | `user not found` / `invalid password`      | `DEBUG` | username            | yes, on the sign-in form                   |
 | `login failure limit exceeded` (429)       | `WARN`  | path                | yes, on the sign-in form                   |
 | `password verification capacity exhausted` | `WARN`  | path                | yes, on the sign-in form                   |
@@ -2623,13 +2661,12 @@ wider of the two handlers spends more on than the client spent sending them.
 Every case holds each line to the 2,560-byte ceiling. That per-line ceiling is
 what the figure above states, and every row establishes it.
 
-Three of the sites go further and bound the whole flood's output — the total
+Two of the sites go further and bound the whole flood's output — the total bytes
-bytes a run of distinct invented values wrote, which is the shape an operator
+a run of distinct invented values wrote, which is the shape an operator sizing
-sizing storage cares about. They are `request body exceeds limit`
+storage cares about. They are `request body exceeds limit`
-(`TestMaxBodySize_FloodOfOversizePathsDoesNotGrowTheLog`),
+(`TestMaxBodySize_FloodOfOversizePathsDoesNotGrowTheLog`) and `user not found`
-`entrypoint not found` and `user not found` (the last two through
+(through `assertBoundedFlood`). The other rows carry no aggregate assertion; the
-`assertBoundedFlood`). The other rows carry no aggregate assertion; the per-line
+per-line ceiling is what they establish.
-ceiling is what they establish.
 
 `internal/logfield/logfield_test.go` measures the per-rune charge against what
 the handlers really emit, over roughly 3,000 code points on each, so an
@@ -2647,7 +2684,7 @@ everything else, so its lines take the level the operator set and the handler
 `internal/logger` selected, and every value it emits is spent through the same
 `internal/logfield` budget. A record-not-found is not logged as an error: it is
 the expected outcome on both of those paths, and each handler already records
-its own miss at `DEBUG` — bounded, per the table above — without the SQL. Slow
+its own miss at `DEBUG`, without the SQL and within the ceiling above. Slow
 statements are kept, at `WARN`, above the same 200 ms threshold GORM used and
 with the statement bounded, because that report is the one thing GORM's logger
 gave an operator that nothing else here does. The adapter orders its cases
@@ -2972,6 +3009,12 @@ webhooker/
 ├── cmd/webhooker/
 │   └── main.go               # Entry point: subcommand dispatch; no args locks DATA_DIR and wires fx
 ├── internal/
+│   ├── archive/
+│   │   ├── archive.go         # The archive writer of each database target, eviction, rename, and the rename lock
+│   │   ├── writer.go          # Archive file lifecycle and pruning
+│   │   ├── rotation.go        # Archive rotation and file names
+│   │   ├── download.go        # Archive download as gzipped JSON
+│   │   └── sweeper.go         # Periodic pruning of idle archives
 │   ├── banner/
 │   │   └── banner.go          # Ruled block for the one credential shown in the clear
 │   ├── resetpw/
@@ -3015,13 +3058,9 @@ webhooker/
 │   │   ├── target.go          # Target interface, Task, Scheduler
 │   │   ├── target_http.go     # HTTP target (retries, circuit breaker)
 │   │   ├── target_slack.go    # Slack/Mattermost incoming-webhook target
-│   │   ├── target_database.go # Database archive target
+│   │   ├── target_database.go # Database archive target, writing through internal/archive
-│   │   ├── target_database_archive.go  # Archive file lifecycle and pruning
-│   │   ├── target_database_rotation.go # Archive rotation and file names
-│   │   ├── target_database_export.go   # Archive download as gzipped JSON
 │   │   ├── target_log.go      # Log target (stdout)
 │   │   ├── target_config_view.go  # Masked target config for templates
-│   │   ├── archive_sweeper.go # Periodic pruning of idle archives
 │   │   ├── queue_depth.go     # Periodic sampler behind the queue-depth gauges
 │   │   ├── url_mask.go        # Strips credentials from *url.Error
 │   │   └── ssrf.go            # SSRF prevention (IP validation, safe HTTP transport)
@@ -3062,6 +3101,8 @@ webhooker/
 │   │   ├── ratelimit.go       # Per-IP rate limiting middleware (go-chi/httprate)
 │   │   ├── loginguard.go      # Login failure counters and the Argon2id verification semaphore
 │   │   └── middlewaretest/    # Test support: a Middleware for tests in other packages
+│   ├── referer/
+│   │   └── referer.go         # SchemeAndHost: cuts a Referer down to its scheme and host, for the access log and the Sentry hook
 │   ├── reqtls/
 │   │   └── reqtls.go          # IsTLS: the one TLS predicate, r.TLS or X-Forwarded-Proto
 │   ├── server/
@@ -3076,8 +3117,8 @@ webhooker/
 │   ├── static.go              # //go:embed directive
 │   ├── css/input.css          # Tailwind input, source for tailwind.css (make css)
 │   ├── css/tailwind.css       # Generated stylesheet the pages load
-│   ├── css/style.css          # Hand-written, loaded after tailwind.css: btn-small, the pointer cursor for input.css's buttons, the webhook list cards' focus outline
+│   ├── css/style.css          # Hand-written, loaded after tailwind.css: btn-small, the pointer cursor for input.css's buttons, the webhook list cards' focus outline, the rule hiding x-cloak elements
-│   ├── js/app.js              # Copy-to-clipboard, and the Alpine.js components
+│   ├── js/app.js              # Copy-to-clipboard, the delete prompts, and the Alpine.js components
 │   └── js/alpine.min.js       # Alpine.js CSP build, extracted from 3p/ by make assets, not committed
 ├── templates/                 # Go HTML templates (base, login, sources, etc.)
 ├── script/                    # Scripts to Rule Them All entrypoints
@@ -3110,14 +3151,16 @@ Components are wired via Uber fx in this order:
 11. `metrics.New` — The delivery collectors, registered on that registry
 12. `middleware.New` — HTTP middleware
 13. `delivery.New` — Event-driven delivery engine
-14. `delivery.NewArchiveSweeper` — Periodic pruning of idle archives
+14. `archive.NewWriters` — The database targets' archive writers, and the lock
-15. `delivery.Engine` → `delivery.Notifier` — interface bridge
+    every rename of their files runs under
-16. `delivery.Engine` → `delivery.Archives` — interface bridge so deleting or
+15. `archive.NewSweeper` — Periodic pruning of idle archives
+16. `delivery.Engine` → `delivery.Notifier` — interface bridge
+17. `archive.Writers` → `archive.Archives` — interface bridge so deleting or
     renaming a webhook or target reaches its archive files
-17. `server.New` — HTTP server and router
+18. `server.New` — HTTP server and router
 
 The server starts via
-`fx.Invoke(func(*server.Server, *delivery.Engine, *database.RetentionReaper, *delivery.ArchiveSweeper) {})`,
+`fx.Invoke(func(*server.Server, *delivery.Engine, *database.RetentionReaper, *archive.Sweeper) {})`,
 which triggers the fx lifecycle hooks in dependency order. The
 `delivery.Notifier` interface allows the webhook handler to send self-contained
 `delivery.Task` slices to the engine without a direct package dependency. Each
@@ -3131,8 +3174,9 @@ Applied to all routes in this order:
 
 1. **RequestID** — Generate unique request IDs (chi built-in)
 2. **SecurityHeaders** — Production security headers on every response (HSTS
-   unless `HSTS_MAX_AGE` is `0`, X-Content-Type-Options, X-Frame-Options, CSP,
+   unless `HSTS_MAX_AGE` is `0`, X-Content-Type-Options, X-Frame-Options, CSP
-   Referrer-Policy, Permissions-Policy)
+   `default-src 'self'; script-src 'self'; style-src 'self'`, Referrer-Policy,
+   Permissions-Policy)
 3. **Logging** — Structured request logging (method, URL, status, latency,
    remote IP, client IP, user agent, request ID)
 4. **Metrics** — Prometheus HTTP metrics (if `METRICS_USERNAME` and
@@ -3217,6 +3261,12 @@ credential check, see [The login endpoint](#the-login-endpoint).
 - Production security headers on all responses: HSTS (unless `HSTS_MAX_AGE` is
   `0`), X-Content-Type-Options (`nosniff`), X-Frame-Options (`DENY`),
   Content-Security-Policy, Referrer-Policy, and Permissions-Policy
+- The Content-Security-Policy is
+  `default-src 'self'; script-src 'self'; style-src 'self'`: a page takes
+  scripts and styles only from files webhooker serves, and the browser runs no
+  inline script or event handler and ignores any `<style>` element or `style`
+  attribute in a page. The pages need none: their scripts are in `static/js/`
+  and their styles in `static/css/`
 - Request body size limits (1 MB) on all form POST endpoints, enforced by
   middleware that runs before CSRF parses the form
 - **CSRF protection** via [gorilla/csrf](https://github.com/gorilla/csrf) on all
@@ -3279,12 +3329,13 @@ order under a **5 second budget** (`fx.StopTimeout` in `cmd/webhooker/main.go`).
 That budget covers the whole sequence, not each hook. The order, read off the fx
 stop-hook log:
 
-1. `ArchiveSweeper`
+1. `archive.Sweeper`
 2. `RetentionReaper`
 3. `server` — the HTTP drain, bounded by `server.ShutdownTimeout` (**3
    seconds**) and by what the hooks before it left, then a Sentry flush if
    `SENTRY_DSN` is set
-4. `delivery.Engine` — waits for its workers, then closes the archive databases
+4. `delivery.Engine` — cuts off any `http` or `slack` request in flight, waits
+   for its workers, then closes the archive databases
 5. `healthcheck`
 6. `WebhookDBManager`
 7. the database close
@@ -3295,6 +3346,12 @@ by the stop context, so a wedge there consumes the 5 seconds before the HTTP
 server hook is ever entered. The hooks after the server are microsecond-scale in
 normal operation.
 
+The delivery engine cancels a delivery request in flight. That attempt is not
+recorded or counted in the metrics, and the delivery keeps its `pending` or
+`retrying` status, so recovery at the next start sends it again (see Recovery
+under Bounded Worker Pool). If the receiver already had it, it receives it
+twice: the at-least-once duplicate described under Rationale.
+
 The HTTP drain budget is deliberately **shorter** than the sequence budget. Were
 the two equal, a drain that used its whole budget would exhaust the sequence
 budget at the instant it finished, and every later hook — the delivery engine,
@@ -3315,7 +3372,7 @@ skipped when that leaves too little to be worth attempting — so a full-length
 drain means Sentry events are dropped rather than the database close being
 skipped.
 
-This does not make the database close unconditional. A slow `ArchiveSweeper` or
+This does not make the database close unconditional. A slow `archive.Sweeper` or
 `RetentionReaper` is enough to cut the shutdown short, not only one that
 consumes the whole budget: what they spend comes out of the drain first, so
 after 2 seconds of theirs a request still in flight gets 1 second to finish, and
@@ -3417,16 +3474,12 @@ fixed independently of the compiler's:
    a step's log, and then fails. `make test` builds this stage alone.
 6. **Builder stage** (`golang:1.26.1-bookworm`) — depends on the lint and test
    phases and the `css-check` and `markdown-check` stages passing (it copies a
-   file from each), runs `make build` (which extracts Alpine.js from `3p/`
+   file from each), and runs `make build` (which extracts Alpine.js from `3p/`
-   first), and then rebuilds the binary with `CGO_ENABLED=1` and static linking
+   first). `make build` compiles with cgo off, so the binary is statically
-   so it runs on musl, with the build tags `netgo`, `osusergo` and
+   linked and runs on the Alpine runtime image. The version is the `VERSION`
-   `sqlite_omit_load_extension` so it needs none of glibc's shared libraries at
+   build arg if one is given, otherwise derived from the `.git` in the context,
-   run time. Both builds go through `make build`, the relink adding its
+   and the stage fails if a context with `.git` would stamp an empty version,
-   `-extldflags` via `GO_LDFLAGS` and its tags via `GO_TAGS`, so neither can
+   `dev` or `unknown` (see [Version stamping](#version-stamping)).
-   drop the `-X` that stamps the version. The version is the `VERSION` build arg
-   if one is given, otherwise derived from the `.git` in the context, and the
-   stage fails if a context with `.git` would stamp an empty version, `dev` or
-   `unknown` (see [Version stamping](#version-stamping)).
 7. **Runtime stage** (`alpine:3.21`) — copies the static binary and
    `deploy/docker-entrypoint.sh`, creates the `/var/lib/webhooker` directory for
    all SQLite databases, exposes port 8080, and includes a health check against
@@ -3438,11 +3491,6 @@ The lint and test phases invoke `gofmt`, `golangci-lint` and `go test` directly
 rather than `make fmt-check`, `make lint` and `make test`: those targets build
 docker stages, which would need a docker daemon inside this build.
 
-The lint phase and the Go stages use Debian rather than Alpine because
-`gorm.io/driver/sqlite` pulls in `mattn/go-sqlite3`, which needs CGO and does
-not compile against musl. Only the final binary is statically linked, which is
-what lets it run on the Alpine runtime image.
-
 `script/cibuild` is the CI gate: it runs `script/bootstrap`, then
 `script/check`, then builds the image, whose build runs the lint and test phases
 and the stylesheet and Markdown checks again. A build that succeeds is a repo

cmd/webhooker/main.go

@@ -10,6 +10,7 @@ import (
 
 	"go.uber.org/fx"
 	"go.uber.org/fx/fxevent"
+	"sneak.berlin/go/webhooker/internal/archive"
 	"sneak.berlin/go/webhooker/internal/config"
 	"sneak.berlin/go/webhooker/internal/database"
 	"sneak.berlin/go/webhooker/internal/datadir"
@@ -49,7 +50,7 @@ import (
 // before the server may already have spent.
 //
 // This does not make the database close unconditional: the
-// ArchiveSweeper and RetentionReaper hooks run before the server.
+// archive.Sweeper and RetentionReaper hooks run before the server.
 // What they spend comes out of the drain first, but past 3s it comes
 // out of the reserve, and they can consume the whole budget.
 const stopTimeout = 5 * time.Second
@@ -188,8 +189,8 @@ func newApp() *fx.App {
 		fx.Provide(
 			globals.New,
 			logger.New,
-			// The plain logger the session, the middleware and the
+			// The plain logger the session, the middleware, the
-			// webhook database manager take.
+			// webhook database manager and the archive writers take.
 			func(l *logger.Logger) *slog.Logger { return l.Get() },
 			config.New,
 			database.New,
@@ -208,14 +209,15 @@ func newApp() *fx.App {
 			// disagree about a destination.
 			delivery.NewGuard,
 			delivery.New,
-			delivery.NewArchiveSweeper,
+			archive.NewWriters,
+			archive.NewSweeper,
 			// Wire *delivery.Engine as delivery.Notifier so the
 			// webhook handler can notify the engine of new deliveries.
 			func(e *delivery.Engine) delivery.Notifier { return e },
-			// Wire *delivery.Engine as delivery.Archives so deleting
+			// Wire *archive.Writers as archive.Archives so deleting
 			// or renaming a webhook or target reaches its archive
 			// files.
-			func(e *delivery.Engine) delivery.Archives { return e },
+			func(w *archive.Writers) archive.Archives { return w },
 			// Wire *delivery.Engine as delivery.CircuitBreakers so
 			// the pages can show a target whose deliveries are
 			// paused.
@@ -227,7 +229,7 @@ func newApp() *fx.App {
 				*server.Server,
 				*delivery.Engine,
 				*database.RetentionReaper,
-				*delivery.ArchiveSweeper,
+				*archive.Sweeper,
 			) {
 			},
 		),

cmd/webhooker/main_test.go

@@ -252,7 +252,7 @@ const tailHeadroom = 2 * time.Second
 // can produce, since a shorter drain leaves the flush more room and
 // the worst case is not necessarily at either extreme.
 //
-// Nor does the hook start on a full budget: the ArchiveSweeper and
+// Nor does the hook start on a full budget: the archive.Sweeper and
 // RetentionReaper hooks run before it, and whatever they spent is
 // gone. The outer sweep walks every amount they can spend. Once they
 // have eaten into the headroom themselves, the hook must spend

internal/archive/archive.go

@@ -0,0 +1,454 @@
+// Package archive manages the SQLite archive files the database target
+// writes: how they are named and rotated, the writers that open, write,
+// close and reopen them, pruning the rows past a target's expiry,
+// renaming a target's files and moving them back when that fails, the
+// gzipped JSON export, the idle sweep, and the locks that keep a rename
+// apart from archive writes, from other edits and from exports.
+package archive
+
+import (
+	"fmt"
+	"log/slog"
+	"strings"
+	"sync"
+	"time"
+
+	"go.uber.org/fx"
+	"sneak.berlin/go/webhooker/internal/database"
+)
+
+// archiveNameMaxLen is how many characters of a webhook or target
+// name an archive file name keeps.
+const archiveNameMaxLen = 40
+
+// Archives is how the handlers keep the database targets' archive
+// files in step with the configuration. Deleting a webhook or a
+// target releases the cached archive writers, whose open file
+// handles would otherwise outlive them; renaming one renames the
+// archive files, which are named for the webhook and the target
+// (see FileName). RenameLock returns the lock every rename runs under
+// (see Writers.RenameLock).
+//
+// It is an interface so that the handlers' tests can stand in for
+// Writers.
+//
+// Neither eviction deletes an archive file. Both are idempotent
+// and are no-ops for a webhook or target with no writer.
+type Archives interface {
+	RenameLock() *sync.Mutex
+	EvictWebhook(webhookID string)
+	EvictTarget(targetID string)
+	Rename(targetID, webhookName, targetName string) error
+}
+
+// WritersParams holds the fx dependencies for Writers.
+type WritersParams struct {
+	fx.In
+
+	Database  *database.Database
+	DBManager *database.WebhookDBManager
+	Logger    *slog.Logger
+}
+
+// Writers holds the archive writer of each database target, and the
+// lock every rename of archive files runs under. The database target
+// writes an event through it, the handlers rename and evict through
+// it, the archive sweeper prunes through it, and the delivery engine
+// evicts every writer when it stops. See archiveWriter for the
+// close/reopen, auto-recreate, and expiry semantics.
+type Writers struct {
+	db    *database.Database
+	dbMgr *database.WebhookDBManager
+	log   *slog.Logger
+
+	// writers holds one archive writer per database target, keyed
+	// by target ID.
+	mu      sync.Mutex
+	writers map[string]*archiveWriter
+
+	// renameMu makes the webhook edit, the target edit and target
+	// creation run one at a time, each held from loading the stored
+	// names through the archive rename, the save and any move back.
+	// Interleaved, one could rename an archive between another's
+	// rename and save, leaving the file named for one edit and the
+	// stored names from the other. An archive download holds it while
+	// it reads the stored names and lists the files they give, and
+	// again for each file while it finds the file under the names
+	// stored then and opens it. RenameLock returns it.
+	renameMu sync.Mutex
+}
+
+// NewWriters builds the archive writers. It opens no archive file:
+// each target's writer is made on its first use.
+func NewWriters(params WritersParams) *Writers {
+	return &Writers{
+		db:    params.Database,
+		dbMgr: params.DBManager,
+		log:   params.Logger,
+	}
+}
+
+// RenameLock implements Archives. It returns the lock every rename of
+// archive files runs under: see renameMu for who holds it and for how
+// long. Archive writes and Rename itself do not take it.
+func (ws *Writers) RenameLock() *sync.Mutex {
+	return &ws.renameMu
+}
+
+// FileName returns the file name of a database target's
+// archive: archive-WEBHOOKNAME-TARGETNAME-TARGETID.db, with both
+// names passed through archiveNamePart. The target ID keeps the
+// name unique when two targets' names come out the same.
+func FileName(webhookName, targetName, targetID string) string {
+	return "archive-" + archiveNamePart(webhookName) + "-" +
+		archiveNamePart(targetName) + "-" + targetID + ".db"
+}
+
+// archiveNamePart makes a webhook or target name safe to put in a
+// file name. It is lowercased; ASCII letters and digits are kept,
+// every other run of characters becomes a single "-", and no "-" is
+// left at either end. It is cut to archiveNameMaxLen characters, and
+// a name with nothing left is "unnamed".
+func archiveNamePart(name string) string {
+	var b strings.Builder
+
+	dash := false
+
+	for _, r := range strings.ToLower(name) {
+		if (r < 'a' || r > 'z') && (r < '0' || r > '9') {
+			dash = b.Len() > 0
+
+			continue
+		}
+
+		if dash {
+			b.WriteByte('-')
+
+			dash = false
+		}
+
+		b.WriteRune(r)
+	}
+
+	part := b.String()
+	if len(part) > archiveNameMaxLen {
+		part = strings.TrimRight(part[:archiveNameMaxLen], "-")
+	}
+
+	if part == "" {
+		return "unnamed"
+	}
+
+	return part
+}
+
+// Write writes the full event of a delivery to a database target as
+// a row into the target's archive database, honouring the optional
+// per-target expiry and rotation parsed from the target config JSON.
+// With rotation, the event goes to the file for the period of its
+// receive time.
+func (ws *Writers) Write(d *database.Delivery) error {
+	webhookID := d.Event.WebhookID
+	if webhookID == "" {
+		return errArchiveMissingWebhookID
+	}
+
+	expiry, err := ParseExpiry(d.Target.Config)
+	if err != nil {
+		return err
+	}
+
+	rotation, err := ParseRotation(d.Target.Config)
+	if err != nil {
+		return err
+	}
+
+	// An event whose stored row was gone before its delivery ran has
+	// no receive time (see delivery's Engine.hydrateEvent), and goes
+	// to the file for now.
+	receivedAt := d.Event.CreatedAt
+	if receivedAt.IsZero() {
+		receivedAt = time.Now()
+	}
+
+	w, err := ws.writerFor(d.TargetID)
+	if err != nil {
+		return err
+	}
+
+	row := archivedEvent{
+		EventID:      d.Event.ID,
+		WebhookID:    webhookID,
+		EntrypointID: d.Event.EntrypointID,
+		Method:       d.Event.Method,
+		RawQuery:     d.Event.RawQuery,
+		Headers:      d.Event.Headers,
+		Body:         d.Event.Body,
+		ContentType:  d.Event.ContentType,
+	}
+
+	return w.write(row, expiry, archivePeriod(rotation, receivedAt))
+}
+
+// Rename implements Archives. It renames every one of a database
+// target's archive files to FileName(webhookName, targetName,
+// targetID), each keeping the period in its name. It goes through the
+// target's writer, so the move holds the lock that the target's
+// archive writes and the idle sweep take, and later writes use the
+// new name. It never replaces a file: if one already has a new name,
+// the error is ErrNameTaken.
+//
+// The writer is created if there is none, and it stays cached. The
+// handlers rename before they save the new name, so until the save
+// the main database still has the old one; a delivery in that window
+// must find this writer rather than build one from the old name.
+func (ws *Writers) Rename(
+	targetID, webhookName, targetName string,
+) error {
+	w, err := ws.writerFor(targetID)
+	if err != nil {
+		return err
+	}
+
+	return w.rename(FileName(webhookName, targetName, targetID))
+}
+
+// EvictTarget implements Archives. It drops a database target's
+// archive writer from the registry and closes its handle, so a
+// deleted target does not leave a writer (and an open archive handle
+// within its debounce window) alive for the process lifetime.
+//
+// The map entry is removed under the registry lock, which is
+// then released before the handle is closed under the writer's
+// own lock: that ordering keeps the registry available to other
+// targets while an in-flight write on this one drains, and
+// closing under the writer's lock means eviction can never race
+// a write.
+//
+// Eviction is idempotent and silent for a target with no writer,
+// which is the common case: only a database target that has
+// received an event or been renamed has one. It never deletes the
+// archive file.
+func (ws *Writers) EvictTarget(targetID string) {
+	ws.mu.Lock()
+
+	w, ok := ws.writers[targetID]
+	if ok {
+		delete(ws.writers, targetID)
+	}
+
+	ws.mu.Unlock()
+
+	if !ok {
+		return
+	}
+
+	w.evict()
+
+	ws.log.Info(
+		"evicted archive writer",
+		"target_id", targetID,
+		"path", w.path,
+	)
+}
+
+// EvictWebhook implements Archives. It evicts, exactly as EvictTarget
+// does, the writer of every database target of a webhook. The archive
+// files themselves are left on disk — they are long-term storage the
+// operator owns.
+func (ws *Writers) EvictWebhook(webhookID string) {
+	ws.mu.Lock()
+
+	var gone []*archiveWriter
+
+	for targetID, w := range ws.writers {
+		if w.webhookID == webhookID {
+			delete(ws.writers, targetID)
+
+			gone = append(gone, w)
+		}
+	}
+
+	ws.mu.Unlock()
+
+	for _, w := range gone {
+		w.evict()
+
+		ws.log.Info(
+			"evicted archive writer",
+			"webhook_id", webhookID,
+			"path", w.path,
+		)
+	}
+}
+
+// EvictAll evicts every cached archive writer, exactly as EvictTarget
+// does for one target. The delivery engine calls it at shutdown, once
+// its workers have returned. Closing the last handle on an archive
+// moves the contents of its -wal into the .db and removes the
+// -wal, so a clean stop leaves each archive as a single file.
+func (ws *Writers) EvictAll() {
+	ws.mu.Lock()
+
+	writers := ws.writers
+	ws.writers = nil
+
+	ws.mu.Unlock()
+
+	for _, w := range writers {
+		w.evict()
+	}
+}
+
+// writerFor returns the archive writer for a database target,
+// creating and caching it on first use. Each target has one writer
+// so its close/reopen debounce state is shared across concurrent
+// deliveries, and so a rename and the idle sweep take the same lock
+// as its writes.
+func (ws *Writers) writerFor(
+	targetID string,
+) (*archiveWriter, error) {
+	ws.mu.Lock()
+	defer ws.mu.Unlock()
+
+	w, ok := ws.writers[targetID]
+	if !ok {
+		var err error
+
+		w, err = ws.newWriter(targetID)
+		if err != nil {
+			return nil, err
+		}
+
+		if ws.writers == nil {
+			ws.writers = make(map[string]*archiveWriter)
+		}
+
+		ws.writers[targetID] = w
+	}
+
+	// A delivery claims the entry: even if the idle sweep created
+	// it moments ago, it now belongs to the registry proper and
+	// the sweep must leave it in place when it finishes.
+	w.sweepOwned = false
+
+	return w, nil
+}
+
+// sweepWriterFor returns the archive writer the idle sweep should
+// prune a target's archive through, together with whether the sweep
+// itself created the registry entry.
+//
+// The sweep must route its prune through the registered writer so
+// the writer's mutex orders it against concurrent writes, but it
+// must never leave a registry entry behind: a sweep that ran
+// concurrently with the target's deletion would otherwise
+// re-create an entry that nothing will ever evict again, which is
+// exactly the leak eviction exists to prevent. An entry the sweep
+// creates is therefore marked sweep-owned and handed back to
+// releaseSweepWriter when the sweep is done.
+func (ws *Writers) sweepWriterFor(
+	targetID string,
+) (*archiveWriter, bool, error) {
+	ws.mu.Lock()
+	defer ws.mu.Unlock()
+
+	w, ok := ws.writers[targetID]
+	if ok {
+		return w, false, nil
+	}
+
+	w, err := ws.newWriter(targetID)
+	if err != nil {
+		return nil, false, err
+	}
+
+	if ws.writers == nil {
+		ws.writers = make(map[string]*archiveWriter)
+	}
+
+	w.sweepOwned = true
+	ws.writers[targetID] = w
+
+	return w, true, nil
+}
+
+// releaseSweepWriter drops a registry entry that the idle sweep
+// created, so a sweep leaves the registry exactly as it found it.
+//
+// The entry is removed only if it is still the very writer the
+// sweep installed and no delivery has claimed it in the meantime
+// (writerFor clears sweepOwned when it hands a writer to the
+// write path). Both conditions are evaluated under the registry
+// lock, so an eviction that raced the sweep — which removes the
+// entry outright — simply finds nothing left to do here, and a
+// delivery that adopted the writer keeps a registered, evictable
+// one.
+func (ws *Writers) releaseSweepWriter(
+	targetID string, w *archiveWriter,
+) {
+	ws.mu.Lock()
+	defer ws.mu.Unlock()
+
+	cur, ok := ws.writers[targetID]
+	if !ok || cur != w || !cur.sweepOwned {
+		return
+	}
+
+	delete(ws.writers, targetID)
+}
+
+// newWriter builds the writer for a database target's archive. Its
+// path is the one Path gives for the webhook and the target as
+// the main database names them now; from then on only rename changes
+// the name the writer uses. It does not touch the archive files.
+func (ws *Writers) newWriter(
+	targetID string,
+) (*archiveWriter, error) {
+	if ws.dbMgr == nil {
+		return nil, errArchiveNoDataDir
+	}
+
+	var target database.Target
+
+	err := ws.db.DB().
+		Preload("Webhook").
+		First(&target, "id = ?", targetID).Error
+	if err != nil {
+		return nil, fmt.Errorf(
+			"loading database target %s: %w", targetID, err,
+		)
+	}
+
+	w := newArchiveWriter(
+		Path(ws.dbMgr, &target.Webhook, &target),
+		ws.log,
+	)
+	w.webhookID = target.WebhookID
+
+	return w, nil
+}
+
+// sweepArchive prunes one database target's archive of rows older
+// than expiry, without requiring a write. A missing archive file is
+// left missing (see sweepExpired), so a sweep never creates an
+// archive for a target that has never received an event.
+//
+// It also never leaves a registry entry behind: an entry it had
+// to create to reach the writer's mutex is released again once
+// the prune is done, so a sweep racing a target deletion cannot
+// resurrect the writer the eviction just dropped.
+func (ws *Writers) sweepArchive(
+	targetID string, expiry time.Duration,
+) error {
+	w, created, err := ws.sweepWriterFor(targetID)
+	if err != nil {
+		return err
+	}
+
+	if created {
+		defer ws.releaseSweepWriter(targetID, w)
+	}
+
+	return w.sweepExpired(expiry)
+}

internal/archive/archive_test.go

@@ -0,0 +1,773 @@
+package archive_test
+
+import (
+	"database/sql"
+	"fmt"
+	"io/fs"
+	"log/slog"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"gorm.io/driver/sqlite"
+	"gorm.io/gorm"
+	_ "modernc.org/sqlite" // Pure Go SQLite driver.
+	"sneak.berlin/go/webhooker/internal/archive"
+	"sneak.berlin/go/webhooker/internal/database"
+	"sneak.berlin/go/webhooker/internal/gormlog"
+)
+
+const (
+	// testContentType is the event content type used in tests.
+	testContentType = "application/json"
+
+	// eventQuery is the query string an archived event carries.
+	eventQuery = "a=1&b=2"
+)
+
+func archiveTestLogger() *slog.Logger {
+	return slog.New(slog.NewTextHandler(
+		os.Stderr,
+		&slog.HandlerOptions{Level: slog.LevelDebug},
+	))
+}
+
+// openArchiveDBForRead opens an archive file read-only so a
+// test can inspect the rows the writer persisted.
+func openArchiveDBForRead(
+	t *testing.T, path string,
+) *gorm.DB {
+	t.Helper()
+
+	sqlDB, err := sql.Open(
+		"sqlite",
+		fmt.Sprintf("file:%s?mode=ro", path),
+	)
+	require.NoError(t, err)
+
+	t.Cleanup(func() { _ = sqlDB.Close() })
+
+	gdb, err := gorm.Open(
+		sqlite.Dialector{Conn: sqlDB},
+		&gorm.Config{Logger: gormlog.New(slog.New(slog.DiscardHandler))},
+	)
+	require.NoError(t, err)
+
+	return gdb
+}
+
+// archiveFileSuffixes returns the archive file itself and the
+// SQLite sidecars that accompany an open database. A test that
+// asserts no archive was created has to check all of them.
+func archiveFileSuffixes() []string {
+	return []string{"", "-wal", "-shm"}
+}
+
+// removeArchiveFiles simulates an operator moving the archive
+// away by deleting the SQLite file and its sidecar files.
+func removeArchiveFiles(t *testing.T, path string) {
+	t.Helper()
+
+	for _, suffix := range []string{
+		"", "-wal", "-shm", "-journal",
+	} {
+		err := os.Remove(path + suffix)
+		if err != nil && !os.IsNotExist(err) {
+			t.Fatalf("removing %s%s: %v", path, suffix, err)
+		}
+	}
+}
+
+// assertStoredTime asserts that text, a timestamp as SQLite holds it,
+// is in the form GORM stores created_at in: the layout of
+// time.Time.String, with no " m=+…" monotonic clock reading after it.
+func assertStoredTime(t *testing.T, text string) {
+	t.Helper()
+
+	_, err := time.Parse(
+		"2006-01-02 15:04:05.999999999 -0700 MST", text,
+	)
+	assert.NoError(t, err, "stored as %q", text)
+}
+
+// newEvent returns an event received now with the given body, as the
+// webhook handler stores it.
+func newEvent(body string) database.Event {
+	return database.Event{
+		BaseModel: database.BaseModel{
+			ID:        uuid.New().String(),
+			CreatedAt: time.Now(),
+		},
+		WebhookID:    uuid.New().String(),
+		EntrypointID: uuid.New().String(),
+		Method:       http.MethodPost,
+		Headers:      `{"Content-Type":["application/json"]}`,
+		Body:         body,
+		ContentType:  testContentType,
+	}
+}
+
+// databaseTargetDelivery returns a delivery of event to a database
+// target, as the database target hands it to Writers.Write.
+func databaseTargetDelivery(
+	event database.Event, tgt *database.Target,
+) *database.Delivery {
+	return &database.Delivery{
+		EventID:  event.ID,
+		TargetID: tgt.ID,
+		Event:    event,
+		Target: database.Target{
+			Name:   tgt.Name,
+			Type:   database.TargetTypeDatabase,
+			Config: tgt.Config,
+		},
+	}
+}
+
+func TestArchiveWriter_WritesRow(t *testing.T) {
+	t.Parallel()
+
+	path := filepath.Join(t.TempDir(), "archive-wh.db")
+	w := archive.NewExportArchiveWriter(
+		path, archiveTestLogger(), 0,
+	)
+
+	row := archive.ExportArchivedEvent{
+		EventID:      "ev-1",
+		WebhookID:    "wh-1",
+		EntrypointID: "ep-1",
+		Method:       "POST",
+		Headers:      `{"X":"Y"}`,
+		Body:         `{"hello":"world"}`,
+		ContentType:  "application/json",
+	}
+
+	require.NoError(t, w.Write(row, 0))
+	assert.FileExists(t, path)
+
+	var got []archive.ExportArchivedEvent
+
+	require.NoError(t, w.DB().Find(&got).Error)
+	require.Len(t, got, 1)
+	assert.Equal(t, "ev-1", got[0].EventID)
+	assert.Equal(t, "wh-1", got[0].WebhookID)
+	assert.Equal(t, "ep-1", got[0].EntrypointID)
+	assert.Equal(t, row.Method, got[0].Method)
+	assert.Equal(t, row.ContentType, got[0].ContentType)
+	assert.JSONEq(t, `{"hello":"world"}`, got[0].Body)
+	assert.False(t, got[0].ArchivedAt.IsZero())
+
+	var archivedAt string
+
+	require.NoError(t, w.DB().Raw(
+		"SELECT CAST(archived_at AS TEXT) FROM archived_events",
+	).Row().Scan(&archivedAt))
+	assertStoredTime(t, archivedAt)
+}
+
+func TestArchiveWriter_RecreatesAfterRemoval(
+	t *testing.T,
+) {
+	t.Parallel()
+
+	path := filepath.Join(t.TempDir(), "archive-wh.db")
+	w := archive.NewExportArchiveWriter(
+		path, archiveTestLogger(), 0,
+	)
+
+	require.NoError(t, w.Write(
+		archive.ExportArchivedEvent{EventID: "a"}, 0,
+	))
+	assert.FileExists(t, path)
+
+	// The operator moves the archive away while the handle is
+	// still open.
+	removeArchiveFiles(t, path)
+	require.NoFileExists(t, path)
+
+	// The next write recreates the file with a fresh schema and
+	// only the new row.
+	require.NoError(t, w.Write(
+		archive.ExportArchivedEvent{EventID: "b"}, 0,
+	))
+	assert.FileExists(t, path)
+
+	var got []archive.ExportArchivedEvent
+
+	require.NoError(t, w.DB().Find(&got).Error)
+	require.Len(t, got, 1)
+	assert.Equal(t, "b", got[0].EventID)
+}
+
+// TestArchiveHandleIsWAL closes the last gap in the durability
+// evidence: the main and per-webhook tiers each assert their journal
+// mode on a live handle, and the archive tier gets its settings from
+// the same code path but nothing checked the running file.
+func TestArchiveHandleIsWAL(t *testing.T) {
+	t.Parallel()
+
+	w := archive.NewExportArchiveWriter(
+		filepath.Join(t.TempDir(), "archive-wal.db"),
+		archiveTestLogger(), 0,
+	)
+
+	require.NoError(t, w.Open(0))
+
+	var mode string
+
+	row := w.DB().Raw("pragma journal_mode").Row()
+	require.NoError(t, row.Scan(&mode))
+	assert.Equal(t, "wal", strings.ToLower(mode))
+
+	var busy string
+
+	row = w.DB().Raw("pragma busy_timeout").Row()
+	require.NoError(t, row.Scan(&busy))
+	assert.Equal(t, "10000", busy)
+}
+
+// TestStatArchive proves Stat finds no file before the first
+// write; after a write still held in the -wal, counts the -wal in the
+// size and takes its later time as the last write; and finds no file
+// again once the file has been moved away.
+func TestStatArchive(t *testing.T) {
+	t.Parallel()
+
+	path := filepath.Join(t.TempDir(), "archive-wh.db")
+
+	_, err := archive.Stat(path)
+	require.ErrorIs(t, err, fs.ErrNotExist)
+
+	// With the clock stopped, the reopen debounce never passes, so
+	// the handle stays open after the write.
+	stopped := time.Now()
+	w := archive.NewExportArchiveWriter(path, archiveTestLogger(), 0)
+	w.SetNow(func() time.Time { return stopped })
+
+	require.NoError(t, w.Write(archive.ExportArchivedEvent{EventID: "a"}, 0))
+
+	written := time.Date(2026, 1, 2, 3, 4, 5, 0, time.UTC)
+	earlier := written.Add(-time.Hour)
+	require.NoError(t, os.Chtimes(path, earlier, earlier))
+	require.NoError(t, os.Chtimes(path+"-wal", written, written))
+
+	file, err := os.Stat(path)
+	require.NoError(t, err)
+
+	wal, err := os.Stat(path + "-wal")
+	require.NoError(t, err)
+	require.Positive(t, wal.Size())
+
+	got, err := archive.Stat(path)
+	require.NoError(t, err)
+	assert.Equal(t, 1, got.Files)
+	assert.Equal(t, file.Size()+wal.Size(), got.Size)
+	assert.True(t, written.Equal(got.Written), got.Written)
+
+	removeArchiveFiles(t, path)
+
+	_, err = archive.Stat(path)
+	require.ErrorIs(t, err, fs.ErrNotExist)
+}
+
+func TestArchiveWriter_ReopenDebounce(t *testing.T) {
+	t.Parallel()
+
+	const debounce = 2 * time.Second
+
+	path := filepath.Join(t.TempDir(), "archive-wh.db")
+	w := archive.NewExportArchiveWriter(
+		path, archiveTestLogger(), debounce,
+	)
+
+	// The writer measures its reopen debounce on this clock, which
+	// only the test moves, so how long the host takes between
+	// writes cannot change the result.
+	now := time.Now()
+
+	w.SetNow(func() time.Time { return now })
+
+	require.NoError(t, w.Write(
+		archive.ExportArchivedEvent{EventID: "a"}, 0,
+	))
+	require.NoError(t, w.Write(
+		archive.ExportArchivedEvent{EventID: "b"}, 0,
+	))
+
+	// Two writes inside the debounce window trigger only the
+	// initial open — no extra close/reopen.
+	assert.Equal(t, 1, w.Reopens())
+
+	now = now.Add(debounce)
+
+	require.NoError(t, w.Write(
+		archive.ExportArchivedEvent{EventID: "c"}, 0,
+	))
+
+	// A write after the window elapses closes and reopens once.
+	assert.Equal(t, 2, w.Reopens())
+}
+
+func TestArchiveWriter_ExpiryPrune(t *testing.T) {
+	t.Parallel()
+
+	path := filepath.Join(t.TempDir(), "archive-wh.db")
+	w := archive.NewExportArchiveWriter(
+		path, archiveTestLogger(), 0,
+	)
+
+	require.NoError(t, w.Open(0))
+
+	old := archive.ExportArchivedEvent{
+		EventID:    "old",
+		ArchivedAt: time.Now().Add(-2 * time.Hour),
+	}
+	fresh := archive.ExportArchivedEvent{
+		EventID:    "fresh",
+		ArchivedAt: time.Now(),
+	}
+
+	require.NoError(t, w.DB().Create(&old).Error)
+	require.NoError(t, w.DB().Create(&fresh).Error)
+
+	// Reopening with a one-hour expiry prunes the old row.
+	require.NoError(t, w.Reopen(time.Hour))
+
+	var got []archive.ExportArchivedEvent
+
+	require.NoError(t, w.DB().Find(&got).Error)
+	require.Len(t, got, 1)
+	assert.Equal(t, "fresh", got[0].EventID)
+}
+
+func TestParseArchiveExpiry(t *testing.T) {
+	t.Parallel()
+
+	cases := []struct {
+		name    string
+		in      string
+		want    time.Duration
+		wantErr bool
+	}{
+		{"empty config", "", 0, false},
+		{"explicit never", `{"expiry":"never"}`, 0, false},
+		{"empty expiry", `{"expiry":""}`, 0, false},
+		{"duration", `{"expiry":"1h"}`, time.Hour, false},
+		{"unparseable", `{"expiry":"nonsense"}`, 0, true},
+		{"zero duration", `{"expiry":"0s"}`, 0, true},
+		{"negative duration", `{"expiry":"-5h"}`, 0, true},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			got, err := archive.ParseExpiry(tc.in)
+			if tc.wantErr {
+				require.Error(t, err)
+
+				return
+			}
+
+			require.NoError(t, err)
+			assert.Equal(t, tc.want, got)
+		})
+	}
+}
+
+func TestValidateArchiveExpiry(t *testing.T) {
+	t.Parallel()
+
+	valid := []string{"", "never", "1h", "720h", "30m"}
+	for _, in := range valid {
+		require.NoError(t,
+			archive.ValidateExpiry(in),
+			"expiry %q should be accepted", in,
+		)
+	}
+
+	invalid := []string{"nonsense", "7d", "-5h", "0s", "0"}
+	for _, in := range invalid {
+		require.Error(t,
+			archive.ValidateExpiry(in),
+			"expiry %q should be rejected", in,
+		)
+	}
+}
+
+// TestArchiveFileName pins the archive file name and the rules
+// that make a webhook or target name safe to put in it.
+func TestArchiveFileName(t *testing.T) {
+	t.Parallel()
+
+	const id = "3f2a1c9e-8d4b-4c1a-9e2f-0a1b2c3d4e5f"
+
+	cases := []struct {
+		name    string
+		webhook string
+		target  string
+		want    string
+	}{
+		{
+			"plain names", "orders", "archive",
+			"archive-orders-archive-" + id + ".db",
+		},
+		{
+			"lowercased", "Orders", "Main Archive",
+			"archive-orders-main-archive-" + id + ".db",
+		},
+		{
+			"a run of other characters is one dash",
+			`a  /\..b`, "c__--d",
+			"archive-a-b-c-d-" + id + ".db",
+		},
+		{
+			"no dash at either end", "  --orders!! ", "(archive)",
+			"archive-orders-archive-" + id + ".db",
+		},
+		{
+			"path separators", "../../etc/passwd", "a/b",
+			"archive-etc-passwd-a-b-" + id + ".db",
+		},
+		{
+			"letters outside ASCII are dropped",
+			"Bestellungen Größe", "café",
+			"archive-bestellungen-gr-e-caf-" + id + ".db",
+		},
+		{
+			"nothing left is unnamed", "", "!!!",
+			"archive-unnamed-unnamed-" + id + ".db",
+		},
+		{
+			"cut to 40 characters", strings.Repeat("a", 50), "x",
+			"archive-" + strings.Repeat("a", 40) + "-x-" + id + ".db",
+		},
+		{
+			"no dash left by the cut",
+			strings.Repeat("a", 39) + " b", "x",
+			"archive-" + strings.Repeat("a", 39) + "-x-" + id + ".db",
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			assert.Equal(
+				t, tc.want,
+				archive.FileName(tc.webhook, tc.target, id),
+			)
+		})
+	}
+}
+
+// TestWrite_EachTargetHasItsOwnArchive proves two
+// database targets of one webhook archive into separate files.
+func TestWrite_EachTargetHasItsOwnArchive(t *testing.T) {
+	t.Parallel()
+
+	env := setupArchiveTest(t)
+	first := env.seedDatabaseTarget(t, "")
+	second := env.addDatabaseTarget(t, first.WebhookID, "")
+
+	event := newEvent(`{"n":1}`)
+
+	for _, tgt := range []*database.Target{first, second} {
+		require.NoError(t, env.writers.Write(
+			databaseTargetDelivery(event, tgt),
+		))
+	}
+
+	require.NotEqual(
+		t, env.archivePath(first), env.archivePath(second),
+	)
+	assert.Equal(
+		t, []string{event.ID},
+		archivedEventIDs(t, env.archivePath(first)),
+	)
+	assert.Equal(
+		t, []string{event.ID},
+		archivedEventIDs(t, env.archivePath(second)),
+	)
+}
+
+// TestRename_MovesTheFile proves a rename moves the archive, rows
+// and all, and that later writes go to the new name.
+func TestRename_MovesTheFile(t *testing.T) {
+	t.Parallel()
+
+	env := setupArchiveTest(t)
+	tgt := env.seedDatabaseTarget(t, "")
+	oldPath := env.archivePath(tgt)
+
+	first := newEvent(`{"n":1}`)
+	require.NoError(t, env.writers.Write(databaseTargetDelivery(first, tgt)))
+	require.FileExists(t, oldPath)
+
+	require.NoError(
+		t, env.writers.Rename(tgt.ID, "Orders", "Long Term"),
+	)
+
+	newPath := filepath.Join(
+		env.dataDir, "archive-orders-long-term-"+tgt.ID+".db",
+	)
+
+	assert.NoFileExists(t, oldPath)
+	assert.Equal(t, []string{first.ID}, archivedEventIDs(t, newPath))
+
+	second := newEvent(`{"n":2}`)
+	require.NoError(t, env.writers.Write(databaseTargetDelivery(second, tgt)))
+
+	assert.ElementsMatch(
+		t, []string{first.ID, second.ID},
+		archivedEventIDs(t, newPath),
+	)
+	assert.NoFileExists(
+		t, oldPath, "a write after the rename must use the new name",
+	)
+}
+
+// TestRename_NeverReplacesAFile plants a file at the new name, once
+// the .db alone, once a lone -wal and once a lone -shm, and proves
+// each time that the rename is refused, the planted file survives,
+// and the archive keeps its name and its rows.
+func TestRename_NeverReplacesAFile(t *testing.T) {
+	t.Parallel()
+
+	for _, suffix := range archiveFileSuffixes() {
+		t.Run("planted .db"+suffix, func(t *testing.T) {
+			t.Parallel()
+
+			env := setupArchiveTest(t)
+			tgt := env.seedDatabaseTarget(t, "")
+			oldPath := env.archivePath(tgt)
+
+			first := newEvent(`{"n":1}`)
+			require.NoError(
+				t, env.writers.Write(databaseTargetDelivery(first, tgt)),
+			)
+
+			newPath := filepath.Join(
+				env.dataDir, "archive-orders-long-term-"+tgt.ID+".db",
+			)
+			plantedPath := newPath + suffix
+			require.NoError(
+				t, os.WriteFile(plantedPath, []byte("planted"), 0o600),
+			)
+
+			require.ErrorIs(
+				t, env.writers.Rename(tgt.ID, "Orders", "Long Term"),
+				archive.ErrNameTaken,
+			)
+
+			//nolint:gosec // reads the file the test planted under t.TempDir()
+			planted, err := os.ReadFile(plantedPath)
+			require.NoError(t, err)
+			assert.Equal(t, "planted", string(planted))
+
+			second := newEvent(`{"n":2}`)
+			require.NoError(
+				t, env.writers.Write(databaseTargetDelivery(second, tgt)),
+			)
+
+			assert.ElementsMatch(
+				t, []string{first.ID, second.ID},
+				archivedEventIDs(t, oldPath),
+			)
+		})
+	}
+}
+
+// TestRename_BeforeTheNameIsSaved covers the order the handlers
+// use: they rename before they save the new name, so a delivery in
+// between must write under the new name although the main database
+// still has the old one. It also shows that renaming an archive that
+// does not exist yet is not an error.
+func TestRename_BeforeTheNameIsSaved(t *testing.T) {
+	t.Parallel()
+
+	env := setupArchiveTest(t)
+	tgt := env.seedDatabaseTarget(t, "")
+
+	require.NoError(
+		t, env.writers.Rename(tgt.ID, "Orders", "Archive"),
+	)
+
+	event := newEvent(`{"n":1}`)
+	require.NoError(t, env.writers.Write(databaseTargetDelivery(event, tgt)))
+
+	assert.FileExists(
+		t,
+		filepath.Join(
+			env.dataDir, "archive-orders-archive-"+tgt.ID+".db",
+		),
+	)
+	assert.NoFileExists(t, env.archivePath(tgt))
+}
+
+// TestArchiveWriter_RenameMovesSidecars proves a rename carries
+// the -wal and -shm a crash can leave beside an archive no handle
+// has opened since. SQLite finds them by name, so a -wal left
+// behind would lose the transactions it holds.
+func TestArchiveWriter_RenameMovesSidecars(t *testing.T) {
+	t.Parallel()
+
+	dir := t.TempDir()
+	oldPath := filepath.Join(dir, "archive-old.db")
+	newPath := filepath.Join(dir, "archive-new.db")
+
+	for _, suffix := range archiveFileSuffixes() {
+		require.NoError(
+			t, os.WriteFile(oldPath+suffix, []byte(suffix), 0o600),
+		)
+	}
+
+	w := archive.NewExportArchiveWriter(
+		oldPath, archiveTestLogger(), 0,
+	)
+
+	require.NoError(t, w.Rename("archive-new.db"))
+
+	for _, suffix := range archiveFileSuffixes() {
+		assert.NoFileExists(t, oldPath+suffix)
+		assert.FileExists(t, newPath+suffix)
+	}
+
+	assert.Equal(t, newPath, w.Path())
+}
+
+// TestArchiveWriter_RenameMovesBackOnFailure makes the -wal fail to
+// move after the .db has moved, and proves the .db is moved back, so
+// the archive is never split across two names. The new name is 255
+// bytes, the longest a file name may be, so the .db can take it but
+// the -wal, four bytes longer, cannot.
+func TestArchiveWriter_RenameMovesBackOnFailure(t *testing.T) {
+	t.Parallel()
+
+	dir := t.TempDir()
+	oldPath := filepath.Join(dir, "archive-old.db")
+	newName := strings.Repeat("a", 252) + ".db"
+
+	for _, suffix := range archiveFileSuffixes() {
+		require.NoError(
+			t, os.WriteFile(oldPath+suffix, []byte(suffix), 0o600),
+		)
+	}
+
+	w := archive.NewExportArchiveWriter(
+		oldPath, archiveTestLogger(), 0,
+	)
+
+	require.Error(t, w.Rename(newName))
+
+	for _, suffix := range archiveFileSuffixes() {
+		assert.FileExists(t, oldPath+suffix)
+	}
+
+	assert.NoFileExists(t, filepath.Join(dir, newName))
+	assert.Equal(t, oldPath, w.Path())
+}
+
+// TestArchiveWriter_RenameMovesBackEveryFile renames a target with a
+// file without a period and a file for a month, and proves that when
+// the month's file fails to move, the file already moved is moved back:
+// both files are under the old name with their rows, and nothing is
+// under the new name. The new name is 251 bytes, so the file without a
+// period, with its -wal and -shm, can take it, but the month's file,
+// eight bytes longer, cannot.
+func TestArchiveWriter_RenameMovesBackEveryFile(t *testing.T) {
+	t.Parallel()
+
+	dir := t.TempDir()
+	oldPath := filepath.Join(dir, "archive-old.db")
+	monthPath := filepath.Join(dir, "archive-old-2026-03.db")
+	w := archive.NewExportArchiveWriter(oldPath, archiveTestLogger(), 0)
+
+	require.NoError(t, w.WritePeriod(
+		archive.ExportArchivedEvent{EventID: "in-none"}, 0, "",
+	))
+	require.NoError(t, w.WritePeriod(
+		archive.ExportArchivedEvent{EventID: "in-month"}, 0, "2026-03",
+	))
+
+	require.Error(t, w.Rename(strings.Repeat("a", 248)+".db"))
+
+	assert.Equal(t, []string{"in-none"}, archivedEventIDs(t, oldPath))
+	assert.Equal(t, []string{"in-month"}, archivedEventIDs(t, monthPath))
+
+	entries, err := os.ReadDir(dir)
+	require.NoError(t, err)
+
+	for _, entry := range entries {
+		assert.True(t, strings.HasPrefix(entry.Name(), "archive-old"),
+			"%s is not under the old name", entry.Name())
+	}
+
+	assert.Equal(t, oldPath, w.Path())
+}
+
+// TestRenameLock_HeldByOneEditAtATime holds the rename lock, as an edit
+// does from loading the stored names until it has saved them. While it
+// is held, the edit's rename and an archive write still finish, since
+// neither takes it, and the event ends up under the new name whichever
+// ran first. A second edit waits for the lock until the first lets go.
+func TestRenameLock_HeldByOneEditAtATime(t *testing.T) {
+	t.Parallel()
+
+	env := setupArchiveTest(t)
+	tgt := env.seedDatabaseTarget(t, "")
+	event := newEvent(`{"n":1}`)
+
+	env.writers.RenameLock().Lock()
+
+	finished := make(chan error, 2)
+
+	go func() {
+		finished <- env.writers.Rename(tgt.ID, "Orders", "Long Term")
+	}()
+	go func() {
+		finished <- env.writers.Write(databaseTargetDelivery(event, tgt))
+	}()
+
+	for range 2 {
+		select {
+		case err := <-finished:
+			require.NoError(t, err)
+		case <-time.After(10 * time.Second):
+			t.Fatal("a rename or a write waited for the rename lock")
+		}
+	}
+
+	newPath := filepath.Join(
+		env.dataDir, "archive-orders-long-term-"+tgt.ID+".db",
+	)
+	assert.Equal(t, []string{event.ID}, archivedEventIDs(t, newPath))
+
+	secondEdit := make(chan struct{})
+
+	go func() {
+		env.writers.RenameLock().Lock()
+		close(secondEdit)
+		env.writers.RenameLock().Unlock()
+	}()
+
+	select {
+	case <-secondEdit:
+		t.Fatal("a second edit took the rename lock while it was held")
+	case <-time.After(100 * time.Millisecond):
+	}
+
+	env.writers.RenameLock().Unlock()
+
+	select {
+	case <-secondEdit:
+	case <-time.After(10 * time.Second):
+		t.Fatal("a second edit did not get the rename lock once released")
+	}
+}

internal/archive/download.go

@@ -1,4 +1,4 @@
-package delivery
+package archive
 
 import (
 	"compress/gzip"
@@ -28,25 +28,25 @@ import (
 const archiveTableQuery = "SELECT count(*) FROM sqlite_master " +
 	"WHERE type = 'table' AND name = 'archived_events'"
 
-// ArchivePath returns where a database target's archive file is: in
+// Path returns where a database target's archive file is: in
 // the data directory, beside the webhook's event database, under the
-// name ArchiveFileName gives it.
+// name FileName gives it.
-func ArchivePath(
+func Path(
 	dbMgr *database.WebhookDBManager,
 	webhook *database.Webhook,
 	target *database.Target,
 ) string {
 	return filepath.Join(
 		filepath.Dir(dbMgr.DBPath(webhook.ID)),
-		ArchiveFileName(webhook.Name, target.Name, target.ID),
+		FileName(webhook.Name, target.Name, target.ID),
 	)
 }
 
-// ArchiveExportFileName returns the name a database target's archive
+// ExportFileName returns the name a database target's archive
 // downloads under:
 // archive-WEBHOOKNAME-TARGETNAME-YYYYMMDDTHHMMSSZ.json.gz, the names
-// made safe as in ArchiveFileName and the time in UTC.
+// made safe as in FileName and the time in UTC.
-func ArchiveExportFileName(
+func ExportFileName(
 	webhookName, targetName string, at time.Time,
 ) string {
 	return "archive-" + archiveNamePart(webhookName) + "-" +
@@ -54,7 +54,7 @@ func ArchiveExportFileName(
 		at.UTC().Format("20060102T150405Z") + ".json.gz"
 }
 
-// ArchiveExport is a database target's archive listed for download. It
+// Export is a database target's archive listed for download. It
 // opens one of the target's files at a time, only when its rows are
 // about to be written out, and closes it before it opens the next, so
 // an export holds at most one file open however many the target has.
@@ -66,7 +66,7 @@ func ArchiveExportFileName(
 // is open, and the export does not see them. SQLite cannot checkpoint
 // a -wal past an open snapshot, so the open file's -wal grows until the
 // export has written that file out.
-type ArchiveExport struct {
+type Export struct {
 	// periods are the periods of the target's files when the export
 	// was listed, "" for the file without one, in the order
 	// archiveFiles lists them.
@@ -77,7 +77,7 @@ type ArchiveExport struct {
 	// between.
 	lock sync.Locker
 
-	// currentPath returns the path ArchivePath gives the target under
+	// currentPath returns the path Path gives the target under
 	// the names stored for it now, which a rename may have changed since
 	// the export was listed.
 	currentPath func() (string, error)
@@ -103,11 +103,12 @@ type exportedName struct {
 	Name string `json:"name"`
 }
 
-// NewArchiveExport lists a database target's archive files for export,
+// NewExport lists a database target's archive files for export,
-// given the path ArchivePath gives it (see archiveFiles). It opens none
+// given the path Path gives it (see archiveFiles). It opens none
 // of them. Its caller holds lock, which every rename of the target's
-// files runs under, from reading the names path is made of until it
+// files runs under (Writers.RenameLock returns it), from reading the names
-// returns, so the files it lists are the ones those names give.
+// path is made of until it returns, so the files it lists are the ones
+// those names give.
 //
 // WriteGzipJSON, called without lock held, finds each file again by its
 // period under the path currentPath gives, holding lock while it does
@@ -115,18 +116,18 @@ type exportedName struct {
 // file. A file that is gone by then, emptied by the sweep or moved
 // away, is skipped. The export never creates a file: with no files, it
 // has no rows.
-func NewArchiveExport(
+func NewExport(
 	path string,
 	lock sync.Locker,
 	currentPath func() (string, error),
 	log *slog.Logger,
-) (*ArchiveExport, error) {
+) (*Export, error) {
 	files, err := archiveFiles(path)
 	if err != nil {
 		return nil, err
 	}
 
-	x := &ArchiveExport{lock: lock, currentPath: currentPath, log: log}
+	x := &Export{lock: lock, currentPath: currentPath, log: log}
 
 	for _, file := range files {
 		x.periods = append(x.periods, file.period)
@@ -199,7 +200,7 @@ func openExportFile(
 // closed once its rows are written, before the next is opened. When it
 // returns, no file is open. After an error the gzip stream is left
 // unfinished, so what was written does not decompress as a whole file.
-func (x *ArchiveExport) WriteGzipJSON(
+func (x *Export) WriteGzipJSON(
 	ctx context.Context,
 	w io.Writer,
 	webhook *database.Webhook,
@@ -228,7 +229,7 @@ func (x *ArchiveExport) WriteGzipJSON(
 // openFile finds the target's archive file for period under the path
 // currentPath gives now, and opens it for the export, holding x.lock
 // for both. For a file that is gone, the error wraps fs.ErrNotExist.
-func (x *ArchiveExport) openFile(
+func (x *Export) openFile(
 	ctx context.Context, period string,
 ) (*exportFile, error) {
 	x.lock.Lock()
@@ -258,7 +259,7 @@ func (f *exportFile) close() error {
 
 // writeJSON writes head with archived_events added as its last key,
 // the rows going into it one at a time.
-func (x *ArchiveExport) writeJSON(
+func (x *Export) writeJSON(
 	ctx context.Context, w io.Writer, head []byte,
 ) error {
 	// head goes out without its closing brace, so that
@@ -286,7 +287,7 @@ func (x *ArchiveExport) writeJSON(
 // writeRows writes the archived rows of each file to w, one per line,
 // separated by commas, opening each file in turn and closing it once
 // its rows are written.
-func (x *ArchiveExport) writeRows(ctx context.Context, w io.Writer) error {
+func (x *Export) writeRows(ctx context.Context, w io.Writer) error {
 	sep := "\n"
 
 	for _, period := range x.periods {

internal/archive/download_test.go

@@ -1,4 +1,4 @@
-package delivery_test
+package archive_test
 
 import (
 	"bufio"
@@ -19,8 +19,8 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/webhooker/internal/archive"
 	"sneak.berlin/go/webhooker/internal/database"
-	"sneak.berlin/go/webhooker/internal/delivery"
 )
 
 // The webhook and the target the export tests' archives belong to.
@@ -37,7 +37,7 @@ const binaryBody = "\xff\xfe\x00\x01binary\x80"
 // writeExportTo writes export to w as the archive of the export tests'
 // webhook and target, exported at 2026-10-02T12:03:04Z.
 func writeExportTo(
-	t *testing.T, export *delivery.ArchiveExport, w io.Writer,
+	t *testing.T, export *archive.Export, w io.Writer,
 ) error {
 	t.Helper()
 
@@ -57,7 +57,7 @@ func writeExportTo(
 
 // listExport lists the archive at path for export, as the archive of a
 // target whose names do not change.
-func listExport(t *testing.T, path string) *delivery.ArchiveExport {
+func listExport(t *testing.T, path string) *archive.Export {
 	t.Helper()
 
 	return newExport(t, path, &sync.Mutex{}, func() (string, error) {
@@ -73,10 +73,10 @@ func newExport(
 	path string,
 	lock sync.Locker,
 	currentPath func() (string, error),
-) *delivery.ArchiveExport {
+) *archive.Export {
 	t.Helper()
 
-	export, err := delivery.NewArchiveExport(
+	export, err := archive.NewExport(
 		path, lock, currentPath, archiveTestLogger(),
 	)
 	require.NoError(t, err)
@@ -96,7 +96,7 @@ func exportArchive(t *testing.T, path string) map[string]any {
 // decompressed and parsed. Reading to the end makes the gzip reader
 // check that the stream was finished.
 func writeExport(
-	t *testing.T, export *delivery.ArchiveExport,
+	t *testing.T, export *archive.Export,
 ) map[string]any {
 	t.Helper()
 
@@ -157,11 +157,11 @@ func TestArchiveExport_MatchesStoredRows(t *testing.T) {
 	t.Parallel()
 
 	path := filepath.Join(t.TempDir(), "archive.db")
-	w := delivery.NewExportArchiveWriter(path, archiveTestLogger(), 0)
+	w := archive.NewExportArchiveWriter(path, archiveTestLogger(), 0)
 	bodies := []string{`{"order":1}`, "plain text", "", binaryBody}
 
 	for i, body := range bodies {
-		require.NoError(t, w.Write(delivery.ExportArchivedEvent{
+		require.NoError(t, w.Write(archive.ExportArchivedEvent{
 			EventID:      fmt.Sprintf("ev-%d", i),
 			WebhookID:    exportWebhookID,
 			EntrypointID: "ep-1",
@@ -173,7 +173,7 @@ func TestArchiveExport_MatchesStoredRows(t *testing.T) {
 		}, 0))
 	}
 
-	var stored []delivery.ExportArchivedEvent
+	var stored []archive.ExportArchivedEvent
 
 	require.NoError(t, openArchiveDBForRead(t, path).
 		Order("id").Find(&stored).Error)
@@ -201,7 +201,7 @@ func TestArchiveExport_MatchesStoredRows(t *testing.T) {
 // assertExportedRow checks that ev, from an export, holds every column
 // of the stored row.
 func assertExportedRow(
-	t *testing.T, row delivery.ExportArchivedEvent, ev map[string]any,
+	t *testing.T, row archive.ExportArchivedEvent, ev map[string]any,
 ) {
 	t.Helper()
 
@@ -248,7 +248,7 @@ func TestArchiveExport_Empty(t *testing.T) {
 
 	require.NoError(t, os.WriteFile(noTable, nil, 0o600))
 	require.NoError(t,
-		delivery.NewExportArchiveWriter(noRows, archiveTestLogger(), 0).
+		archive.NewExportArchiveWriter(noRows, archiveTestLogger(), 0).
 			Open(0),
 	)
 
@@ -284,18 +284,18 @@ func TestArchiveExport_ReadsOneSnapshot(t *testing.T) {
 	t.Parallel()
 
 	path := filepath.Join(t.TempDir(), "archive.db")
-	w := delivery.NewExportArchiveWriter(path, archiveTestLogger(), 0)
+	w := archive.NewExportArchiveWriter(path, archiveTestLogger(), 0)
 
-	require.NoError(t, w.Write(delivery.ExportArchivedEvent{EventID: "listed"}, 0))
+	require.NoError(t, w.Write(archive.ExportArchivedEvent{EventID: "listed"}, 0))
 
 	opened := &unlockHook{fn: func() {
-		require.NoError(t, w.Write(delivery.ExportArchivedEvent{EventID: "during"}, 0))
+		require.NoError(t, w.Write(archive.ExportArchivedEvent{EventID: "during"}, 0))
 	}}
 	export := newExport(t, path, opened, func() (string, error) {
 		return path, nil
 	})
 
-	require.NoError(t, w.Write(delivery.ExportArchivedEvent{EventID: "before-open"}, 0))
+	require.NoError(t, w.Write(archive.ExportArchivedEvent{EventID: "before-open"}, 0))
 
 	assert.Equal(t,
 		[]string{"listed", "before-open"},
@@ -305,7 +305,7 @@ func TestArchiveExport_ReadsOneSnapshot(t *testing.T) {
 	var stored int64
 
 	require.NoError(t, openArchiveDBForRead(t, path).
-		Model(&delivery.ExportArchivedEvent{}).Count(&stored).Error)
+		Model(&archive.ExportArchivedEvent{}).Count(&stored).Error)
 	assert.Equal(t, int64(3), stored)
 }
 
@@ -318,11 +318,11 @@ func TestArchiveExport_FindsFilesAfterRename(t *testing.T) {
 
 	dir := t.TempDir()
 	path := filepath.Join(dir, "archive-old.db")
-	w := delivery.NewExportArchiveWriter(path, archiveTestLogger(), 0)
+	w := archive.NewExportArchiveWriter(path, archiveTestLogger(), 0)
 
 	for _, period := range []string{"", dayPeriod, hourPeriod} {
 		require.NoError(t, w.WritePeriod(
-			delivery.ExportArchivedEvent{EventID: "in-" + period}, 0, period,
+			archive.ExportArchivedEvent{EventID: "in-" + period}, 0, period,
 		))
 	}
 
@@ -353,19 +353,19 @@ func TestArchiveExport_EveryFileOldestFirst(t *testing.T) {
 	t.Parallel()
 
 	path := filepath.Join(t.TempDir(), "archive-wh.db")
-	w := delivery.NewExportArchiveWriter(path, archiveTestLogger(), 0)
+	w := archive.NewExportArchiveWriter(path, archiveTestLogger(), 0)
 
 	// Written in an order that is not the export's.
 	for _, period := range []string{nextDayPeriod, "", hourPeriod, "2026-03"} {
 		require.NoError(t, w.WritePeriod(
-			delivery.ExportArchivedEvent{EventID: "in-" + period}, 0, period,
+			archive.ExportArchivedEvent{EventID: "in-" + period}, 0, period,
 		))
 	}
 
 	export := listExport(t, path)
 
 	require.NoError(t, w.WritePeriod(
-		delivery.ExportArchivedEvent{EventID: "later"}, 0, "2026-03-06",
+		archive.ExportArchivedEvent{EventID: "later"}, 0, "2026-03-06",
 	))
 
 	events := exportedEvents(t, writeExport(t, export))
@@ -434,13 +434,13 @@ func TestArchiveExport_OneFileOpenAtATime(t *testing.T) {
 	require.NoError(t, err)
 
 	path := filepath.Join(dir, "archive-wh.db")
-	w := delivery.NewExportArchiveWriter(path, archiveTestLogger(), 0)
+	w := archive.NewExportArchiveWriter(path, archiveTestLogger(), 0)
 	random := make([]byte, 36<<10)
 
 	for hour := range 24 {
 		_, _ = rand.Read(random)
 
-		require.NoError(t, w.WritePeriod(delivery.ExportArchivedEvent{
+		require.NoError(t, w.WritePeriod(archive.ExportArchivedEvent{
 			Body: base64.StdEncoding.EncodeToString(random),
 		}, 0, fmt.Sprintf("2026-10-01-%02d", hour)))
 	}
@@ -489,7 +489,7 @@ func exportHeapGrowth(t *testing.T, rows, bodySize int) uint64 {
 	t.Helper()
 
 	path := filepath.Join(t.TempDir(), "archive.db")
-	w := delivery.NewExportArchiveWriter(path, archiveTestLogger(), 0)
+	w := archive.NewExportArchiveWriter(path, archiveTestLogger(), 0)
 
 	// Base64 makes four characters of every three bytes.
 	random := make([]byte, bodySize/4*3)
@@ -497,7 +497,7 @@ func exportHeapGrowth(t *testing.T, rows, bodySize int) uint64 {
 	for range rows {
 		_, _ = rand.Read(random)
 
-		require.NoError(t, w.Write(delivery.ExportArchivedEvent{
+		require.NoError(t, w.Write(archive.ExportArchivedEvent{
 			Body: base64.StdEncoding.EncodeToString(random),
 		}, 0))
 	}
@@ -565,7 +565,7 @@ func TestArchiveExportFileName(t *testing.T) {
 
 	assert.Equal(t,
 		"archive-orders-eu-long-term-archive-20261002T120304Z.json.gz",
-		delivery.ArchiveExportFileName(
+		archive.ExportFileName(
 			exportWebhookName, exportTargetName,
 			time.Date(2026, 10, 2, 14, 3, 4, 0, cest),
 		),

internal/archive/evict_test.go

@@ -1,7 +1,6 @@
-package delivery_test
+package archive_test
 
 import (
-	"context"
 	"errors"
 	"fmt"
 	"net/http"
@@ -13,8 +12,8 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/webhooker/internal/archive"
 	"sneak.berlin/go/webhooker/internal/database"
-	"sneak.berlin/go/webhooker/internal/delivery"
 )
 
 // deliverTo archives one event to a database target, leaving the
@@ -24,12 +23,9 @@ func deliverTo(
 ) {
 	t.Helper()
 
-	webhookDB := testWebhookDB(t)
+	event := newEvent(`{"archived":true}`)
-	event := seedEvent(t, webhookDB, `{"archived":true}`)
 
-	env.eng.ExportDeliverDatabase(
+	require.NoError(t, env.writers.Write(databaseTargetDelivery(event, tgt)))
-		webhookDB, seedDatabaseTargetDelivery(t, webhookDB, event, tgt),
-	)
 }
 
 // TestEvictWebhook_ClosesAndRemovesWriter proves that evicting
@@ -49,20 +45,20 @@ func TestEvictWebhook_ClosesAndRemovesWriter(t *testing.T) {
 		deliverTo(t, env, tgt)
 
 		require.True(
-			t, env.eng.ExportArchiveHandleOpen(tgt.ID),
+			t, env.writers.ExportArchiveHandleOpen(tgt.ID),
 			"the writer should hold an open handle after a write",
 		)
 	}
 
-	env.eng.EvictWebhook(first.WebhookID)
+	env.writers.EvictWebhook(first.WebhookID)
 
 	for _, tgt := range []*database.Target{first, second} {
 		assert.False(
-			t, env.eng.ExportHasArchiveWriter(tgt.ID),
+			t, env.writers.ExportHasArchiveWriter(tgt.ID),
 			"eviction should remove the registry entry",
 		)
 		assert.False(
-			t, env.eng.ExportArchiveHandleOpen(tgt.ID),
+			t, env.writers.ExportArchiveHandleOpen(tgt.ID),
 			"eviction should close the archive handle",
 		)
 		assert.FileExists(
@@ -72,7 +68,7 @@ func TestEvictWebhook_ClosesAndRemovesWriter(t *testing.T) {
 	}
 
 	assert.True(
-		t, env.eng.ExportArchiveHandleOpen(other.ID),
+		t, env.writers.ExportArchiveHandleOpen(other.ID),
 		"another webhook's writer must be left alone",
 	)
 }
@@ -90,15 +86,15 @@ func TestEvictTarget_LeavesOtherTargets(t *testing.T) {
 	deliverTo(t, env, doomed)
 	deliverTo(t, env, kept)
 
-	env.eng.EvictTarget(doomed.ID)
+	env.writers.EvictTarget(doomed.ID)
 
-	assert.False(t, env.eng.ExportHasArchiveWriter(doomed.ID))
+	assert.False(t, env.writers.ExportHasArchiveWriter(doomed.ID))
 	assert.FileExists(
 		t, env.archivePath(doomed),
 		"eviction must not delete the archive file",
 	)
 	assert.True(
-		t, env.eng.ExportArchiveHandleOpen(kept.ID),
+		t, env.writers.ExportArchiveHandleOpen(kept.ID),
 		"the other target's writer must be left alone",
 	)
 }
@@ -112,21 +108,21 @@ func TestEvictWebhook_UnknownWebhookIsNoOp(t *testing.T) {
 	env := setupArchiveTest(t)
 
 	assert.NotPanics(t, func() {
-		env.eng.EvictWebhook("no-such-webhook")
+		env.writers.EvictWebhook("no-such-webhook")
-		env.eng.EvictWebhook("no-such-webhook")
+		env.writers.EvictWebhook("no-such-webhook")
-		env.eng.EvictTarget("no-such-target")
+		env.writers.EvictTarget("no-such-target")
-		env.eng.EvictTarget("no-such-target")
+		env.writers.EvictTarget("no-such-target")
 	})
 
 	assert.False(
-		t, env.eng.ExportHasArchiveWriter("no-such-target"),
+		t, env.writers.ExportHasArchiveWriter("no-such-target"),
 		"eviction must not create a writer",
 	)
 }
 
 // evictTestRow builds an archive row for the eviction tests.
-func evictTestRow(eventID string) delivery.ExportArchivedEvent {
+func evictTestRow(eventID string) archive.ExportArchivedEvent {
-	return delivery.ExportArchivedEvent{
+	return archive.ExportArchivedEvent{
 		EventID:   eventID,
 		WebhookID: "wh-evict",
 		Method:    http.MethodPost,
@@ -147,7 +143,7 @@ func TestEvictedWriter_WriteDoesNotReopenFile(t *testing.T) {
 
 	path := filepath.Join(t.TempDir(), "archive-evicted.db")
 
-	w := delivery.NewExportArchiveWriter(
+	w := archive.NewExportArchiveWriter(
 		path, archiveTestLogger(), 0,
 	)
 
@@ -164,7 +160,7 @@ func TestEvictedWriter_WriteDoesNotReopenFile(t *testing.T) {
 	err := w.Write(evictTestRow("ev-2"), 0)
 
 	require.ErrorIs(
-		t, err, delivery.ErrExportArchiveWriterEvicted,
+		t, err, archive.ErrExportArchiveWriterEvicted,
 		"an evicted writer must refuse writes",
 	)
 	assert.NoFileExists(
@@ -187,7 +183,7 @@ func TestEvictedWriter_SweepDoesNotReopenFile(t *testing.T) {
 
 	path := filepath.Join(t.TempDir(), "archive-evicted.db")
 
-	w := delivery.NewExportArchiveWriter(
+	w := archive.NewExportArchiveWriter(
 		path, archiveTestLogger(), 0,
 	)
 
@@ -199,7 +195,7 @@ func TestEvictedWriter_SweepDoesNotReopenFile(t *testing.T) {
 	err := w.SweepExpired(time.Hour)
 
 	require.ErrorIs(
-		t, err, delivery.ErrExportArchiveWriterEvicted,
+		t, err, archive.ErrExportArchiveWriterEvicted,
 		"an evicted writer must refuse an idle sweep",
 	)
 	assert.False(
@@ -230,7 +226,7 @@ const racingWriteGoroutines = 4
 // against a hang, not a timing assumption: the first write after
 // the eviction is refused.
 func startRacingWrites(
-	w *delivery.ExportArchiveWriter,
+	w *archive.ExportArchiveWriter,
 ) *racingWrites {
 	r := &racingWrites{
 		started: make(chan struct{}, racingWriteGoroutines),
@@ -276,7 +272,7 @@ func (r *racingWrites) record(err error) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 
-	if errors.Is(err, delivery.ErrExportArchiveWriterEvicted) {
+	if errors.Is(err, archive.ErrExportArchiveWriterEvicted) {
 		r.sawEvicted = true
 
 		return
@@ -320,7 +316,7 @@ func TestEvictWebhook_RacingWriteDoesNotReopenHandle(
 	// eviction is about to detach.
 	deliverTo(t, env, tgt)
 
-	w := env.eng.ExportArchiveWriterFor(tgt.ID)
+	w := env.writers.ExportArchiveWriterFor(tgt.ID)
 	require.NotNil(t, w)
 	require.True(t, w.HandleOpen())
 
@@ -330,7 +326,7 @@ func TestEvictWebhook_RacingWriteDoesNotReopenHandle(
 	// eviction has to contend for the writer's mutex.
 	race.awaitFirstWrite()
 
-	env.eng.EvictWebhook(tgt.WebhookID)
+	env.writers.EvictWebhook(tgt.WebhookID)
 
 	sawEvicted, otherErr := race.wait()
 
@@ -345,7 +341,7 @@ func TestEvictWebhook_RacingWriteDoesNotReopenHandle(
 			"been evicted",
 	)
 	assert.False(
-		t, env.eng.ExportHasArchiveWriter(tgt.ID),
+		t, env.writers.ExportHasArchiveWriter(tgt.ID),
 		"the registry entry must stay gone",
 	)
 }
@@ -362,25 +358,25 @@ func TestEvictWebhook_LaterDeliveryRecreatesWriter(t *testing.T) {
 	tgt := env.seedDatabaseTarget(t, "")
 
 	deliverTo(t, env, tgt)
-	require.True(t, env.eng.ExportHasArchiveWriter(tgt.ID))
+	require.True(t, env.writers.ExportHasArchiveWriter(tgt.ID))
 
-	env.eng.EvictWebhook(tgt.WebhookID)
+	env.writers.EvictWebhook(tgt.WebhookID)
 
 	// A fresh delivery for the same target gets a brand new
 	// writer from the registry, so archiving keeps working.
 	deliverTo(t, env, tgt)
 
 	assert.True(
-		t, env.eng.ExportHasArchiveWriter(tgt.ID),
+		t, env.writers.ExportHasArchiveWriter(tgt.ID),
 		"a later delivery should recreate the writer",
 	)
 }
 
-// TestEngineStop_WriteAfterStopIsRefused proves the engine's stop
+// TestEvictAll_WriteAfterIsRefused proves that EvictAll, which the
-// closes each archive writer the way deleting its webhook does: a
+// delivery engine calls when it stops, closes each archive writer the
-// write that reaches a writer after the stop is refused, reopens
+// way deleting its webhook does: a write that reaches a writer after
-// nothing and adds no row.
+// it is refused, reopens nothing and adds no row.
-func TestEngineStop_WriteAfterStopIsRefused(t *testing.T) {
+func TestEvictAll_WriteAfterIsRefused(t *testing.T) {
 	t.Parallel()
 
 	env := setupArchiveTest(t)
@@ -388,16 +384,16 @@ func TestEngineStop_WriteAfterStopIsRefused(t *testing.T) {
 
 	deliverTo(t, env, tgt)
 
-	w := env.eng.ExportArchiveWriterFor(tgt.ID)
+	w := env.writers.ExportArchiveWriterFor(tgt.ID)
 	require.NotNil(t, w)
 	require.True(t, w.HandleOpen())
 
-	require.NoError(t, env.eng.ExportStop(context.Background()))
+	env.writers.EvictAll()
 
 	err := w.Write(evictTestRow("ev-after-stop"), 0)
 
 	require.ErrorIs(
-		t, err, delivery.ErrExportArchiveWriterEvicted,
+		t, err, archive.ErrExportArchiveWriterEvicted,
 		"a write after the stop must be refused",
 	)
 	assert.False(
@@ -405,7 +401,7 @@ func TestEngineStop_WriteAfterStopIsRefused(t *testing.T) {
 		"a refused write must not reopen the archive",
 	)
 	assert.False(
-		t, env.eng.ExportHasArchiveWriter(tgt.ID),
+		t, env.writers.ExportHasArchiveWriter(tgt.ID),
 		"the stop should empty the registry",
 	)
 

internal/archive/export_test.go

@@ -0,0 +1,280 @@
+package archive
+
+import (
+	"context"
+	"log/slog"
+	"time"
+
+	"go.uber.org/fx"
+	"gorm.io/gorm"
+	"sneak.berlin/go/webhooker/internal/database"
+)
+
+// ErrExportArchiveWriterEvicted exposes the sentinel returned by
+// an evicted archive writer. It carries the Err prefix rather
+// than this file's usual Export one because it is a sentinel
+// error.
+var ErrExportArchiveWriterEvicted = errArchiveWriterEvicted
+
+// ExportArchivedEvent aliases the archive row type so black-box
+// tests can construct and read archive rows.
+type ExportArchivedEvent = archivedEvent
+
+// ExportArchiveWriter wraps an archiveWriter so black-box tests
+// can exercise the archive file mechanics.
+type ExportArchiveWriter struct {
+	w *archiveWriter
+}
+
+// NewExportArchiveWriter builds an archive writer for tests,
+// optionally overriding the reopen debounce (a non-positive
+// debounce keeps the production default).
+func NewExportArchiveWriter(
+	path string, log *slog.Logger, debounce time.Duration,
+) *ExportArchiveWriter {
+	w := newArchiveWriter(path, log)
+	if debounce > 0 {
+		w.debounce = debounce
+	}
+
+	return &ExportArchiveWriter{w: w}
+}
+
+// Write archives a row through the writer, into the file named
+// without a period.
+func (e *ExportArchiveWriter) Write(
+	row ExportArchivedEvent, expiry time.Duration,
+) error {
+	return e.w.write(row, expiry, "")
+}
+
+// WritePeriod archives a row through the writer, into the file for
+// period.
+func (e *ExportArchiveWriter) WritePeriod(
+	row ExportArchivedEvent, expiry time.Duration, period string,
+) error {
+	return e.w.write(row, expiry, period)
+}
+
+// Open opens the archive file, pruning when expiry is positive.
+func (e *ExportArchiveWriter) Open(expiry time.Duration) error {
+	return e.w.open(e.w.path, expiry)
+}
+
+// Reopen closes and reopens the archive file.
+func (e *ExportArchiveWriter) Reopen(
+	expiry time.Duration,
+) error {
+	return e.w.reopen(e.w.path, expiry)
+}
+
+// SetNow replaces the clock the writer measures its reopen
+// debounce on.
+func (e *ExportArchiveWriter) SetNow(now func() time.Time) {
+	e.w.now = now
+}
+
+// Reopens reports how many times the file has been opened.
+func (e *ExportArchiveWriter) Reopens() int {
+	return e.w.reopens
+}
+
+// DB returns the writer's current open handle for row
+// inspection in tests.
+func (e *ExportArchiveWriter) DB() *gorm.DB {
+	return e.w.db
+}
+
+// Path returns the archive file the writer owns.
+func (e *ExportArchiveWriter) Path() string {
+	return e.w.path
+}
+
+// OpenExisting opens the archive without permitting creation,
+// the way the idle sweep does.
+func (e *ExportArchiveWriter) OpenExisting(
+	expiry time.Duration,
+) error {
+	return e.w.openMode(e.w.path, archiveModeExisting, expiry)
+}
+
+// SweepExpired runs an idle sweep of the archive.
+func (e *ExportArchiveWriter) SweepExpired(
+	expiry time.Duration,
+) error {
+	return e.w.sweepExpired(expiry)
+}
+
+// Evict marks the writer evicted and closes its handle, exactly
+// as leaving the registry does.
+func (e *ExportArchiveWriter) Evict() {
+	e.w.evict()
+}
+
+// Rename gives the archive file a new name in the same directory,
+// as a rename of the webhook or target does.
+func (e *ExportArchiveWriter) Rename(name string) error {
+	return e.w.rename(name)
+}
+
+// HandleOpen reports whether the writer currently holds an open
+// archive handle.
+func (e *ExportArchiveWriter) HandleOpen() bool {
+	e.w.mu.Lock()
+	defer e.w.mu.Unlock()
+
+	return e.w.db != nil
+}
+
+// Same reports whether both wrappers refer to the very same
+// underlying archive writer, so a test can prove a registry entry
+// is the writer it was handed rather than a replacement.
+func (e *ExportArchiveWriter) Same(
+	other *ExportArchiveWriter,
+) bool {
+	return other != nil && e.w == other.w
+}
+
+// ExportArchiveWriterFor returns the archive writer the registry
+// currently caches for a database target, or nil when none is
+// cached. It never creates one, so a test can hold a reference to
+// the very writer an eviction is about to detach.
+func (ws *Writers) ExportArchiveWriterFor(
+	targetID string,
+) *ExportArchiveWriter {
+	ws.mu.Lock()
+	defer ws.mu.Unlock()
+
+	w, ok := ws.writers[targetID]
+	if !ok {
+		return nil
+	}
+
+	return &ExportArchiveWriter{w: w}
+}
+
+// ExportHasArchiveWriter reports whether the registry currently
+// caches an archive writer for a target.
+func (ws *Writers) ExportHasArchiveWriter(
+	targetID string,
+) bool {
+	ws.mu.Lock()
+	defer ws.mu.Unlock()
+
+	_, ok := ws.writers[targetID]
+
+	return ok
+}
+
+// ExportArchiveHandleOpen reports whether the cached archive
+// writer for a target holds an open database handle. It
+// returns false when no writer is cached.
+func (ws *Writers) ExportArchiveHandleOpen(
+	targetID string,
+) bool {
+	ws.mu.Lock()
+	w, ok := ws.writers[targetID]
+	ws.mu.Unlock()
+
+	if !ok {
+		return false
+	}
+
+	w.mu.Lock()
+	defer w.mu.Unlock()
+
+	return w.db != nil
+}
+
+// ExportEnsureArchiveWriter creates (if needed) and returns the
+// archive file path of the cached writer for a target, so a
+// test can prime the registry the way a delivery would.
+func (ws *Writers) ExportEnsureArchiveWriter(
+	targetID string,
+) (string, error) {
+	w, err := ws.writerFor(targetID)
+	if err != nil {
+		return "", err
+	}
+
+	return w.path, nil
+}
+
+// ExportSweepWriterFor takes a target's registry writer exactly
+// as the idle sweep does, reporting whether the sweep had to
+// create the entry. It lets a test drive the registry through the
+// sweep's own entry point instead of choreographing goroutines.
+func (ws *Writers) ExportSweepWriterFor(
+	targetID string,
+) (*ExportArchiveWriter, bool, error) {
+	w, created, err := ws.sweepWriterFor(targetID)
+	if err != nil {
+		return nil, false, err
+	}
+
+	return &ExportArchiveWriter{w: w}, created, nil
+}
+
+// ExportReleaseSweepWriter releases a sweep-created registry entry
+// exactly as a finished sweep does.
+func (ws *Writers) ExportReleaseSweepWriter(
+	targetID string, w *ExportArchiveWriter,
+) {
+	ws.releaseSweepWriter(targetID, w.w)
+}
+
+// NewTestSweeper builds a Sweeper backed by the given main
+// database and archive writers, without the fx lifecycle.
+// Intended for tests.
+func NewTestSweeper(
+	db *database.Database,
+	writers *Writers,
+	log *slog.Logger,
+) *Sweeper {
+	return &Sweeper{
+		db:       db,
+		writers:  writers,
+		log:      log,
+		interval: time.Hour,
+	}
+}
+
+// ExportSweep runs a single archive sweep synchronously for
+// tests.
+func (s *Sweeper) ExportSweep(ctx context.Context) {
+	s.sweep(ctx)
+}
+
+// ExportStart starts the sweeper's background loop for tests.
+func (s *Sweeper) ExportStart() {
+	s.start()
+}
+
+// ExportRegisterHooks registers the sweeper's real fx lifecycle
+// hooks on a lifecycle supplied by a test, so a test can drive
+// the exact OnStart/OnStop functions the application runs and
+// hand OnStart the kind of context fx actually supplies.
+func (s *Sweeper) ExportRegisterHooks(lc fx.Lifecycle) {
+	s.registerHooks(lc)
+}
+
+// ExportStop stops the sweeper's background loop for tests.
+func (s *Sweeper) ExportStop(ctx context.Context) error {
+	return s.stop(ctx)
+}
+
+// ExportWedgeLoop adds a goroutine to the sweeper's WaitGroup
+// that never observes cancellation and returns only when release
+// is closed. It stands in for a prune stuck on a locked archive.
+func (s *Sweeper) ExportWedgeLoop(
+	release <-chan struct{},
+) {
+	s.wg.Go(func() {
+		<-release
+	})
+}
+
+// ExportSetInterval overrides the sweep interval for tests.
+func (s *Sweeper) ExportSetInterval(d time.Duration) {
+	s.interval = d
+}

internal/archive/rotation.go

@@ -1,4 +1,4 @@
-package delivery
+package archive
 
 import (
 	"encoding/json"
@@ -41,10 +41,10 @@ type archiveFile struct {
 	period string
 }
 
-// ValidateArchiveRotation checks a user-supplied archive rotation for
+// ValidateRotation checks a user-supplied archive rotation for
 // a database target: empty or none (both meaning one file), monthly,
 // daily or hourly.
-func ValidateArchiveRotation(rotation string) error {
+func ValidateRotation(rotation string) error {
 	switch rotation {
 	case "", archiveRotationNone, archiveRotationMonthly,
 		archiveRotationDaily, archiveRotationHourly:
@@ -54,21 +54,21 @@ func ValidateArchiveRotation(rotation string) error {
 	}
 }
 
-// parseArchiveRotation reads the rotation from a database target's
+// ParseRotation reads the rotation from a database target's
 // config JSON. An empty config or an empty rotation is none.
-func parseArchiveRotation(configJSON string) (string, error) {
+func ParseRotation(configJSON string) (string, error) {
 	if configJSON == "" {
 		return archiveRotationNone, nil
 	}
 
-	var cfg databaseTargetConfig
+	var cfg DatabaseTargetConfig
 
 	err := json.Unmarshal([]byte(configJSON), &cfg)
 	if err != nil {
 		return "", fmt.Errorf("parsing database target config: %w", err)
 	}
 
-	err = ValidateArchiveRotation(cfg.Rotation)
+	err = ValidateRotation(cfg.Rotation)
 	if err != nil {
 		return "", err
 	}
@@ -97,7 +97,7 @@ func archivePeriod(rotation string, receivedAt time.Time) string {
 }
 
 // archivePeriodPath returns the path of a database target's archive
-// file for a period: path, as ArchivePath gives it, with "-" and the
+// file for a period: path, as Path gives it, with "-" and the
 // period put before its ".db". The period "" gives path itself.
 func archivePeriodPath(path, period string) string {
 	if period == "" {
@@ -107,28 +107,28 @@ func archivePeriodPath(path, period string) string {
 	return strings.TrimSuffix(path, ".db") + "-" + period + ".db"
 }
 
-// ArchivePathAt returns the archive file a database target writes an
+// PathAt returns the archive file a database target writes an
-// event received at receivedAt to: ArchivePath's file, with the
+// event received at receivedAt to: Path's file, with the
 // period in its name when the target rotates.
-func ArchivePathAt(
+func PathAt(
 	dbMgr *database.WebhookDBManager,
 	webhook *database.Webhook,
 	target *database.Target,
 	receivedAt time.Time,
 ) (string, error) {
-	rotation, err := parseArchiveRotation(target.Config)
+	rotation, err := ParseRotation(target.Config)
 	if err != nil {
 		return "", err
 	}
 
 	return archivePeriodPath(
-		ArchivePath(dbMgr, webhook, target),
+		Path(dbMgr, webhook, target),
 		archivePeriod(rotation, receivedAt),
 	), nil
 }
 
 // archiveFiles lists the database target's archive files that exist,
-// given the path ArchivePath gives it: the file at path, then each
+// given the path Path gives it: the file at path, then each
 // file archivePeriodPath names for path and a period, oldest period
 // first. Which rotation wrote a file does not matter, so the files of
 // an earlier rotation setting are listed too.

internal/archive/rotation_test.go

@@ -1,4 +1,4 @@
-package delivery_test
+package archive_test
 
 import (
 	"os"
@@ -9,9 +9,9 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/webhooker/internal/archive"
 	"sneak.berlin/go/webhooker/internal/database"
 	"sneak.berlin/go/webhooker/internal/database/databasetest"
-	"sneak.berlin/go/webhooker/internal/delivery"
 )
 
 // The archive rotations, and the configs of a daily target and of one
@@ -40,32 +40,30 @@ func periodPath(path, period string) string {
 	return strings.TrimSuffix(path, ".db") + "-" + period + ".db"
 }
 
-// deliverReceivedAt delivers to a database target an event whose
+// deliverReceivedAt archives, as a delivery to a database target
-// receive time is receivedAt, and returns the event's id. The receive
+// does, an event whose receive time is receivedAt, and returns the
-// time is what decides a rotated archive's file, so setting it is how
+// event's id. The receive time is what decides a rotated archive's
-// these tests move the clock across a period boundary.
+// file, so setting it is how these tests move the clock across a
+// period boundary.
 func (env *archiveEnv) deliverReceivedAt(
 	t *testing.T, tgt *database.Target, receivedAt time.Time,
 ) string {
 	t.Helper()
 
-	webhookDB := testWebhookDB(t)
+	event := newEvent(`{"n":1}`)
-	event := seedEvent(t, webhookDB, `{"n":1}`)
 	event.CreatedAt = receivedAt
 
-	env.eng.ExportDeliverDatabase(
+	require.NoError(t, env.writers.Write(databaseTargetDelivery(event, tgt)))
-		webhookDB, seedDatabaseTargetDelivery(t, webhookDB, event, tgt),
-	)
 
 	return event.ID
 }
 
-// TestDeliverDatabase_RotatesAtEachPeriodBoundary delivers, for each
+// TestWrite_RotatesAtEachPeriodBoundary writes, for each
 // rotation, an event received in the last second of a period and one
 // received in the first second of the next, and checks each lands in
 // the file named for its own period, in UTC. Rotation none keeps both
 // in the one file.
-func TestDeliverDatabase_RotatesAtEachPeriodBoundary(t *testing.T) {
+func TestWrite_RotatesAtEachPeriodBoundary(t *testing.T) {
 	t.Parallel()
 
 	berlin := time.FixedZone("CEST", 2*60*60)
@@ -139,10 +137,10 @@ func TestDeliverDatabase_RotatesAtEachPeriodBoundary(t *testing.T) {
 	})
 }
 
-// TestDeliverDatabase_EventWithoutReceiveTime proves an event whose
+// TestWrite_EventWithoutReceiveTime proves an event whose
 // receive time is not known goes to the file for the time it is
 // archived, rather than to one for the year 1.
-func TestDeliverDatabase_EventWithoutReceiveTime(t *testing.T) {
+func TestWrite_EventWithoutReceiveTime(t *testing.T) {
 	t.Parallel()
 
 	env := setupArchiveTest(t)
@@ -164,10 +162,10 @@ func TestDeliverDatabase_EventWithoutReceiveTime(t *testing.T) {
 	assert.NoFileExists(t, periodPath(path, "0001-01"))
 }
 
-// TestDeliverDatabase_RotationChangeKeepsOldFiles changes a target's
+// TestWrite_RotationChangeKeepsOldFiles changes a target's
 // rotation from none to daily between two events, and checks the
 // second goes to the daily file while the first stays where it was.
-func TestDeliverDatabase_RotationChangeKeepsOldFiles(t *testing.T) {
+func TestWrite_RotationChangeKeepsOldFiles(t *testing.T) {
 	t.Parallel()
 
 	env := setupArchiveTest(t)
@@ -237,7 +235,7 @@ func TestRename_MovesEveryFile(t *testing.T) {
 	first := env.deliverReceivedAt(t, tgt, day)
 	second := env.deliverReceivedAt(t, tgt, day.Add(24*time.Hour))
 
-	require.NoError(t, env.eng.Rename(tgt.ID, "Orders", "Long Term"))
+	require.NoError(t, env.writers.Rename(tgt.ID, "Orders", "Long Term"))
 
 	newPath := filepath.Join(
 		env.dataDir, "archive-orders-long-term-"+tgt.ID+".db",
@@ -283,8 +281,8 @@ func TestRename_NeverReplacesARotatedFile(t *testing.T) {
 	require.NoError(t, os.WriteFile(planted, []byte("planted"), 0o600))
 
 	require.ErrorIs(
-		t, env.eng.Rename(tgt.ID, "Orders", "Long Term"),
+		t, env.writers.Rename(tgt.ID, "Orders", "Long Term"),
-		delivery.ErrArchiveNameTaken,
+		archive.ErrNameTaken,
 	)
 
 	assert.FileExists(t, periodPath(oldPath, dayPeriod))
@@ -292,7 +290,7 @@ func TestRename_NeverReplacesARotatedFile(t *testing.T) {
 	assert.NoFileExists(t, periodPath(newPath, dayPeriod))
 }
 
-// TestStatArchive_EveryFile proves StatArchive counts and adds up every
+// TestStatArchive_EveryFile proves Stat counts and adds up every
 // one of a target's files, takes the latest write of any of them, and
 // leaves out files whose names only look like the target's.
 func TestStatArchive_EveryFile(t *testing.T) {
@@ -324,7 +322,7 @@ func TestStatArchive_EveryFile(t *testing.T) {
 			os.WriteFile(filepath.Join(dir, other), []byte("x"), 0o600))
 	}
 
-	got, err := delivery.StatArchive(path)
+	got, err := archive.Stat(path)
 	require.NoError(t, err)
 	assert.Equal(t, len(files), got.Files)
 	assert.Equal(t, size, got.Size)
@@ -357,7 +355,7 @@ func TestArchivePathAt(t *testing.T) {
 			Config:    config,
 		}
 
-		got, err := delivery.ArchivePathAt(dbMgr, webhook, target, at)
+		got, err := archive.PathAt(dbMgr, webhook, target, at)
 		require.NoError(t, err, config)
 		assert.Equal(t,
 			filepath.Join(
@@ -367,7 +365,7 @@ func TestArchivePathAt(t *testing.T) {
 		)
 	}
 
-	_, err := delivery.ArchivePathAt(dbMgr, webhook, &database.Target{
+	_, err := archive.PathAt(dbMgr, webhook, &database.Target{
 		Config: weeklyConfig,
 	}, at)
 	require.Error(t, err)
@@ -381,10 +379,10 @@ func TestValidateArchiveRotation(t *testing.T) {
 	for _, ok := range []string{
 		"", rotationNone, rotationMonthly, rotationDaily, rotationHourly,
 	} {
-		require.NoError(t, delivery.ValidateArchiveRotation(ok), ok)
+		require.NoError(t, archive.ValidateRotation(ok), ok)
 	}
 
 	for _, bad := range []string{"weekly", "Daily", "hourly "} {
-		require.Error(t, delivery.ValidateArchiveRotation(bad), bad)
+		require.Error(t, archive.ValidateRotation(bad), bad)
 	}
 }

internal/archive/sweeper.go

@@ -1,4 +1,4 @@
-package delivery
+package archive
 
 import (
 	"context"
@@ -15,18 +15,18 @@ import (
 	"sneak.berlin/go/webhooker/internal/logger"
 )
 
-// ArchiveSweeperParams holds the fx dependencies for the
+// SweeperParams holds the fx dependencies for the
-// ArchiveSweeper.
+// Sweeper.
-type ArchiveSweeperParams struct {
+type SweeperParams struct {
 	fx.In
 
 	Config   *config.Config
 	Database *database.Database
-	Engine   *Engine
+	Writers  *Writers
 	Logger   *logger.Logger
 }
 
-// ArchiveSweeper periodically prunes expired rows from the
+// Sweeper periodically prunes expired rows from the
 // archive databases of database targets that carry a positive
 // expiry.
 //
@@ -40,9 +40,9 @@ type ArchiveSweeperParams struct {
 // It reuses Config.RetentionSweepInterval rather than
 // introducing a second interval: this is a retention sweep with
 // the same semantics as the event retention reaper.
-type ArchiveSweeper struct {
+type Sweeper struct {
 	db       *database.Database
-	eng      *Engine
+	writers  *Writers
 	log      *slog.Logger
 	interval time.Duration
 
@@ -54,16 +54,16 @@ type ArchiveSweeper struct {
 	wg sync.WaitGroup
 }
 
-// NewArchiveSweeper creates the archive sweeper and registers
+// NewSweeper creates the archive sweeper and registers
 // its fx lifecycle hooks. The background sweep loop starts on
 // OnStart and stops cleanly on OnStop via context cancellation.
-func NewArchiveSweeper(
+func NewSweeper(
 	lc fx.Lifecycle,
-	params ArchiveSweeperParams,
+	params SweeperParams,
-) *ArchiveSweeper {
+) *Sweeper {
-	s := &ArchiveSweeper{
+	s := &Sweeper{
 		db:       params.Database,
-		eng:      params.Engine,
+		writers:  params.Writers,
 		log:      params.Logger.Get(),
 		interval: params.Config.RetentionSweepInterval,
 	}
@@ -77,7 +77,7 @@ func NewArchiveSweeper(
 // lifecycle. The start hook's context is deliberately ignored
 // (see start for why the background loop must not inherit it);
 // the stop hook's context is honoured (see stop).
-func (s *ArchiveSweeper) registerHooks(lc fx.Lifecycle) {
+func (s *Sweeper) registerHooks(lc fx.Lifecycle) {
 	lc.Append(fx.Hook{
 		//nolint:contextcheck // Not passing the hook context is
 		// the point: see start.
@@ -103,7 +103,7 @@ func (s *ArchiveSweeper) registerHooks(lc fx.Lifecycle) {
 // goroutine must outlive the startup phase, so its lifetime is
 // bounded by OnStop instead: stop cancels this context and waits
 // on the WaitGroup.
-func (s *ArchiveSweeper) start() {
+func (s *Sweeper) start() {
 	ctx, cancel := context.WithCancel(context.Background())
 	s.cancel = cancel
 
@@ -121,7 +121,7 @@ func (s *ArchiveSweeper) start() {
 // exit, bounded by the stop hook's context: a prune wedged on a
 // locked archive must not hang the process past fx's stop
 // timeout.
-func (s *ArchiveSweeper) stop(ctx context.Context) error {
+func (s *Sweeper) stop(ctx context.Context) error {
 	s.log.Info("archive sweeper stopping")
 
 	if s.cancel != nil {
@@ -140,7 +140,7 @@ func (s *ArchiveSweeper) stop(ctx context.Context) error {
 	return nil
 }
 
-func (s *ArchiveSweeper) run(ctx context.Context) {
+func (s *Sweeper) run(ctx context.Context) {
 	defer s.wg.Done()
 
 	ticker := time.NewTicker(s.interval)
@@ -164,7 +164,7 @@ func (s *ArchiveSweeper) run(ctx context.Context) {
 // A failure for one target is logged and the sweep continues,
 // matching how the write path already treats a prune error as
 // non-fatal.
-func (s *ArchiveSweeper) sweep(ctx context.Context) {
+func (s *Sweeper) sweep(ctx context.Context) {
 	var targets []database.Target
 
 	err := s.db.DB().
@@ -202,8 +202,8 @@ func (s *ArchiveSweeper) sweep(ctx context.Context) {
 // sweepTarget prunes the archive of a single database target.
 // A missing, empty, or "never" expiry parses as a zero duration
 // and is skipped entirely, so those archives are never pruned.
-func (s *ArchiveSweeper) sweepTarget(target *database.Target) {
+func (s *Sweeper) sweepTarget(target *database.Target) {
-	expiry, err := parseArchiveExpiry(target.Config)
+	expiry, err := ParseExpiry(target.Config)
 	if err != nil {
 		s.log.Error(
 			"archive sweep: invalid database target config",
@@ -219,11 +219,11 @@ func (s *ArchiveSweeper) sweepTarget(target *database.Target) {
 		return
 	}
 
-	if s.eng == nil || s.eng.dbTarget == nil {
+	if s.writers == nil {
 		return
 	}
 
-	err = s.eng.dbTarget.sweepArchive(target.ID, expiry)
+	err = s.writers.sweepArchive(target.ID, expiry)
 	if err == nil {
 		return
 	}

internal/archive/sweeper_test.go

@@ -1,4 +1,4 @@
-package delivery_test
+package archive_test
 
 import (
 	"bytes"
@@ -16,14 +16,15 @@ import (
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"go.uber.org/fx"
 	"gorm.io/driver/sqlite"
 	"gorm.io/gorm"
 	"gorm.io/gorm/clause"
 	_ "modernc.org/sqlite" // Pure Go SQLite driver.
+	"sneak.berlin/go/webhooker/internal/archive"
 	"sneak.berlin/go/webhooker/internal/database"
 	"sneak.berlin/go/webhooker/internal/database/databasetest"
 	"sneak.berlin/go/webhooker/internal/db/migrations"
-	"sneak.berlin/go/webhooker/internal/delivery"
 	"sneak.berlin/go/webhooker/internal/gormlog"
 )
 
@@ -37,6 +38,18 @@ const (
 	// sweepConcurrentWrites is how many deliveries the
 	// concurrent write-plus-sweep test races against the sweep.
 	sweepConcurrentWrites = 20
+
+	// hookStopTimeout bounds how long a lifecycle test waits for
+	// the sweeper's OnStop hook to return before declaring the
+	// shutdown hung.
+	hookStopTimeout = 10 * time.Second
+
+	// wedgeStopTimeout is the stop timeout a wedged-shutdown test
+	// hands OnStop, standing in for fx's StopTimeout. The test
+	// asserts only that the hook returns at all, and allows it
+	// hookStopTimeout — forty times this budget — to do so, so no
+	// assertion here races the wall clock.
+	wedgeStopTimeout = 250 * time.Millisecond
 )
 
 // archiveTestWebhookName is the name of every webhook
@@ -45,12 +58,12 @@ const (
 const archiveTestWebhookName = "Sweep Test!"
 
 // archiveEnv bundles the pieces an archive test drives: a main
-// configuration database holding webhooks and targets, a delivery
+// configuration database holding webhooks and targets, the archive
-// engine owning the archive writer registry, the archive sweeper,
+// writers, the archive sweeper, and the data directory the archive
-// and the data directory the archive files live in.
+// files live in.
 type archiveEnv struct {
-	sweeper *delivery.ArchiveSweeper
+	sweeper *archive.Sweeper
-	eng     *delivery.Engine
+	writers *archive.Writers
 	mainDB  *database.Database
 	dataDir string
 }
@@ -66,30 +79,28 @@ func setupArchiveTest(t *testing.T) *archiveEnv {
 
 	t.Cleanup(func() { _ = mainDB.Close() })
 
-	eng := delivery.NewTestEngineWithDB(
+	writers := archive.NewWriters(archive.WritersParams{
-		mainDB,
+		Database:  mainDB,
-		databasetest.NewWebhookDBManager(t, dataDir),
+		DBManager: databasetest.NewWebhookDBManager(t, dataDir),
-		log,
+		Logger:    log,
-		&http.Client{Timeout: 5 * time.Second},
+	})
-		1,
-	)
 
 	return &archiveEnv{
-		sweeper: delivery.NewTestArchiveSweeper(
+		sweeper: archive.NewTestSweeper(
-			mainDB, eng, log,
+			mainDB, writers, log,
 		),
-		eng:     eng,
+		writers: writers,
 		mainDB:  mainDB,
 		dataDir: dataDir,
 	}
 }
 
-// archivePath returns where the engine keeps a database target's
+// archivePath returns where the writers keep a database target's
 // archive file, for the names seedDatabaseTarget gave it.
 func (env *archiveEnv) archivePath(tgt *database.Target) string {
 	return filepath.Join(
 		env.dataDir,
-		delivery.ArchiveFileName(
+		archive.FileName(
 			archiveTestWebhookName, tgt.Name, tgt.ID,
 		),
 	)
@@ -124,11 +135,12 @@ func (env *archiveEnv) addDatabaseTarget(
 	t.Helper()
 
 	tgt := &database.Target{
-		WebhookID: webhookID,
+		WebhookID:   webhookID,
-		Name:      "Archive",
+		Name:        "Archive",
-		Type:      database.TargetTypeDatabase,
+		Type:        database.TargetTypeDatabase,
-		Active:    true,
+		Active:      true,
-		Config:    configJSON,
+		Config:      configJSON,
+		MaxAttempts: 1,
 	}
 	require.NoError(
 		t,
@@ -176,7 +188,7 @@ func seedArchiveFile(
 	require.NoError(t, migrations.Apply(gdb, migrations.Archive))
 
 	for i, at := range archivedAt {
-		row := delivery.ExportArchivedEvent{
+		row := archive.ExportArchivedEvent{
 			EventID:    fmt.Sprintf("ev-%d", i),
 			WebhookID:  webhookID,
 			Method:     http.MethodPost,
@@ -196,7 +208,7 @@ func archivedEventIDs(
 ) []string {
 	t.Helper()
 
-	var rows []delivery.ExportArchivedEvent
+	var rows []archive.ExportArchivedEvent
 
 	rdb := openArchiveDBForRead(t, path)
 	require.NoError(t, rdb.Order("event_id").Find(&rows).Error)
@@ -233,7 +245,7 @@ func countArchivedRows(path string) (int64, error) {
 
 	var count int64
 
-	err = gdb.Model(&delivery.ExportArchivedEvent{}).
+	err = gdb.Model(&archive.ExportArchivedEvent{}).
 		Count(&count).Error
 	if err != nil {
 		return 0, err
@@ -242,6 +254,55 @@ func countArchivedRows(path string) (int64, error) {
 	return count, nil
 }
 
+// recordingLifecycle is a minimal fx.Lifecycle that records the
+// hooks a component registers, so a test can invoke the real
+// OnStart/OnStop functions with a context of its choosing.
+type recordingLifecycle struct {
+	hooks []fx.Hook
+}
+
+func (l *recordingLifecycle) Append(h fx.Hook) {
+	l.hooks = append(l.hooks, h)
+}
+
+// requireStopHookExpires drives hook.OnStop with a stop context
+// that expires while a wedged goroutine is still running, and
+// requires the hook to return the deadline error naming
+// component instead of blocking on the WaitGroup forever.
+func requireStopHookExpires(
+	t *testing.T, hook fx.Hook, component string,
+) {
+	t.Helper()
+
+	stopCtx, cancel := context.WithTimeout(
+		context.Background(), wedgeStopTimeout,
+	)
+	defer cancel()
+
+	var stopErr error
+
+	stopped := make(chan struct{})
+
+	go func() {
+		defer close(stopped)
+
+		stopErr = hook.OnStop(stopCtx)
+	}()
+
+	select {
+	case <-stopped:
+	case <-time.After(hookStopTimeout):
+		t.Fatal(
+			"OnStop did not return: it discarded the stop " +
+				"context and is waiting on a wedged goroutine " +
+				"that will never observe cancellation",
+		)
+	}
+
+	require.ErrorIs(t, stopErr, context.DeadlineExceeded)
+	require.ErrorContains(t, stopErr, component)
+}
+
 // TestArchiveSweeper_LoopOutlivesStartHookContext is the
 // regression test for a sweeper that never swept. fx calls
 // OnStart with a context carrying the application's start
@@ -325,16 +386,16 @@ func TestArchiveSweep_DoesNotResurrectEvictedWriter(
 	// the deletion path does. The target row is deliberately left
 	// in place: this is the tick that listed the target before
 	// the deletion committed.
-	_, err := env.eng.ExportEnsureArchiveWriter(tgt.ID)
+	_, err := env.writers.ExportEnsureArchiveWriter(tgt.ID)
 	require.NoError(t, err)
 
-	env.eng.EvictTarget(tgt.ID)
+	env.writers.EvictTarget(tgt.ID)
-	require.False(t, env.eng.ExportHasArchiveWriter(tgt.ID))
+	require.False(t, env.writers.ExportHasArchiveWriter(tgt.ID))
 
 	env.sweeper.ExportSweep(context.Background())
 
 	assert.False(
-		t, env.eng.ExportHasArchiveWriter(tgt.ID),
+		t, env.writers.ExportHasArchiveWriter(tgt.ID),
 		"a sweep must never re-register a writer for a target "+
 			"whose registry entry has already been released",
 	)
@@ -357,7 +418,7 @@ func TestArchiveSweep_LeavesNoRegistryEntry(t *testing.T) {
 		time.Now().Add(-time.Minute),
 	)
 
-	require.False(t, env.eng.ExportHasArchiveWriter(tgt.ID))
+	require.False(t, env.writers.ExportHasArchiveWriter(tgt.ID))
 
 	env.sweeper.ExportSweep(context.Background())
 
@@ -366,7 +427,7 @@ func TestArchiveSweep_LeavesNoRegistryEntry(t *testing.T) {
 		"the sweep must still prune an idle archive",
 	)
 	assert.False(
-		t, env.eng.ExportHasArchiveWriter(tgt.ID),
+		t, env.writers.ExportHasArchiveWriter(tgt.ID),
 		"the sweep must release the registry entry it created",
 	)
 }
@@ -388,24 +449,22 @@ func TestArchiveSweep_KeepsWriterAdoptedByDelivery(
 		t, tgt, time.Now().Add(-48*time.Hour),
 	)
 
-	webhookDB := testWebhookDB(t)
+	d := databaseTargetDelivery(newEvent(`{"n":1}`), tgt)
-	event := seedEvent(t, webhookDB, `{"n":1}`)
-	d := seedDatabaseTargetDelivery(t, webhookDB, event, tgt)
 
 	env.sweeper.ExportSweep(context.Background())
-	require.False(t, env.eng.ExportHasArchiveWriter(tgt.ID))
+	require.False(t, env.writers.ExportHasArchiveWriter(tgt.ID))
 
-	env.eng.ExportDeliverDatabase(webhookDB, d)
+	require.NoError(t, env.writers.Write(d))
 
 	assert.True(
-		t, env.eng.ExportHasArchiveWriter(tgt.ID),
+		t, env.writers.ExportHasArchiveWriter(tgt.ID),
 		"a delivery's writer must stay registered",
 	)
 
 	env.sweeper.ExportSweep(context.Background())
 
 	assert.True(
-		t, env.eng.ExportHasArchiveWriter(tgt.ID),
+		t, env.writers.ExportHasArchiveWriter(tgt.ID),
 		"a sweep must not drop a writer a delivery owns",
 	)
 }
@@ -444,7 +503,7 @@ func TestArchiveSweep_KeepsWriterAdoptedDuringSweep(
 		t, tgt, time.Now().Add(-48*time.Hour),
 	)
 
-	sweepWriter, created, err := env.eng.ExportSweepWriterFor(
+	sweepWriter, created, err := env.writers.ExportSweepWriterFor(
 		tgt.ID,
 	)
 	require.NoError(t, err)
@@ -454,36 +513,34 @@ func TestArchiveSweep_KeepsWriterAdoptedDuringSweep(
 	)
 
 	// The delivery lands mid-sweep and adopts the entry.
-	webhookDB := testWebhookDB(t)
+	d := databaseTargetDelivery(newEvent(`{"n":1}`), tgt)
-	event := seedEvent(t, webhookDB, `{"n":1}`)
-	d := seedDatabaseTargetDelivery(t, webhookDB, event, tgt)
 
-	env.eng.ExportDeliverDatabase(webhookDB, d)
+	require.NoError(t, env.writers.Write(d))
 
-	adopted := env.eng.ExportArchiveWriterFor(tgt.ID)
+	adopted := env.writers.ExportArchiveWriterFor(tgt.ID)
 	require.NotNil(t, adopted)
 	require.True(
 		t, sweepWriter.Same(adopted),
 		"the delivery must have adopted the sweep's writer",
 	)
 	require.True(
-		t, env.eng.ExportArchiveHandleOpen(tgt.ID),
+		t, env.writers.ExportArchiveHandleOpen(tgt.ID),
 		"the delivery leaves the archive handle open",
 	)
 
 	// The sweep finishes.
-	env.eng.ExportReleaseSweepWriter(tgt.ID, sweepWriter)
+	env.writers.ExportReleaseSweepWriter(tgt.ID, sweepWriter)
 
 	require.True(
-		t, env.eng.ExportHasArchiveWriter(tgt.ID),
+		t, env.writers.ExportHasArchiveWriter(tgt.ID),
 		"a writer adopted by a delivery during a sweep must "+
 			"stay registered, or its open handle is unreachable",
 	)
 
-	env.eng.EvictTarget(tgt.ID)
+	env.writers.EvictTarget(tgt.ID)
 
 	assert.False(
-		t, env.eng.ExportHasArchiveWriter(tgt.ID),
+		t, env.writers.ExportHasArchiveWriter(tgt.ID),
 		"the adopted writer must still be evictable",
 	)
 	assert.False(
@@ -547,7 +604,7 @@ func TestArchiveSweep_OpenExistingDoesNotCreateFile(
 	dir := t.TempDir()
 	path := filepath.Join(dir, "archive-absent.db")
 
-	w := delivery.NewExportArchiveWriter(
+	w := archive.NewExportArchiveWriter(
 		path, archiveTestLogger(), 0,
 	)
 
@@ -618,7 +675,7 @@ func TestArchiveSweep_LeavesArchiveClosed(t *testing.T) {
 		t, tgt, time.Now().Add(-48*time.Hour),
 	)
 
-	w := delivery.NewExportArchiveWriter(
+	w := archive.NewExportArchiveWriter(
 		path, archiveTestLogger(), 0,
 	)
 
@@ -658,25 +715,23 @@ func TestArchiveSweep_ClosesHandleOfRegisteredWriter(
 		t, tgt, time.Now().Add(-48*time.Hour),
 	)
 
-	webhookDB := testWebhookDB(t)
+	d := databaseTargetDelivery(newEvent(`{"n":1}`), tgt)
-	event := seedEvent(t, webhookDB, `{"n":1}`)
-	d := seedDatabaseTargetDelivery(t, webhookDB, event, tgt)
 
-	env.eng.ExportDeliverDatabase(webhookDB, d)
+	require.NoError(t, env.writers.Write(d))
 
 	require.True(
-		t, env.eng.ExportArchiveHandleOpen(tgt.ID),
+		t, env.writers.ExportArchiveHandleOpen(tgt.ID),
 		"the delivery must leave the archive handle open",
 	)
 
 	env.sweeper.ExportSweep(context.Background())
 
 	require.True(
-		t, env.eng.ExportHasArchiveWriter(tgt.ID),
+		t, env.writers.ExportHasArchiveWriter(tgt.ID),
 		"the delivery's registry entry must survive the sweep",
 	)
 	assert.False(
-		t, env.eng.ExportArchiveHandleOpen(tgt.ID),
+		t, env.writers.ExportArchiveHandleOpen(tgt.ID),
 		"the sweep must leave the archive closed",
 	)
 }
@@ -692,7 +747,7 @@ func TestArchiveSweep_ClosesHandleBeforeReopening(t *testing.T) {
 
 	path := filepath.Join(t.TempDir(), "archive.db")
 
-	w := delivery.NewExportArchiveWriter(
+	w := archive.NewExportArchiveWriter(
 		path, archiveTestLogger(), 0,
 	)
 
@@ -720,8 +775,8 @@ func TestArchiveSweep_CancelledSweepLogsNoError(t *testing.T) {
 
 	var errorLines bytes.Buffer
 
-	sweeper := delivery.NewTestArchiveSweeper(
+	sweeper := archive.NewTestSweeper(
-		env.mainDB, env.eng,
+		env.mainDB, env.writers,
 		slog.New(slog.NewTextHandler(
 			&errorLines,
 			&slog.HandlerOptions{Level: slog.LevelError},
@@ -765,7 +820,7 @@ func TestArchiveSweep_NeverExpiryUntouched(t *testing.T) {
 			"config %q must keep rows forever", configJSON,
 		)
 		assert.False(
-			t, env.eng.ExportHasArchiveWriter(tgt.ID),
+			t, env.writers.ExportHasArchiveWriter(tgt.ID),
 			"config %q must leave no registry entry behind",
 			configJSON,
 		)
@@ -830,7 +885,7 @@ func archiveTableExists(t *testing.T, path string) bool {
 
 	return openArchiveDBForRead(t, path).
 		Migrator().
-		HasTable(&delivery.ExportArchivedEvent{})
+		HasTable(&archive.ExportArchivedEvent{})
 }
 
 // TestArchiveSweep_DoesNotCreateArchiveFile proves the sweep
@@ -857,7 +912,7 @@ func TestArchiveSweep_DoesNotCreateArchiveFile(t *testing.T) {
 	}
 
 	assert.False(
-		t, env.eng.ExportHasArchiveWriter(tgt.ID),
+		t, env.writers.ExportHasArchiveWriter(tgt.ID),
 		"the sweep must leave no registry entry behind",
 	)
 }
@@ -875,7 +930,7 @@ func TestArchiveSweep_DoesNotCreateAfterWriterExists(
 
 	tgt := env.seedDatabaseTarget(t, `{"expiry":"1h"}`)
 
-	path, err := env.eng.ExportEnsureArchiveWriter(tgt.ID)
+	path, err := env.writers.ExportEnsureArchiveWriter(tgt.ID)
 	require.NoError(t, err)
 	require.NoFileExists(t, path)
 
@@ -922,21 +977,14 @@ func TestArchiveSweep_ConcurrentWrites(t *testing.T) {
 
 	tgt := env.seedDatabaseTarget(t, `{"expiry":"1h"}`)
 
-	webhookDB := testWebhookDB(t)
-
-	// The deliveries are seeded up front, on the test's own
-	// goroutine: the seed helpers assert, and testify assertions
-	// must not run off the test goroutine.
 	deliveries := make(
 		[]*database.Delivery, 0, sweepConcurrentWrites,
 	)
 
 	for range sweepConcurrentWrites {
-		event := seedEvent(t, webhookDB, `{"n":1}`)
-
 		deliveries = append(
 			deliveries,
-			seedDatabaseTargetDelivery(t, webhookDB, event, tgt),
+			databaseTargetDelivery(newEvent(`{"n":1}`), tgt),
 		)
 	}
 
@@ -948,7 +996,7 @@ func TestArchiveSweep_ConcurrentWrites(t *testing.T) {
 		defer wg.Done()
 
 		for _, d := range deliveries {
-			env.eng.ExportDeliverDatabase(webhookDB, d)
+			_ = env.writers.Write(d)
 		}
 	}()
 

internal/archive/writer.go

@@ -1,4 +1,4 @@
-package delivery
+package archive
 
 import (
 	"encoding/json"
@@ -18,9 +18,9 @@ import (
 	"sneak.berlin/go/webhooker/internal/gormlog"
 )
 
-// archiveExpiryNever is the expiry sentinel (and default) that
+// ExpiryNever is the expiry sentinel (and default) that
 // disables pruning so archived rows are kept forever.
-const archiveExpiryNever = "never"
+const ExpiryNever = "never"
 
 // archiveReopenDebounce bounds how often an archive file is
 // closed and reopened. After each write the handle is closed
@@ -71,17 +71,17 @@ var (
 		"archive writer has been evicted",
 	)
 
-	// ErrArchiveNameTaken is returned when an archive cannot be
+	// ErrNameTaken is returned when an archive cannot be
 	// renamed because a file already has the new name. That file may
 	// be an archive with rows of its own, so it is never replaced.
-	ErrArchiveNameTaken = errors.New(
+	ErrNameTaken = errors.New(
 		"a file already has the archive's new name",
 	)
 )
 
-// databaseTargetConfig is the optional per-target JSON config
+// DatabaseTargetConfig is the optional per-target JSON config
 // for a database (archive) target.
-type databaseTargetConfig struct {
+type DatabaseTargetConfig struct {
 	// Expiry is a Go duration (e.g. "720h") after which
 	// archived rows are pruned, or "never" (the default) to
 	// keep them forever.
@@ -112,21 +112,21 @@ type archivedEvent struct {
 	ArchivedAt time.Time `gorm:"index"`
 }
 
-// parseArchiveExpiry reads the optional expiry from a database
+// ParseExpiry reads the optional expiry from a database
 // target's config JSON. An empty config, an empty expiry, or
 // the literal "never" all mean keep forever, returned as a zero
 // duration. Any other value must parse as a positive Go
 // duration; a set-but-invalid value (unparseable, zero, or
 // negative) is an error rather than a silent default, matching
-// ValidateArchiveExpiry at target creation.
+// ValidateExpiry at target creation.
-func parseArchiveExpiry(
+func ParseExpiry(
 	configJSON string,
 ) (time.Duration, error) {
 	if configJSON == "" {
 		return 0, nil
 	}
 
-	var cfg databaseTargetConfig
+	var cfg DatabaseTargetConfig
 
 	err := json.Unmarshal([]byte(configJSON), &cfg)
 	if err != nil {
@@ -135,7 +135,7 @@ func parseArchiveExpiry(
 		)
 	}
 
-	if cfg.Expiry == "" || cfg.Expiry == archiveExpiryNever {
+	if cfg.Expiry == "" || cfg.Expiry == ExpiryNever {
 		return 0, nil
 	}
 
@@ -155,14 +155,14 @@ func parseArchiveExpiry(
 	return dur, nil
 }
 
-// ValidateArchiveExpiry checks a user-supplied archive expiry
+// ValidateExpiry checks a user-supplied archive expiry
 // for a database target at configuration time. Valid values are
 // empty, "never" (both meaning keep forever), or a positive Go
 // duration such as "720h". Anything else is an error, so a bad
 // expiry is rejected when the target is created rather than
 // failing every subsequent delivery.
-func ValidateArchiveExpiry(expiry string) error {
+func ValidateExpiry(expiry string) error {
-	if expiry == "" || expiry == archiveExpiryNever {
+	if expiry == "" || expiry == ExpiryNever {
 		return nil
 	}
 
@@ -171,7 +171,7 @@ func ValidateArchiveExpiry(expiry string) error {
 		return fmt.Errorf(
 			"expiry must be %q or a Go duration "+
 				"such as \"720h\": %w",
-			archiveExpiryNever, err,
+			ExpiryNever, err,
 		)
 	}
 
@@ -194,7 +194,7 @@ func ValidateArchiveExpiry(expiry string) error {
 type archiveWriter struct {
 	mu sync.Mutex
 
-	// path is the target's archive file as ArchivePath names it. A
+	// path is the target's archive file as Path names it. A
 	// target that rotates writes to the files archivePeriodPath names
 	// for path and a period instead.
 	path string
@@ -232,7 +232,7 @@ type archiveWriter struct {
 	// registry proper.
 	//
 	// Unlike every other field here it is guarded by
-	// databaseTarget.mu, not by this writer's mu: it describes the
+	// Writers.mu, not by this writer's mu: it describes the
 	// registry entry rather than the file.
 	sweepOwned bool
 }
@@ -277,7 +277,11 @@ func (w *archiveWriter) write(
 		}
 	}
 
-	row.ArchivedAt = time.Now()
+	// GORM's clock, the one that stamps created_at in the other
+	// databases, so this is stored in the same form. A bare time.Now()
+	// carries a monotonic clock reading, which the driver would store
+	// as an " m=+…" suffix.
+	row.ArchivedAt = w.db.NowFunc()
 
 	err := w.db.Create(&row).Error
 	if err != nil {
@@ -495,7 +499,7 @@ func (w *archiveWriter) sweepFile(
 // the next write creates its file under the new name.
 //
 // If a file already has one of the new names, nothing is moved and
-// the error is ErrArchiveNameTaken. If one file fails to move, those
+// the error is ErrNameTaken. If one file fails to move, those
 // already moved are moved back before the error is returned, so the
 // archive is never split across two names.
 func (w *archiveWriter) rename(name string) error {
@@ -533,7 +537,7 @@ func (w *archiveWriter) rename(name string) error {
 	for _, taken := range to {
 		if fileExists(taken) {
 			return fmt.Errorf(
-				"%w: %s", ErrArchiveNameTaken, filepath.Base(taken),
+				"%w: %s", ErrNameTaken, filepath.Base(taken),
 			)
 		}
 	}
@@ -586,7 +590,7 @@ func (w *archiveWriter) evict() {
 // each row's archived time. It runs on every (re)open, so a
 // steadily written archive is swept by its own write traffic. An
 // archive that goes idle receives no further reopens, which is
-// why ArchiveSweeper exists to drive sweepExpired on a timer.
+// why Sweeper exists to drive sweepExpired on a timer.
 // Failures are logged, not fatal: a prune error must not stop
 // archiving.
 func (w *archiveWriter) prune(expiry time.Duration) {
@@ -613,9 +617,9 @@ func (w *archiveWriter) prune(expiry time.Duration) {
 	}
 }
 
-// ArchiveFileInfo is what the metadata of a database target's archive
+// FileInfo is what the metadata of a database target's archive
 // files says about them.
-type ArchiveFileInfo struct {
+type FileInfo struct {
 	// Files counts the files.
 	Files int
 
@@ -627,18 +631,18 @@ type ArchiveFileInfo struct {
 	Written time.Time
 }
 
-// StatArchive reads the metadata of a database target's archive
+// Stat reads the metadata of a database target's archive
-// files, given the path ArchivePath gives it (see archiveFiles), and
+// files, given the path Path gives it (see archiveFiles), and
 // of their -wal, without opening them. With no files, which is so
 // before the first write and after the operator moved them away, the
 // error wraps fs.ErrNotExist.
-func StatArchive(path string) (ArchiveFileInfo, error) {
+func Stat(path string) (FileInfo, error) {
 	files, err := archiveFiles(path)
 	if err != nil {
-		return ArchiveFileInfo{}, err
+		return FileInfo{}, err
 	}
 
-	var info ArchiveFileInfo
+	var info FileInfo
 
 	for _, file := range files {
 		db, err := os.Stat(file.path)
@@ -647,7 +651,7 @@ func StatArchive(path string) (ArchiveFileInfo, error) {
 		}
 
 		if err != nil {
-			return ArchiveFileInfo{}, err
+			return FileInfo{}, err
 		}
 
 		info.Files++
@@ -663,7 +667,7 @@ func StatArchive(path string) (ArchiveFileInfo, error) {
 		}
 
 		if err != nil {
-			return ArchiveFileInfo{}, err
+			return FileInfo{}, err
 		}
 
 		info.Size += wal.Size()
@@ -674,7 +678,7 @@ func StatArchive(path string) (ArchiveFileInfo, error) {
 	}
 
 	if info.Files == 0 {
-		return ArchiveFileInfo{}, fmt.Errorf(
+		return FileInfo{}, fmt.Errorf(
 			"no archive file for %s: %w", path, fs.ErrNotExist,
 		)
 	}

internal/archive/writer_gormlog_test.go

@@ -1,4 +1,4 @@
-package delivery_test
+package archive_test
 
 import (
 	"bytes"
@@ -14,7 +14,7 @@ import (
 	"github.com/stretchr/testify/require"
 	"gorm.io/gorm"
 	gormlogger "gorm.io/gorm/logger"
-	"sneak.berlin/go/webhooker/internal/delivery"
+	"sneak.berlin/go/webhooker/internal/archive"
 	"sneak.berlin/go/webhooker/internal/middleware"
 )
 
@@ -57,7 +57,7 @@ func (g *gormDefaultBuf) String() string {
 // without exporting production code to carry it, and a logging
 // detector is not worth a production symbol. What it detects is the
 // third gorm.Open in this service, at
-// internal/delivery/target_database_archive.go — the archive writer,
+// internal/archive/writer.go — the archive writer,
 // whose type is unexported, so nothing outside this package can drive
 // it.
 func captureArchiveGORMDefault(t *testing.T) *gormDefaultBuf {
@@ -85,7 +85,7 @@ func captureArchiveGORMDefault(t *testing.T) *gormDefaultBuf {
 // writer's gorm.Open to the adapter.
 //
 // Restore a bare &gorm.Config{} at
-// internal/delivery/target_database_archive.go and this fails: the
+// internal/archive/writer.go and this fails: the
 // default logger prints the fully interpolated SELECT on every
 // ErrRecordNotFound, so the client-chosen event id below arrives whole
 // and unbounded on stdout, answering to no level the operator set.
@@ -100,7 +100,7 @@ func TestArchiveWriter_NeverUsesGORMsDefaultLogger(t *testing.T) {
 
 	gormDefault := captureArchiveGORMDefault(t)
 
-	w := delivery.NewExportArchiveWriter(
+	w := archive.NewExportArchiveWriter(
 		filepath.Join(t.TempDir(), "archive.db"),
 		slog.New(slog.NewTextHandler(
 			&captured, &slog.HandlerOptions{Level: slog.LevelDebug},
@@ -118,7 +118,7 @@ func TestArchiveWriter_NeverUsesGORMsDefaultLogger(t *testing.T) {
 	value := strings.Repeat("\x01", archiveGORMFillBytes) +
 		archiveGORMTailMarker
 
-	var row delivery.ExportArchivedEvent
+	var row archive.ExportArchivedEvent
 
 	err := w.DB().Where("event_id = ?", value).First(&row).Error
 	require.ErrorIs(t, err, gorm.ErrRecordNotFound)

internal/database/event_db_isolation_test.go

@@ -25,10 +25,11 @@ func TestEventDBCreateOmitsAssociations(t *testing.T) {
 	require.NoError(t, err)
 
 	target := database.Target{
-		WebhookID: webhookID,
+		WebhookID:   webhookID,
-		Name:      "leaky-target",
+		Name:        "leaky-target",
-		Type:      database.TargetTypeSlack,
+		Type:        database.TargetTypeSlack,
-		Config:    `{"webhookUrl":"https://hooks.example/secret"}`,
+		Config:      `{"webhookUrl":"https://hooks.example/secret"}`,
+		MaxAttempts: 1,
 	}
 	target.ID = uuid.New().String()
 

internal/database/event_tier_indexes_test.go

@@ -79,8 +79,9 @@ func TestEventTierQueriesUseTheirIndexes(t *testing.T) {
 	byStatus := "idx_deliveries_status (status=? AND deleted_at=?)"
 	byEvent := "idx_deliveries_event_id (event_id=? AND deleted_at=?)"
 
-	// The delivery engine: recovery and the retry sweep, the sweep for
+	// The delivery engine: the recovery routine, which reads the
-	// stranded pending deliveries, and the queue depth count.
+	// retrying deliveries and, on a tick of the sweep, the pending ones
+	// untouched for a while; and the queue depth count.
 	assertPlanUses(t, db, dry.Where(
 		"status = ?", database.DeliveryStatusRetrying,
 	).Find(&deliveries), byStatus)

internal/database/model_parent_test.go

@@ -23,8 +23,9 @@ func TestPreloadedModelsMarshalWithoutTheirParent(t *testing.T) {
 		Name:        testWebhookName,
 		Entrypoints: []database.Entrypoint{{Path: uuid.New().String()}},
 		Targets: []database.Target{{
-			Name: "log",
+			Name:        "log",
-			Type: database.TargetTypeLog,
+			Type:        database.TargetTypeLog,
+			MaxAttempts: 1,
 		}},
 	}
 	require.NoError(t, db.Create(&stored).Error)

internal/database/model_secrets_test.go

@@ -46,9 +46,10 @@ func TestModelsDoNotMarshalTheirSecrets(t *testing.T) {
 		{
 			name: "target config",
 			model: database.Target{
-				Name:   keptField,
+				Name:        keptField,
-				Type:   database.TargetTypeSlack,
+				Type:        database.TargetTypeSlack,
-				Config: `{"webhookUrl":"https://h/s/` + marker + `"}`,
+				Config:      `{"webhookUrl":"https://h/s/` + marker + `"}`,
+				MaxAttempts: 1,
 			},
 		},
 		{
@@ -97,8 +98,9 @@ func TestWebhookMarshalsNoTargetConfig(t *testing.T) {
 	encoded := marshalModel(t, database.Webhook{
 		Name: keptField,
 		Targets: []database.Target{{
-			Name:   "slack",
+			Name:        "slack",
-			Config: `{"webhookUrl":"https://h/s/` + marker + `"}`,
+			Config:      `{"webhookUrl":"https://h/s/` + marker + `"}`,
+			MaxAttempts: 1,
 		}},
 	})
 

internal/database/model_target.go

@@ -29,9 +29,12 @@ type Target struct {
 	// handler that marshals the model itself.
 	Config string `gorm:"type:text" json:"-"` // JSON configuration
 
-	// For HTTP targets (max_retries=0 means fire-and-forget,
+	// MaxAttempts is how many times an HTTP or Slack target attempts
-	// >0 enables retries with backoff)
+	// each delivery in all, at least 1. 1 is a single attempt with no
-	MaxRetries int `json:"maxRetries,omitempty"`
+	// circuit breaker; above 1, a failed attempt is retried with
+	// backoff behind the breaker. The table's check constraint refuses
+	// a target saved with less than 1, whatever its type.
+	MaxAttempts int `gorm:"not null;check:max_attempts >= 1" json:"maxAttempts,omitempty"`
 
 	// Relations. No model marshals the record it belongs to:
 	// Webhook.Targets leads back here, and the JSON could loop.

internal/database/model_target_test.go

@@ -0,0 +1,44 @@
+package database_test
+
+import (
+	"testing"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/webhooker/internal/database"
+)
+
+// newHTTPTarget returns an http target that makes maxAttempts attempts
+// at each delivery.
+func newHTTPTarget(maxAttempts int) *database.Target {
+	return &database.Target{
+		WebhookID:   uuid.New().String(),
+		Name:        "target",
+		Type:        database.TargetTypeHTTP,
+		Config:      `{"url":"https://example.com/"}`,
+		MaxAttempts: maxAttempts,
+	}
+}
+
+// TestTargetCreate_RefusesZeroAttempts relies on the targets table
+// alone: nothing in the model checks the number, so the check
+// constraint is what keeps a target with 0 attempts out of the
+// database.
+func TestTargetCreate_RefusesZeroAttempts(t *testing.T) {
+	t.Parallel()
+
+	db := startedTestDB(t)
+
+	err := db.Create(newHTTPTarget(0)).Error
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "CHECK constraint failed")
+}
+
+func TestTargetCreate_AcceptsOneAttempt(t *testing.T) {
+	t.Parallel()
+
+	db := startedTestDB(t)
+
+	require.NoError(t, db.Create(newHTTPTarget(1)).Error)
+}

internal/database/model_webhook.go

@@ -4,27 +4,13 @@ import (
 	"math"
 	"strconv"
 	"time"
-
-	"gorm.io/gorm"
 )
 
 const (
-	// DefaultRetentionDays is the event retention period applied to a
+	// DefaultRetentionDays is the event retention period the new
-	// webhook created without an explicit retention value. It is the
+	// webhook form applies when its retention field is left blank.
-	// single source of truth for that policy and must stay in sync
-	// with the `gorm:"default:30"` column default on
-	// Webhook.RetentionDays below; a struct tag cannot reference a
-	// constant, so a test asserts the two agree.
 	DefaultRetentionDays = 30
 
-	// RetentionForeverDays is the sentinel RetentionDays value meaning
-	// "retain events forever". Users express that intent as 0, which
-	// Webhook.BeforeSave rewrites to this value: the column default
-	// substitutes DefaultRetentionDays for a zero value at insert
-	// time, so a zero can never survive a round trip to the database.
-	// Nothing outside this file may hardcode the number.
-	RetentionForeverDays = 365 * 1000
-
 	// MaxFiniteRetentionDays is the largest finite retention period the
 	// reaper's cutoff arithmetic can represent, and therefore the
 	// largest one a caller may request. It is derived from that
@@ -38,9 +24,7 @@ const (
 	// turns the cutoff into a timestamp in the far future that matches
 	// every row in the webhook's database. That is why this bound is
 	// enforced on input and why retentionCutoff saturates underneath
-	// it. Note that RetentionForeverDays deliberately sits above this
+	// it.
-	// ceiling: such webhooks are skipped before any cutoff is
-	// computed, and never reach the arithmetic at all.
 	MaxFiniteRetentionDays = int(
 		math.MaxInt64 / int64(time.Hour) / hoursPerDay,
 	)
@@ -48,12 +32,10 @@ const (
 
 // Webhook represents a webhook processing unit that groups entrypoints and targets
 //
-// Every method below takes a pointer receiver. BeforeSave has to,
+// Every method below takes a pointer receiver, so handlers put a
-// because it mutates the record and GORM only invokes hooks declared
+// *Webhook into template data: html/template cannot call a pointer
-// that way; the display helpers follow suit so the receiver kinds do
+// method on a value held in a map, because a map element is not
-// not mix. Handlers therefore put a *Webhook into template data:
+// addressable.
-// html/template cannot call a pointer method on a value held in a map,
-// because a map element is not addressable.
 type Webhook struct {
 	BaseModel
 
@@ -61,10 +43,9 @@ type Webhook struct {
 	Name        string `gorm:"not null"           json:"name"`
 	Description string `json:"description"`
 
-	// RetentionDays is the number of days to retain events. A value of
+	// RetentionDays is the number of days to retain events, and 0
-	// RetentionForeverDays means retain forever. The column default
+	// means retain them forever.
-	// must equal DefaultRetentionDays.
+	RetentionDays int `json:"retentionDays"`
-	RetentionDays int `gorm:"default:30" json:"retentionDays"`
 
 	// Relations. No model marshals the record it belongs to:
 	// User.Webhooks leads back here, and the JSON could loop.
@@ -73,36 +54,17 @@ type Webhook struct {
 	Targets     []Target     `json:"targets,omitempty"`
 }
 
-// BeforeSave normalises RetentionDays on every insert and update. A
+// retainsForever reports whether a RetentionDays value means "keep
-// non-positive value is the user's way of asking for "retain forever",
+// events indefinitely", which 0 does. It is the single definition of
-// which is stored as the RetentionForeverDays sentinel.
+// that question, shared by Webhook.RetainsForever and by the reaper's
-//
-// This has to happen in a hook rather than at the call sites. GORM
-// substitutes the column default (DefaultRetentionDays) for a zero
-// value while building the insert statement, which runs after
-// BeforeSave; rewriting any later than this loses that race and the
-// row lands at 30 days. Living on the model also means a future call
-// site, such as a REST API or a fixture, cannot bypass it.
-func (w *Webhook) BeforeSave(_ *gorm.DB) error {
-	if w.RetentionDays <= 0 {
-		w.RetentionDays = RetentionForeverDays
-	}
-
-	return nil
-}
-
-// retainsForever reports whether a stored RetentionDays value means
-// "keep events indefinitely". It is the single definition of that
-// question, shared by Webhook.RetainsForever and by the reaper's
 // cutoff computation so the two cannot disagree about which webhooks
 // are exempt from reaping.
 //
-// It accepts the RetentionForeverDays sentinel written by BeforeSave
+// A negative value, which the forms refuse, is read the same way: as a
-// and, defensively, any non-positive value, which BeforeSave treats
+// day count it would put the cutoff in the future, where it matches
-// as a request to retain forever.
+// every event the webhook has.
 func retainsForever(retentionDays int) bool {
-	return retentionDays <= 0 ||
+	return retentionDays <= 0
-		retentionDays >= RetentionForeverDays
 }
 
 // RetainsForever reports whether this webhook's events are kept
@@ -119,7 +81,8 @@ func (w *Webhook) RetentionCutoff(now time.Time) (time.Time, bool) {
 }
 
 // RetentionLabel returns the webhook's retention policy as display
-// text, so that no template has to know about the sentinel value.
+// text: "forever" rather than "0 days" for a webhook that keeps its
+// events.
 func (w *Webhook) RetentionLabel() string {
 	if w.RetainsForever() {
 		return "forever"

internal/database/model_webhook_test.go

@@ -2,8 +2,6 @@ package database_test
 
 import (
 	"context"
-	"reflect"
-	"strconv"
 	"testing"
 	"time"
 
@@ -47,8 +45,7 @@ func storedRetention(t *testing.T, db *gorm.DB, id string) int {
 }
 
 // newWebhookWithRetention creates a webhook through the ordinary Create
-// path, so the BeforeSave hook and the GORM column default both apply
+// path, as the new webhook form does.
-// exactly as they do in production.
 func newWebhookWithRetention(
 	t *testing.T,
 	db *gorm.DB,
@@ -67,7 +64,7 @@ func newWebhookWithRetention(
 	return wh.ID
 }
 
-func TestWebhookBeforeSave_ZeroBecomesForeverSentinel(t *testing.T) {
+func TestWebhookRetentionDays_ZeroIsStoredAsZero(t *testing.T) {
 	t.Parallel()
 
 	db := startedTestDB(t)
@@ -75,31 +72,10 @@ func TestWebhookBeforeSave_ZeroBecomesForeverSentinel(t *testing.T) {
 	wh := &database.Webhook{RetentionDays: 0}
 	id := newWebhookWithRetention(t, db, wh)
 
-	assert.Equal(
+	assert.Equal(t, 0, storedRetention(t, db, id))
-		t,
-		database.RetentionForeverDays,
-		storedRetention(t, db, id),
-		"a zero retention must be stored as the sentinel, "+
-			"not replaced by the column default",
-	)
 }
 
-func TestWebhookBeforeSave_NegativeBecomesForeverSentinel(t *testing.T) {
+func TestWebhookRetentionDays_DayCountIsStored(t *testing.T) {
-	t.Parallel()
-
-	db := startedTestDB(t)
-
-	wh := &database.Webhook{RetentionDays: -5}
-	id := newWebhookWithRetention(t, db, wh)
-
-	assert.Equal(
-		t,
-		database.RetentionForeverDays,
-		storedRetention(t, db, id),
-	)
-}
-
-func TestWebhookBeforeSave_PositiveIsPreserved(t *testing.T) {
 	t.Parallel()
 
 	db := startedTestDB(t)
@@ -110,10 +86,9 @@ func TestWebhookBeforeSave_PositiveIsPreserved(t *testing.T) {
 	assert.Equal(t, 7, storedRetention(t, db, id))
 }
 
-// TestWebhookBeforeSave_UpdateToZeroBecomesSentinel proves the hook
+// TestWebhookRetentionDays_UpdateToZeroIsStoredAsZero changes a day
-// fires on update as well as insert, via the same Save call the edit
+// count to 0 through the same Save call the edit handler makes.
-// handler makes.
+func TestWebhookRetentionDays_UpdateToZeroIsStoredAsZero(t *testing.T) {
-func TestWebhookBeforeSave_UpdateToZeroBecomesSentinel(t *testing.T) {
 	t.Parallel()
 
 	db := startedTestDB(t)
@@ -125,28 +100,7 @@ func TestWebhookBeforeSave_UpdateToZeroBecomesSentinel(t *testing.T) {
 	wh.RetentionDays = 0
 	require.NoError(t, db.Omit(clause.Associations).Save(wh).Error)
 
-	assert.Equal(
+	assert.Equal(t, 0, storedRetention(t, db, id))
-		t,
-		database.RetentionForeverDays,
-		storedRetention(t, db, id),
-	)
-}
-
-// TestWebhookRetentionColumnDefaultMatchesConstant guards the one place
-// the default lives twice: a struct tag cannot reference a constant, so
-// this asserts the tag and DefaultRetentionDays agree.
-func TestWebhookRetentionColumnDefaultMatchesConstant(t *testing.T) {
-	t.Parallel()
-
-	field, ok := reflect.TypeFor[database.Webhook]().
-		FieldByName("RetentionDays")
-	require.True(t, ok, "Webhook.RetentionDays must exist")
-
-	assert.Equal(
-		t,
-		"default:"+strconv.Itoa(database.DefaultRetentionDays),
-		field.Tag.Get("gorm"),
-	)
 }
 
 // TestMaxFiniteRetentionDaysIsTheOverflowCeiling asserts that the
@@ -176,14 +130,6 @@ func TestMaxFiniteRetentionDaysIsTheOverflowCeiling(t *testing.T) {
 		time.Duration(overCeiling*hoursPerDay)*time.Hour,
 		"one day past the ceiling must overflow",
 	)
-
-	assert.Less(
-		t,
-		database.MaxFiniteRetentionDays,
-		database.RetentionForeverDays,
-		"the sentinel sits above the ceiling and is only safe "+
-			"because retain-forever webhooks skip the arithmetic",
-	)
 }
 
 func TestWebhookRetainsForeverAndLabel(t *testing.T) {
@@ -195,16 +141,8 @@ func TestWebhookRetainsForeverAndLabel(t *testing.T) {
 		forever bool
 		label   string
 	}{
-		{
+		{"zero", 0, true, testForeverLabel},
-			"sentinel",
+		{"negative", -1, true, testForeverLabel},
-			database.RetentionForeverDays, true, testForeverLabel,
-		},
-		{
-			"above sentinel",
-			database.RetentionForeverDays + 1, true, testForeverLabel,
-		},
-		{"legacy zero", 0, true, testForeverLabel},
-		{"legacy negative", -1, true, testForeverLabel},
 		{"default", database.DefaultRetentionDays, false, "30 days"},
 		{"one day", 1, false, "1 day"},
 	}

internal/database/retention.go

@@ -184,8 +184,9 @@ func (r *RetentionReaper) sweep(ctx context.Context) {
 
 		wh := webhooks[i]
 
-		// A missing database has nothing to reap. Restart recovery
+		// A missing database has nothing to reap. The delivery
-		// reports a lost one (see WebhookDBManager.GetDB).
+		// engine's recovery routine reports a lost one at start (see
+		// WebhookDBManager.GetDB).
 		if !r.dbManager.DBExists(wh.ID) {
 			continue
 		}
@@ -243,7 +244,8 @@ func (r *RetentionReaper) reapWebhook(
 
 // retentionCutoff returns the timestamp before which a webhook's
 // events have expired, and whether any cutoff applies at all. It
-// reports false for a retain-forever policy, so no DELETE is issued.
+// reports false for a retention of 0, which means retain forever, so
+// no DELETE is issued.
 //
 // The day count is clamped to MaxFiniteRetentionDays first. This is
 // defense in depth rather than decoration: a time.Duration is an int64

internal/database/retention_test.go

@@ -85,41 +85,6 @@ func createWebhook(
 		db.Omit(clause.Associations).Create(wh).Error,
 	)
 
-	// Webhook.BeforeSave rewrites a non-positive RetentionDays to the
-	// retain-forever sentinel, and the column's GORM default would
-	// otherwise substitute 30. Force the requested value with a
-	// column-level update so tests can plant legacy rows that predate
-	// the sentinel and still carry a literal 0 or negative value.
-	require.NoError(
-		t,
-		db.Model(wh).
-			Update("retention_days", retentionDays).Error,
-	)
-
-	return wh.ID
-}
-
-// createWebhookNormally inserts a webhook through the ordinary Create
-// path, with no column-level forcing, so Webhook.BeforeSave applies
-// exactly as it does in production. Passing 0 therefore yields a row
-// holding the RetentionForeverDays sentinel.
-func createWebhookNormally(
-	t *testing.T,
-	db *gorm.DB,
-	retentionDays int,
-) string {
-	t.Helper()
-
-	wh := &database.Webhook{
-		UserID:        uuid.New().String(),
-		Name:          testWebhookName,
-		RetentionDays: retentionDays,
-	}
-	require.NoError(
-		t,
-		db.Omit(clause.Associations).Create(wh).Error,
-	)
-
 	return wh.ID
 }
 
@@ -281,19 +246,19 @@ func TestRetentionReaper_ReapsExpiredKeepsRecent(t *testing.T) {
 	assertChainPresent(t, db, recent)
 }
 
-// TestRetentionReaper_SkipsSentinelReapsFiniteInSameSweep covers the
+// TestRetentionReaper_SkipsZeroReapsFiniteInSameSweep covers the
-// end-to-end retain-forever path: a webhook created the normal way with
+// end-to-end retain-forever path: a webhook created with a retention
-// a requested retention of 0 lands on the RetentionForeverDays
+// of 0 reads back 0, and the reaper leaves its ancient events alone
-// sentinel, and the reaper leaves its ancient events alone while still
+// while still reaping a finite-retention webhook in the very same
-// reaping a finite-retention webhook in the very same sweep.
+// sweep.
-func TestRetentionReaper_SkipsSentinelReapsFiniteInSameSweep(
+func TestRetentionReaper_SkipsZeroReapsFiniteInSameSweep(
 	t *testing.T,
 ) {
 	t.Parallel()
 
 	env := setupRetentionTest(t)
 
-	foreverID := createWebhookNormally(t, env.mainDB.DB(), 0)
+	foreverID := createWebhook(t, env.mainDB.DB(), 0)
 
 	var stored database.Webhook
 
@@ -302,14 +267,12 @@ func TestRetentionReaper_SkipsSentinelReapsFiniteInSameSweep(
 		env.mainDB.DB().Where("id = ?", foreverID).
 			First(&stored).Error,
 	)
-	require.Equal(
+	require.Zero(
-		t,
+		t, stored.RetentionDays,
-		database.RetentionForeverDays,
+		"a retention of 0 must be stored as 0",
-		stored.RetentionDays,
-		"a requested retention of 0 must persist as the sentinel",
 	)
 
-	finiteID := createWebhookNormally(t, env.mainDB.DB(), 30)
+	finiteID := createWebhook(t, env.mainDB.DB(), 30)
 
 	foreverDB, err := env.mgr.GetDB(foreverID)
 	require.NoError(t, err)
@@ -335,14 +298,10 @@ func TestRetentionReaper_SkipsSentinelReapsFiniteInSameSweep(
 // negative, so subtracting it moves the cutoff into the far future,
 // where "created_at < cutoff" matches every row: an event created a
 // moment ago, and its delivery and delivery result, were all deleted
-// on the first sweep. 200000 is inside that band and below the
+// on the first sweep. 200000 is inside that band.
-// retain-forever sentinel, so it is treated as a finite policy and
-// really does reach the arithmetic.
 //
-// The row is planted at the column level because such a value can no
+// The form refuses such a value; the point of the test is that a row
-// longer be submitted through the form; the point of the test is that
+// written by any other path still cannot trigger the wipe.
-// a row from an older version, or a future call site, still cannot
-// trigger the wipe.
 func TestRetentionReaper_HugeFiniteRetentionRetainsRecentEvents(
 	t *testing.T,
 ) {
@@ -358,12 +317,6 @@ func TestRetentionReaper_HugeFiniteRetentionRetainsRecentEvents(
 		database.MaxFiniteRetentionDays,
 		"the test value must exceed what the cutoff can represent",
 	)
-	require.Less(
-		t,
-		overflowingRetentionDays,
-		database.RetentionForeverDays,
-		"the test value must not be treated as retain-forever",
-	)
 
 	webhookID := createWebhook(
 		t, env.mainDB.DB(), overflowingRetentionDays,
@@ -379,14 +332,15 @@ func TestRetentionReaper_HugeFiniteRetentionRetainsRecentEvents(
 	assertChainPresent(t, db, fresh)
 }
 
-func TestRetentionReaper_RetainsForeverWhenNonPositive(t *testing.T) {
+// TestRetentionReaper_RetainsForeverWhenNegative checks that a negative
+// retention, which the forms refuse, keeps every event rather than
+// putting the cutoff in the future, where it would match them all.
+func TestRetentionReaper_RetainsForeverWhenNegative(t *testing.T) {
 	t.Parallel()
 
 	env := setupRetentionTest(t)
 
-	// A legacy row written before the sentinel existed still carries a
+	webhookID := createWebhook(t, env.mainDB.DB(), -1)
-	// literal 0; the <= 0 guard must keep honouring it.
-	webhookID := createWebhook(t, env.mainDB.DB(), 0)
 
 	db, err := env.mgr.GetDB(webhookID)
 	require.NoError(t, err)

internal/database/schema_test.go

@@ -87,13 +87,13 @@ func TestMainSchemaHoldsEveryModel(t *testing.T) {
 		Active:      true,
 	})
 	assertRoundTrip(t, db, &database.Target{
-		BaseModel:  newBaseModel(),
+		BaseModel:   newBaseModel(),
-		WebhookID:  uuid.New().String(),
+		WebhookID:   uuid.New().String(),
-		Name:       "target",
+		Name:        "target",
-		Type:       database.TargetTypeHTTP,
+		Type:        database.TargetTypeHTTP,
-		Active:     true,
+		Active:      true,
-		Config:     `{"url":"https://example.com/"}`,
+		Config:      `{"url":"https://example.com/"}`,
-		MaxRetries: 3,
+		MaxAttempts: 3,
 	})
 }
 

internal/database/sqlite_mode_test.go

@@ -137,7 +137,7 @@ func TestPerWebhookEventDatabaseFilesAreOwnerOnly(t *testing.T) {
 }
 
 // TestArchiveDatabaseFilesAreOwnerOnly covers the archive-*.db tier.
-// internal/delivery builds that path and opens it through OpenSQLite,
+// internal/archive builds that path and opens it through OpenSQLite,
 // the same single open path exercised here, so the mode is settled for
 // all three tiers in one place.
 func TestArchiveDatabaseFilesAreOwnerOnly(t *testing.T) {

internal/db/migrations/archive/001_schema.sql

@@ -1,5 +1,5 @@
 -- Migration 001: the schema of a database target's archive file. The
--- archivedEvent model in internal/delivery must agree with it.
+-- archivedEvent model in internal/archive must agree with it.
 
 CREATE TABLE archived_events (
     id integer PRIMARY KEY AUTOINCREMENT,

internal/db/migrations/main/001_schema.sql

@@ -46,7 +46,7 @@ CREATE TABLE webhooks (
     user_id uuid NOT NULL,
     name text NOT NULL,
     description text,
-    retention_days integer DEFAULT 30,
+    retention_days integer,
     PRIMARY KEY (id),
     CONSTRAINT fk_users_webhooks FOREIGN KEY (user_id) REFERENCES users (id)
 );
@@ -80,10 +80,11 @@ CREATE TABLE targets (
     type text NOT NULL,
     active numeric DEFAULT true,
     config text,
-    max_retries integer,
+    max_attempts integer NOT NULL,
     PRIMARY KEY (id),
     CONSTRAINT fk_webhooks_targets
-        FOREIGN KEY (webhook_id) REFERENCES webhooks (id)
+        FOREIGN KEY (webhook_id) REFERENCES webhooks (id),
+    CONSTRAINT chk_targets_max_attempts CHECK (max_attempts >= 1)
 );
 
 CREATE INDEX idx_targets_deleted_at ON targets (deleted_at);

internal/delivery/delivery_totals_test.go

@@ -32,8 +32,9 @@ func targetTotals(
 
 // TestUpdateDeliveryStatus_FinishTimeAndTargetTotals pins what a status
 // write records for the webhook page's statistics: the time a delivery
-// finished, set only when it becomes delivered or failed, and one more
+// finished, set only when it becomes delivered or failed and stored in
-// on its target's delivered or failed total.
+// the same form as created_at, and one more on its target's delivered
+// or failed total.
 func TestUpdateDeliveryStatus_FinishTimeAndTargetTotals(t *testing.T) {
 	t.Parallel()
 
@@ -75,6 +76,16 @@ func TestUpdateDeliveryStatus_FinishTimeAndTargetTotals(t *testing.T) {
 			if tt.finished {
 				require.NotNil(t, stored.FinishedAt)
 				assert.False(t, stored.FinishedAt.Before(before))
+
+				var createdAt, finishedAt string
+
+				require.NoError(t, db.Raw(
+					`SELECT CAST(created_at AS TEXT),
+						CAST(finished_at AS TEXT)
+					FROM deliveries WHERE id = ?`, d.ID,
+				).Row().Scan(&createdAt, &finishedAt))
+				assertStoredTime(t, createdAt)
+				assertStoredTime(t, finishedAt)
 			} else {
 				assert.Nil(t, stored.FinishedAt)
 			}

internal/delivery/engine.go

@@ -13,6 +13,7 @@ import (
 
 	"go.uber.org/fx"
 	"gorm.io/gorm"
+	"sneak.berlin/go/webhooker/internal/archive"
 	"sneak.berlin/go/webhooker/internal/database"
 	"sneak.berlin/go/webhooker/internal/globals"
 	"sneak.berlin/go/webhooker/internal/lifecycle"
@@ -39,8 +40,9 @@ const (
 	// explosions regardless of queue depth.
 	defaultWorkers = 10
 
-	// retrySweepInterval is how often the periodic retry
+	// retrySweepInterval is how often the recovery routine runs
-	// sweep runs.
+	// once it has run at start. Each of those runs is a tick of
+	// the sweep.
 	retrySweepInterval = 60 * time.Second
 
 	// pendingSweepMinAge is how long a delivery must have sat
@@ -62,10 +64,10 @@ const (
 	pendingSweepMinAge = 15 * time.Minute
 
 	// pendingSweepBatch bounds how many stranded pending deliveries
-	// one sweep of one webhook re-dispatches. The sweep runs every
+	// one tick of the sweep re-dispatches for one webhook. The sweep
-	// retrySweepInterval, so a larger backlog drains across
+	// ticks every retrySweepInterval, so a larger backlog drains
-	// successive sweeps instead of arriving as one burst against a
+	// across successive ticks instead of arriving as one burst against
-	// database that was already struggling to accept writes.
+	// a database that was already struggling to accept writes.
 	pendingSweepBatch = 500
 
 	// MaxInlineBodySize is the maximum event body size that
@@ -107,7 +109,7 @@ type Task struct {
 	TargetName   string
 	TargetType   database.TargetType
 	TargetConfig string
-	MaxRetries   int
+	MaxAttempts  int
 
 	Method      string
 	RawQuery    string
@@ -124,31 +126,11 @@ type Notifier interface {
 	Notify(tasks []Task)
 }
 
-// Archives is how the handlers keep the database targets' archive
-// files in step with the configuration. Deleting a webhook or a
-// target releases the cached archive writers, whose open file
-// handles would otherwise outlive them; renaming one renames the
-// archive files, which are named for the webhook and the target
-// (see ArchiveFileName).
-//
-// It is deliberately separate from Notifier: archiving lifecycle
-// is not notification, and a small interface keeps the handlers
-// package free of any dependency on the engine's internals while
-// staying trivially fakeable in tests.
-//
-// Neither eviction deletes an archive file. Both are idempotent
-// and are no-ops for a webhook or target with no engine state.
-type Archives interface {
-	EvictWebhook(webhookID string)
-	EvictTarget(targetID string)
-	Rename(targetID, webhookName, targetName string) error
-}
-
 // CircuitBreakers is how the handlers read a target's circuit
 // breaker, so the webhook page and the event log can say that
-// deliveries to the target are paused and until when. Like Archives,
+// deliveries to the target are paused and until when. It keeps the
-// it keeps the handlers free of the engine's internals and is
+// handlers free of the engine's internals and is trivially faked in
-// trivially faked in tests.
+// tests.
 type CircuitBreakers interface {
 	StateAndCooldown(targetID string) (CircuitState, time.Duration)
 }
@@ -164,12 +146,13 @@ type EngineParams struct {
 	Logger    *logger.Logger
 	SSRFGuard *Guard
 	Metrics   *metrics.Set
+	Archives  *archive.Writers
 }
 
 // Engine processes queued deliveries in the background
 // using a bounded worker pool architecture. It owns only
 // the cross-target machinery: the worker pool, the queue
-// and retry channels, restart recovery, and the persistence
+// and retry channels, the recovery routine, and the persistence
 // helpers and Scheduler that individual targets rely on.
 // Each target type owns its own delivery, including retries,
 // backoff, and circuit breaking.
@@ -202,12 +185,13 @@ type Engine struct {
 	httpTarget  *httpTarget
 	slackTarget *slackTarget
 
-	// dbTarget is retained so the engine can reach the archive
+	// archives is the database targets' archive writers. The
-	// writer registry for eviction, renames and the idle sweep.
+	// database target writes each event through them, and stop
-	dbTarget *databaseTarget
+	// closes them.
+	archives *archive.Writers
 
 	// inflight is the set of deliveries this engine currently owns.
-	// Recovery and the sweeps re-dispatch only what it does not
+	// The recovery routine re-dispatches only what it does not
 	// hold. Held by value: its zero value works, so no constructor
 	// can leave it out. See inflight.go.
 	inflight inflightSet
@@ -228,6 +212,7 @@ func New(
 		workers:    defaultWorkers,
 		version:    params.Globals.Version,
 		mtr:        params.Metrics,
+		archives:   params.Archives,
 	}
 
 	e.initTargets(&http.Client{
@@ -272,47 +257,6 @@ func (e *Engine) Notify(tasks []Task) {
 	}
 }
 
-// EvictWebhook implements Archives. The cached archive writer of
-// every database target of the webhook is dropped from the
-// registry and its file handle closed. The archive files
-// themselves are left on disk — they are long-term storage the
-// operator owns.
-func (e *Engine) EvictWebhook(webhookID string) {
-	if e.dbTarget == nil {
-		return
-	}
-
-	e.dbTarget.evictWebhook(webhookID)
-}
-
-// EvictTarget implements Archives. It is EvictWebhook for a single
-// database target, and leaves the archive file on disk the same
-// way.
-func (e *Engine) EvictTarget(targetID string) {
-	if e.dbTarget == nil {
-		return
-	}
-
-	e.dbTarget.evict(targetID)
-}
-
-// Rename implements Archives. It renames every one of a database
-// target's archive files to ArchiveFileName(webhookName, targetName,
-// targetID), each keeping the period in its name, under the lock the
-// target's archive writes and the idle sweep take. It never replaces
-// a file: if one already has a new name, the error is
-// ErrArchiveNameTaken. The caller renames before it saves the new
-// name: see databaseTarget.rename.
-func (e *Engine) Rename(
-	targetID, webhookName, targetName string,
-) error {
-	if e.dbTarget == nil {
-		return nil
-	}
-
-	return e.dbTarget.rename(targetID, webhookName, targetName)
-}
-
 // StateAndCooldown implements CircuitBreakers. It returns the state of
 // the target's circuit breaker and, while the breaker is open, what is
 // left of its cooldown; the cooldown is zero once that has passed and
@@ -399,8 +343,8 @@ func (e *Engine) registerHooks(lc fx.Lifecycle) {
 	})
 }
 
-// start launches the worker pool, restart recovery, and the
+// start launches the worker pool and the recovery routine, which
-// periodic retry sweep.
+// runs now and then on every tick of the sweep (see runRecovery).
 //
 // Their context is derived from context.Background(), NOT from
 // the fx OnStart hook context. The hook context carries fx's
@@ -423,11 +367,7 @@ func (e *Engine) start() {
 
 	e.wg.Add(1)
 
-	go e.recoverPending(ctx)
+	go e.runRecovery(ctx)
-
-	e.wg.Add(1)
-
-	go e.retrySweep(ctx)
 
 	e.wg.Add(1)
 
@@ -466,7 +406,7 @@ func (e *Engine) stop(ctx context.Context) error {
 		return err
 	}
 
-	e.dbTarget.evictAll()
+	e.archives.EvictAll()
 
 	e.log.Info("delivery engine stopped")
 
@@ -510,12 +450,6 @@ func (e *Engine) runTask(
 	run(ctx, task)
 }
 
-func (e *Engine) recoverPending(ctx context.Context) {
-	defer e.wg.Done()
-
-	e.recoverInFlight(ctx)
-}
-
 func (e *Engine) processNewTask(
 	ctx context.Context, task *Task,
 ) {
@@ -530,9 +464,10 @@ func (e *Engine) processNewTask(
 		return
 	}
 
-	// Restart recovery can send and release this delivery before the
+	// The recovery routine's run at start can send and release this
-	// receiver's Notify queues it. Ownership cannot refuse a delivery
+	// delivery before the receiver's Notify queues it. Ownership cannot
-	// nobody holds, so the row decides whether it still needs sending.
+	// refuse a delivery nobody holds, so the row decides whether it
+	// still needs sending.
 	row, err := e.loadDelivery(webhookDB, task.DeliveryID)
 	if err != nil {
 		e.log.Error(
@@ -662,9 +597,9 @@ func (e *Engine) processRetryTask(
 // else on this path reads the target row. Without this check a
 // deletion stops nothing: the timer keeps firing and keeps sending to
 // the destination the operator removed, for the whole remaining
-// backoff chain. Terminalising in the recovery and sweep paths alone
+// backoff chain. Terminalising in the recovery routine alone is not
-// is not enough, because those only see the delivery once nothing
+// enough, because it only sees the delivery once nothing holds it in
-// holds it in memory — which is to say after a restart.
+// memory — which is to say after a restart.
 //
 // The worker already owns this delivery, so the terminal write happens
 // here directly, exactly as a target's own Deliver fails one. Claiming
@@ -712,7 +647,47 @@ func (e *Engine) abandonRetryForMissingTarget(
 	return true
 }
 
-func (e *Engine) recoverInFlight(ctx context.Context) {
+// runRecovery runs the recovery routine, recoverDeliveries, once when
+// the engine starts and then on every tick of the sweep, every
+// retrySweepInterval, until the engine stops.
+func (e *Engine) runRecovery(ctx context.Context) {
+	defer e.wg.Done()
+
+	ticker := time.NewTicker(retrySweepInterval)
+	defer ticker.Stop()
+
+	e.recoverDeliveries(ctx, true)
+
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-ticker.C:
+			e.recoverDeliveries(ctx, false)
+		}
+	}
+}
+
+// recoverDeliveries is the engine's one recovery routine: atStart is
+// true for its run when the engine starts and false on a tick of the
+// sweep.
+//
+// For every webhook it finds the pending and retrying deliveries the
+// engine is not working on, such as those a stop or a crash cut off, a
+// full channel dropped, or a failed bookkeeping write left behind. One
+// that already has a successful attempt is marked delivered. A retrying
+// one is scheduled after what is left of its backoff, or now when
+// nothing is left. A pending one goes to a worker now.
+//
+// Ownership keeps it off a delivery the engine is working on, has
+// queued, or holds a retry timer for, the same at start as on a tick:
+// every delivery it acts on is taken through the inflight set first.
+// See inflight.go.
+//
+// A run at start differs from a tick in which webhooks it opens (see
+// recoverWebhookDeliveries) and which pending deliveries it takes (see
+// recoverPendingDeliveries).
+func (e *Engine) recoverDeliveries(ctx context.Context, atStart bool) {
 	var webhookIDs []string
 
 	err := e.database.DB().
@@ -734,18 +709,27 @@ func (e *Engine) recoverInFlight(ctx context.Context) {
 		default:
 		}
 
-		// Opened even when its file is missing, so that a lost
+		e.recoverWebhookDeliveries(ctx, webhookID, atStart)
-		// database is reported at start, not when the webhook next
-		// receives an event, which for a quiet webhook may be never.
-		e.recoverWebhookDeliveries(ctx, webhookID)
 	}
 }
 
+// recoverWebhookDeliveries runs the recovery routine over one webhook.
+//
+// At start the webhook's database is opened even when its file is
+// missing, so that a lost database is reported at start, not when the
+// webhook next receives an event, which for a quiet webhook may be
+// never. A tick leaves a missing file alone rather than create one: a
+// webhook being created has its row saved a moment before its file,
+// and a tick in between would report that file as lost.
 func (e *Engine) recoverWebhookDeliveries(
-	ctx context.Context, webhookID string,
+	ctx context.Context, webhookID string, atStart bool,
 ) {
-	// The web interface is already serving, so the webhook may have
+	if !atStart && !e.dbManager.DBExists(webhookID) {
-	// been deleted since the list was read. Opening its database then
+		return
+	}
+
+	// The web interface is serving, so the webhook may have been
+	// deleted since the list was read. Opening its database then
 	// would create the file again after the delete removed it.
 	stillExists := func() (bool, error) {
 		var count int64
@@ -777,16 +761,18 @@ func (e *Engine) recoverWebhookDeliveries(
 	}
 
 	e.recoverPendingDeliveries(
-		ctx, webhookDB, webhookID,
+		ctx, webhookDB, webhookID, atStart,
 	)
 
 	e.recoverRetryingDeliveries(
-		webhookDB, webhookID,
+		ctx, webhookDB, webhookID,
 	)
 }
 
+// recoverRetryingDeliveries recovers every retrying delivery of one
+// webhook, at start and on a tick alike.
 func (e *Engine) recoverRetryingDeliveries(
-	webhookDB *gorm.DB, webhookID string,
+	ctx context.Context, webhookDB *gorm.DB, webhookID string,
 ) {
 	var retrying []database.Delivery
 
@@ -813,6 +799,12 @@ func (e *Engine) recoverRetryingDeliveries(
 	)
 
 	for i := range retrying {
+		select {
+		case <-ctx.Done():
+			return
+		default:
+		}
+
 		if _, ok := settled[retrying[i].ID]; ok {
 			continue
 		}
@@ -824,8 +816,9 @@ func (e *Engine) recoverRetryingDeliveries(
 }
 
 // recoverSingleRetry hands an orphaned retrying delivery back
-// to its target to recompute the remaining backoff, then
+// to its target to work out what is left of its backoff, then
-// reschedules it. Targets that do not own durable retries
+// schedules its next attempt after that, or now when nothing is
+// left. Targets that do not own durable retries
 // (fire-and-forget) never produce retrying deliveries, so a
 // delivery found in that state has had its target's type
 // changed underneath it and is terminally failed.
@@ -873,6 +866,19 @@ func (e *Engine) recoverSingleRetry(
 		webhookDB, d.ID, attemptNum,
 	)
 
+	// Taken before the event is read, so that a delivery the engine
+	// already holds, most often one waiting out its backoff on a
+	// timer, costs a tick no read of its body.
+	if !e.takeForRedispatch(
+		webhookDB, d.ID, database.DeliveryStatusRetrying,
+	) {
+		return
+	}
+
+	// ScheduleRetry takes a reference of its own before it returns,
+	// and that one keeps the delivery owned through the backoff.
+	defer e.inflight.release(d.ID)
+
 	event, err := e.loadEvent(webhookDB, d.EventID)
 	if err != nil {
 		e.log.Error(
@@ -886,13 +892,9 @@ func (e *Engine) recoverSingleRetry(
 		return
 	}
 
-	task := buildRecoveryTask(
+	e.ScheduleRetry(buildRecoveryTask(
 		d, webhookID, &event, &target, attemptNum+1,
-	)
+	), remaining)
-
-	if !e.rescheduleRecovered(webhookDB, task, remaining) {
-		return
-	}
 
 	e.log.Info(
 		"recovering retrying delivery",
@@ -903,28 +905,54 @@ func (e *Engine) recoverSingleRetry(
 	)
 }
 
+// recoverPendingDeliveries recovers the pending deliveries of one
+// webhook: it marks delivered those that already have a successful
+// attempt and sends the rest.
+//
+// A delivery is created pending and leaves that state only when its
+// outcome is written, so a pending row the engine does not own is one
+// it stopped working on before then: for example one whose bookkeeping
+// write failed, whose attempt a stop cut off, that was still queued
+// when the engine last stopped, whose task was dropped because the
+// delivery channel was full (by Notify or by queueRecovered), or whose
+// worker could not open the webhook's database.
+//
+// At start every pending delivery is taken, however recent, so one a
+// stop cut off moments ago is sent again now. A tick takes only those
+// untouched for pendingSweepMinAge, at most pendingSweepBatch of them.
+// The age bound is not what keeps a tick off live work: a delivery
+// waiting in deliveryCh is pending and arbitrarily old. Ownership is,
+// checked per delivery in takeForRedispatch. See inflight.go.
 func (e *Engine) recoverPendingDeliveries(
 	ctx context.Context,
 	webhookDB *gorm.DB,
 	webhookID string,
+	atStart bool,
 ) {
+	query := webhookDB.Where(
+		"status = ?", database.DeliveryStatusPending,
+	)
+
+	if !atStart {
+		query = query.
+			Where(
+				"updated_at < ?",
+				time.Now().Add(-pendingSweepMinAge),
+			).
+			Limit(pendingSweepBatch)
+	}
+
 	var deliveries []database.Delivery
 
 	// No Preload: event bodies are read one at a time in
 	// sendRecoveredDeliveries, and only for the deliveries actually
 	// being sent.
-	result := webhookDB.
+	err := query.Find(&deliveries).Error
-		Where(
+	if err != nil {
-			"status = ?",
-			database.DeliveryStatusPending,
-		).
-		Find(&deliveries)
-
-	if result.Error != nil {
 		e.log.Error(
-			"failed to query pending deliveries",
+			"failed to query pending deliveries for recovery",
 			"webhook_id", webhookID,
-			"error", result.Error,
+			"error", err,
 		)
 
 		return
@@ -940,21 +968,6 @@ func (e *Engine) recoverPendingDeliveries(
 		"count", len(deliveries),
 	)
 
-	e.recoverPendingBatch(
-		ctx, webhookDB, webhookID, deliveries,
-	)
-}
-
-// recoverPendingBatch settles every delivery in the batch that was
-// already delivered, and re-dispatches only the rest. Both the
-// restart-time recovery and the periodic sweep go through it, so a
-// pending delivery is treated the same however it was found.
-func (e *Engine) recoverPendingBatch(
-	ctx context.Context,
-	webhookDB *gorm.DB,
-	webhookID string,
-	deliveries []database.Delivery,
-) {
 	targetMap := e.loadTargetMap(deliveries)
 
 	settled := e.reconcileDelivered(
@@ -982,11 +995,11 @@ func (e *Engine) recoverPendingBatch(
 // wire I/O happened and was recorded, and all that is missing is the
 // status.
 //
-// Every recovery path runs this, not only the pending one. A delivery
+// The recovery routine runs this for retrying deliveries as well as
-// abandoned at retrying can hold a successful result just as a pending
+// pending ones. A delivery abandoned at retrying can hold a successful
-// one can — a second attempt that reached the receiver and whose status
+// result just as a pending one can — a second attempt that reached the
-// write then failed sits at retrying with success recorded — and
+// receiver and whose status write then failed sits at retrying with
-// re-sending it is the same duplicate.
+// success recorded — and re-sending it is the same duplicate.
 //
 // Deliveries whose result row itself never landed are not in the
 // returned set and are re-sent, recorded as the further attempt they
@@ -1073,247 +1086,8 @@ func (e *Engine) reconcileDelivered(
 	return settled
 }
 
-func (e *Engine) retrySweep(ctx context.Context) {
-	defer e.wg.Done()
-
-	ticker := time.NewTicker(retrySweepInterval)
-	defer ticker.Stop()
-
-	for {
-		select {
-		case <-ctx.Done():
-			return
-		case <-ticker.C:
-			e.sweepOrphanedRetries(ctx)
-		}
-	}
-}
-
-func (e *Engine) sweepOrphanedRetries(
-	ctx context.Context,
-) {
-	var webhookIDs []string
-
-	err := e.database.DB().
-		Model(&database.Webhook{}).
-		Pluck("id", &webhookIDs).Error
-	if err != nil {
-		e.log.Error(
-			"retry sweep: failed to query webhook IDs",
-			"error", err,
-		)
-
-		return
-	}
-
-	for _, webhookID := range webhookIDs {
-		select {
-		case <-ctx.Done():
-			return
-		default:
-		}
-
-		if !e.dbManager.DBExists(webhookID) {
-			continue
-		}
-
-		e.sweepWebhookRetries(ctx, webhookID)
-	}
-}
-
-func (e *Engine) sweepWebhookRetries(
-	ctx context.Context, webhookID string,
-) {
-	webhookDB, err := e.dbManager.GetDB(webhookID)
-	if err != nil {
-		e.log.Error(
-			"retry sweep: failed to get webhook database",
-			"webhook_id", webhookID,
-			"error", err,
-		)
-
-		return
-	}
-
-	var retrying []database.Delivery
-
-	err = webhookDB.
-		Where(
-			"status = ?",
-			database.DeliveryStatusRetrying,
-		).
-		Find(&retrying).Error
-	if err != nil {
-		e.log.Error(
-			"retry sweep: "+
-				"failed to query retrying deliveries",
-			"webhook_id", webhookID,
-			"error", err,
-		)
-
-		return
-	}
-
-	settled := e.reconcileDelivered(
-		webhookDB, webhookID, retrying,
-		e.loadTargetMap(retrying),
-	)
-
-	for i := range retrying {
-		select {
-		case <-ctx.Done():
-			return
-		default:
-		}
-
-		if _, ok := settled[retrying[i].ID]; ok {
-			continue
-		}
-
-		e.sweepSingleRetry(
-			webhookDB, webhookID, &retrying[i],
-		)
-	}
-
-	e.sweepWebhookPending(ctx, webhookDB, webhookID)
-}
-
-// sweepWebhookPending recovers deliveries stranded at pending.
-//
-// A delivery is created pending and leaves that state only when its
-// outcome is written, so a pending row the engine does not own is one
-// whose bookkeeping write failed — the state that used to sit there
-// until a restart, and then produce a duplicate at the receiver. The
-// sweep gives it the same reconcile-then-dispatch treatment restart
-// recovery gets, so it costs a minute rather than an operator
-// noticing.
-//
-// What keeps the sweep off live work is ownership, checked per
-// delivery in takeForRedispatch, not the age bound in this query.
-// A delivery waiting in deliveryCh is pending and arbitrarily old —
-// the channel holds 10000 tasks and 10 workers drain it — so
-// reasoning from the row's age alone re-sends it. See inflight.go.
-func (e *Engine) sweepWebhookPending(
-	ctx context.Context,
-	webhookDB *gorm.DB,
-	webhookID string,
-) {
-	var pending []database.Delivery
-
-	err := webhookDB.
-		Where(
-			"status = ? AND updated_at < ?",
-			database.DeliveryStatusPending,
-			time.Now().Add(-pendingSweepMinAge),
-		).
-		Limit(pendingSweepBatch).
-		Find(&pending).Error
-	if err != nil {
-		e.log.Error(
-			"retry sweep: "+
-				"failed to query pending deliveries",
-			"webhook_id", webhookID,
-			"error", err,
-		)
-
-		return
-	}
-
-	if len(pending) == 0 {
-		return
-	}
-
-	e.log.Info(
-		"retry sweep: recovering stranded pending deliveries",
-		"webhook_id", webhookID,
-		"count", len(pending),
-	)
-
-	e.recoverPendingBatch(ctx, webhookDB, webhookID, pending)
-}
-
-// sweepSingleRetry re-enqueues an orphaned retrying delivery
-// whose backoff window has elapsed, delegating the backoff
-// decision to the delivery's target. A delivery whose target
-// no longer owns durable retries is terminally failed.
-func (e *Engine) sweepSingleRetry(
-	webhookDB *gorm.DB,
-	webhookID string,
-	d *database.Delivery,
-) {
-	target, err := e.loadTarget(d.TargetID)
-	if err != nil {
-		// Deleted is terminal, unreadable is not; see
-		// recoverSingleRetry.
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			e.failMissingTarget(webhookDB, webhookID, d)
-
-			return
-		}
-
-		e.log.Error(
-			"retry sweep: failed to load target",
-			"delivery_id", d.ID,
-			"target_id", d.TargetID,
-			"error", err,
-		)
-
-		return
-	}
-
-	rs, ok := e.targets[target.Type].(rescheduler)
-	if !ok {
-		e.failUnretryableRetry(
-			webhookDB, webhookID, d, &target,
-		)
-
-		return
-	}
-
-	attemptNum := e.countAttempts(webhookDB, d.ID)
-
-	if !rs.backoffElapsed(
-		webhookDB, d.ID, attemptNum,
-	) {
-		return
-	}
-
-	event, err := e.loadEvent(webhookDB, d.EventID)
-	if err != nil {
-		e.log.Error(
-			"retry sweep: failed to load event",
-			"delivery_id", d.ID,
-			"event_id", d.EventID,
-			"error", err,
-		)
-
-		return
-	}
-
-	task := buildRecoveryTask(
-		d, webhookID, &event, &target, attemptNum+1,
-	)
-
-	if !e.redispatch(
-		e.retryCh, webhookDB, task,
-		database.DeliveryStatusRetrying,
-	) {
-		return
-	}
-
-	e.log.Info(
-		"retry sweep: "+
-			"recovered orphaned retrying delivery",
-		"delivery_id", d.ID,
-		"webhook_id", webhookID,
-		"attempt", attemptNum+1,
-	)
-}
-
 // failUnretryableRetry terminally fails an orphaned retrying
-// delivery whose target type no longer supports retries. Both
+// delivery whose target type no longer supports retries.
-// restart recovery and the periodic sweep call it, so the
-// terminal transition exists once.
 //
 // This is only reachable when a target's type has been changed
 // out from under an in-flight retrying delivery (or the type is
@@ -1361,8 +1135,8 @@ func (e *Engine) failUnretryableRetry(
 }
 
 // failMissingTarget terminally fails a recovered delivery, pending or
-// retrying, whose target row is gone. Restart recovery and the periodic
+// retrying, whose target row is gone. The recovery routine calls it for
-// sweep call it for both statuses, so the transition exists once.
+// both statuses.
 //
 // Until it existed those paths logged the failed lookup and moved on,
 // which left the delivery where it was for the life of the database and
@@ -1701,8 +1475,11 @@ func writeDeliveryStatus(
 			database.DeliveryStatusFailed,
 		}).
 		Updates(map[string]any{
-			"status":      status,
+			"status": status,
-			"finished_at": time.Now(),
+			// GORM's clock, the one that stamps created_at. A bare
+			// time.Now() carries a monotonic clock reading, which the
+			// driver would store as an " m=+…" suffix.
+			"finished_at": tx.NowFunc(),
 		})
 	if res.Error != nil || res.RowsAffected == 0 {
 		return res.Error
@@ -1766,10 +1543,10 @@ func buildEventFromTask(task *Task) database.Event {
 
 func buildTargetFromTask(task *Task) database.Target {
 	target := database.Target{
-		Name:       task.TargetName,
+		Name:        task.TargetName,
-		Type:       task.TargetType,
+		Type:        task.TargetType,
-		Config:     task.TargetConfig,
+		Config:      task.TargetConfig,
-		MaxRetries: task.MaxRetries,
+		MaxAttempts: task.MaxAttempts,
 	}
 
 	target.ID = task.TargetID
@@ -1884,11 +1661,11 @@ func (e *Engine) countAttempts(
 // answer cannot go stale between asking and acting.
 //
 // Stamping updated_at is the same statement, and it is a cadence
-// control rather than a claim: the pending sweep selects on that
+// control rather than a claim: a tick of the sweep selects pending
-// column, so a delivery handed out now is not selected again on the
+// deliveries on that column, so one handed out now is not selected
-// next tick a minute later but after pendingSweepMinAge. A delivery
+// again on the next tick a minute later but after pendingSweepMinAge.
-// the database refuses to settle is therefore retried on that
+// A delivery the database refuses to settle is therefore retried on
-// interval instead of every tick.
+// that interval instead of every tick.
 //
 // A failed write is a refusal. It means the database is not accepting
 // writes, which is the condition that stranded the delivery in the
@@ -1906,12 +1683,13 @@ func (e *Engine) takeForRedispatch(
 		return false
 	}
 
+	// GORM's clock, as writeDeliveryStatus explains.
 	res := webhookDB.
 		Model(&database.Delivery{}).
 		Where(
 			"id = ? AND status = ?", deliveryID, eligible,
 		).
-		UpdateColumn("updated_at", time.Now())
+		UpdateColumn("updated_at", webhookDB.NowFunc())
 
 	if res.Error != nil {
 		e.log.Error(
@@ -1935,14 +1713,11 @@ func (e *Engine) takeForRedispatch(
 	return true
 }
 
-// queueRecovered puts an owned delivery's task on a worker channel,
+// queueRecovered puts an owned pending delivery's task on the delivery
-// dropping the ownership the gate took if it does not fit.
+// channel, dropping the ownership the gate took if it does not fit.
-func (e *Engine) queueRecovered(
+func (e *Engine) queueRecovered(task Task) {
-	ch chan<- Task, task Task,
-) bool {
 	select {
-	case ch <- task:
+	case e.deliveryCh <- task:
-		return true
 	default:
 		e.inflight.release(task.DeliveryID)
 		e.log.Warn(
@@ -1951,53 +1726,9 @@ func (e *Engine) queueRecovered(
 			"delivery_id", task.DeliveryID,
 			"webhook_id", task.WebhookID,
 		)
-
-		return false
 	}
 }
 
-// redispatch hands a recovered delivery to a worker channel through
-// takeForRedispatch, and reports whether the task was queued.
-func (e *Engine) redispatch(
-	ch chan<- Task,
-	webhookDB *gorm.DB,
-	task Task,
-	eligible database.DeliveryStatus,
-) bool {
-	if !e.takeForRedispatch(
-		webhookDB, task.DeliveryID, eligible,
-	) {
-		return false
-	}
-
-	return e.queueRecovered(ch, task)
-}
-
-// rescheduleRecovered hands an orphaned retrying delivery back to the
-// retry timer, through the same gate. It reports whether the delivery
-// was rescheduled.
-//
-// The reference taken by the gate is dropped as soon as ScheduleRetry
-// has taken its own, which it does before returning: what keeps the
-// delivery owned through the backoff window is ScheduleRetry's
-// reference, not this one.
-func (e *Engine) rescheduleRecovered(
-	webhookDB *gorm.DB, task Task, delay time.Duration,
-) bool {
-	if !e.takeForRedispatch(
-		webhookDB, task.DeliveryID,
-		database.DeliveryStatusRetrying,
-	) {
-		return false
-	}
-
-	defer e.inflight.release(task.DeliveryID)
-
-	e.ScheduleRetry(task, delay)
-
-	return true
-}
-
 // countAttemptsBatch counts the recorded attempts of every delivery
 // in a batch with one grouped query, keyed by delivery id. Deliveries
 // with no attempts are simply absent from the result, which reads back
@@ -2024,7 +1755,7 @@ func (e *Engine) countAttemptsBatch(
 	// One delivery id per recorded attempt, tallied here rather than
 	// grouped in SQL: internal/gormlog forbids (*gorm.DB).Scan, which
 	// a GROUP BY into a struct would need, and an attempt row per
-	// delivery is bounded by the target's MaxRetries.
+	// delivery is bounded by the target's MaxAttempts.
 	var attemptIDs []string
 
 	err := webhookDB.
@@ -2102,7 +1833,7 @@ func buildRecoveryTask(
 		TargetName:   target.Name,
 		TargetType:   target.Type,
 		TargetConfig: target.Config,
-		MaxRetries:   target.MaxRetries,
+		MaxAttempts:  target.MaxAttempts,
 		Method:       event.Method,
 		RawQuery:     event.RawQuery,
 		Headers:      event.Headers,
@@ -2255,6 +1986,6 @@ func (e *Engine) sendRecoveredDeliveries(
 			attempts[deliveries[i].ID]+1,
 		)
 
-		e.queueRecovered(e.deliveryCh, task)
+		e.queueRecovered(task)
 	}
 }

internal/delivery/engine_integration_test.go

@@ -170,7 +170,7 @@ func iTask(
 	d database.Delivery,
 	event database.Event,
 	webhookID, targetID, name, config string,
-	maxRetries, attemptNum int,
+	maxAttempts, attemptNum int,
 	body *string,
 ) delivery.Task {
 	return delivery.Task{
@@ -181,7 +181,7 @@ func iTask(
 		TargetName:   name,
 		TargetType:   database.TargetTypeHTTP,
 		TargetConfig: config,
-		MaxRetries:   maxRetries,
+		MaxAttempts:  maxAttempts,
 		Method:       event.Method,
 		Headers:      event.Headers,
 		ContentType:  event.ContentType,
@@ -242,7 +242,7 @@ func TestProcessNewTask_InlineBody(t *testing.T) {
 	cfg := iHTTPConfig(ts.URL)
 	task := iTask(
 		d, event, s.WebhookID, targetID,
-		"test-target", cfg, 0, 1, &bodyStr,
+		"test-target", cfg, 1, 1, &bodyStr,
 	)
 
 	s.Engine.ExportProcessNewTask(
@@ -293,7 +293,7 @@ func TestProcessNewTask_LargeBody_FetchFromDB(
 	cfg := iHTTPConfig(ts.URL)
 	task := iTask(
 		d, event, s.WebhookID, targetID,
-		"test-large", cfg, 0, 1, nil,
+		"test-large", cfg, 1, 1, nil,
 	)
 
 	s.Engine.ExportProcessNewTask(
@@ -320,7 +320,7 @@ func TestProcessNewTask_InvalidWebhookID(t *testing.T) {
 		TargetName:   "test",
 		TargetType:   database.TargetTypeHTTP,
 		TargetConfig: iHTTPConfig("http://localhost:9999"),
-		MaxRetries:   0,
+		MaxAttempts:  1,
 		Body:         nil,
 		AttemptNum:   1,
 	}
@@ -506,7 +506,7 @@ func TestWorkerLifecycle_StartStop(t *testing.T) {
 	task := iTask(
 		d, event, s.WebhookID, targetID,
 		"lifecycle-test", "",
-		0, 1, &bodyStr,
+		1, 1, &bodyStr,
 	)
 	task.TargetType = database.TargetTypeLog
 
@@ -645,7 +645,7 @@ func TestRecoverPendingDeliveries(t *testing.T) {
 
 	iCreateTarget(t, s.MainDB, targetID,
 		s.WebhookID, "recovery-target",
-		database.TargetTypeLog, "", 0,
+		database.TargetTypeLog, "", 1,
 	)
 
 	iSeedPendingDeliveries(
@@ -659,7 +659,7 @@ func TestRecoverPendingDeliveries(t *testing.T) {
 
 	s.Engine.ExportRecoverPendingDeliveries(
 		context.Background(), s.WebhookDB,
-		s.WebhookID,
+		s.WebhookID, atStart,
 	)
 
 	for i := range 3 {
@@ -686,17 +686,17 @@ func iCreateTarget(
 	targetID, webhookID, name string,
 	targetType database.TargetType,
 	config string,
-	maxRetries int,
+	maxAttempts int,
 ) {
 	t.Helper()
 
 	target := database.Target{
-		WebhookID:  webhookID,
+		WebhookID:   webhookID,
-		Name:       name,
+		Name:        name,
-		Type:       targetType,
+		Type:        targetType,
-		Active:     true,
+		Active:      true,
-		Config:     config,
+		Config:      config,
-		MaxRetries: maxRetries,
+		MaxAttempts: maxAttempts,
 	}
 	target.ID = targetID
 
@@ -756,7 +756,7 @@ func TestRecoverWebhookDeliveries_RetryingDeliveries(
 	)
 
 	s.Engine.ExportRecoverWebhookDeliveries(
-		context.Background(), s.WebhookID,
+		context.Background(), s.WebhookID, atStart,
 	)
 
 	select {
@@ -880,7 +880,7 @@ func TestRecoverSingleRetry_TypeNoLongerRetries(
 	)
 
 	s.Engine.ExportRecoverWebhookDeliveries(
-		context.Background(), s.WebhookID,
+		context.Background(), s.WebhookID, atStart,
 	)
 
 	iAssertTerminallyFailed(
@@ -888,7 +888,7 @@ func TestRecoverSingleRetry_TypeNoLongerRetries(
 	)
 }
 
-func TestSweepSingleRetry_TypeNoLongerRetries(
+func TestRecoverSingleRetry_OnTick_TypeNoLongerRetries(
 	t *testing.T,
 ) {
 	t.Parallel()
@@ -903,8 +903,8 @@ func TestSweepSingleRetry_TypeNoLongerRetries(
 		t, s, database.TargetTypeDatabase,
 	)
 
-	s.Engine.ExportSweepWebhookRetries(
+	s.Engine.ExportRecoverWebhookDeliveries(
-		context.Background(), s.WebhookID,
+		context.Background(), s.WebhookID, onTick,
 	)
 
 	iAssertTerminallyFailed(
@@ -955,8 +955,8 @@ func TestFailUnretryableRetry_WritesNoTargetRow(
 
 	iSeedFailedResult(t, s.WebhookDB, d.ID)
 
-	s.Engine.ExportSweepWebhookRetries(
+	s.Engine.ExportRecoverWebhookDeliveries(
-		context.Background(), s.WebhookID,
+		context.Background(), s.WebhookID, onTick,
 	)
 
 	iAssertStatus(t, s.WebhookDB, d.ID,
@@ -987,13 +987,13 @@ func TestRecoverSingleRetry_UnknownTargetType(
 	deliveryID := iSeedRetryingWithType(t, s, unknown)
 
 	s.Engine.ExportRecoverWebhookDeliveries(
-		context.Background(), s.WebhookID,
+		context.Background(), s.WebhookID, atStart,
 	)
 
 	iAssertTerminallyFailed(t, s, deliveryID, unknown)
 }
 
-func TestSweepSingleRetry_UnknownTargetType(
+func TestRecoverSingleRetry_OnTick_UnknownTargetType(
 	t *testing.T,
 ) {
 	t.Parallel()
@@ -1008,8 +1008,8 @@ func TestSweepSingleRetry_UnknownTargetType(
 
 	deliveryID := iSeedRetryingWithType(t, s, unknown)
 
-	s.Engine.ExportSweepWebhookRetries(
+	s.Engine.ExportRecoverWebhookDeliveries(
-		context.Background(), s.WebhookID,
+		context.Background(), s.WebhookID, onTick,
 	)
 
 	iAssertTerminallyFailed(t, s, deliveryID, unknown)
@@ -1051,19 +1051,19 @@ func iCreateWebhook(
 	require.NoError(t, mainDB.Create(&webhook).Error)
 }
 
-// --- recoverInFlight Tests ---
+// --- recoverDeliveries Tests ---
 
-func TestRecoverInFlight_NoWebhooks(t *testing.T) {
+func TestRecoverDeliveries_NoWebhooks(t *testing.T) {
 	t.Parallel()
 
 	s := newISetup(t)
 
-	s.Engine.ExportRecoverInFlight(
+	s.Engine.ExportRecoverDeliveries(
-		context.Background(),
+		context.Background(), atStart,
 	)
 }
 
-func TestRecoverInFlight_WithPendingDeliveries(
+func TestRecoverDeliveries_WithPendingDeliveries(
 	t *testing.T,
 ) {
 	t.Parallel()
@@ -1077,7 +1077,7 @@ func TestRecoverInFlight_WithPendingDeliveries(
 
 	iCreateTarget(t, s.MainDB, targetID,
 		s.WebhookID, "recover-target",
-		database.TargetTypeLog, "", 0,
+		database.TargetTypeLog, "", 1,
 	)
 
 	event := iSeedEvent(
@@ -1090,8 +1090,8 @@ func TestRecoverInFlight_WithPendingDeliveries(
 		database.DeliveryStatusPending,
 	)
 
-	s.Engine.ExportRecoverInFlight(
+	s.Engine.ExportRecoverDeliveries(
-		context.Background(),
+		context.Background(), atStart,
 	)
 
 	select {
@@ -1102,16 +1102,16 @@ func TestRecoverInFlight_WithPendingDeliveries(
 			database.TargetTypeLog, task.TargetType,
 		)
 	case <-time.After(2 * time.Second):
-		t.Fatal("expected task from recoverInFlight")
+		t.Fatal("expected task from recovery at start")
 	}
 }
 
-// TestRecoverInFlight_ReportsAMissingWebhookDatabase covers a webhook
+// TestRecoverDeliveries_ReportsAMissingWebhookDatabase covers a webhook
-// whose database file is gone, after a partial restore say. Restart
+// whose database file is gone, after a partial restore say. Recovery at
-// recovery opens every webhook's database, so the empty one made in its
+// start opens every webhook's database, so the empty one made in its
 // place is reported at start, naming the file
 // (https://git.eeqj.de/sneak/webhooker/issues/290).
-func TestRecoverInFlight_ReportsAMissingWebhookDatabase(t *testing.T) {
+func TestRecoverDeliveries_ReportsAMissingWebhookDatabase(t *testing.T) {
 	t.Parallel()
 
 	mainDB := iMainDB(t)
@@ -1131,7 +1131,7 @@ func TestRecoverInFlight_ReportsAMissingWebhookDatabase(t *testing.T) {
 		&http.Client{Timeout: 5 * time.Second}, 1,
 	)
 
-	engine.ExportRecoverInFlight(context.Background())
+	engine.ExportRecoverDeliveries(context.Background(), atStart)
 
 	assert.Contains(
 		t, logs.String(),
@@ -1140,10 +1140,11 @@ func TestRecoverInFlight_ReportsAMissingWebhookDatabase(t *testing.T) {
 	)
 }
 
-// TestRecoverInFlight_SkipsAWebhookDeletedAfterTheListIsRead covers a
+// TestRecoverDeliveries_SkipsAWebhookDeletedAfterTheListIsRead covers a
-// webhook deleted from the web interface while restart recovery runs.
+// webhook deleted from the web interface while the recovery routine
-// Its database file is gone, and recovery must not create it again.
+// runs. Its database file is gone, and recovery must not create it
-func TestRecoverInFlight_SkipsAWebhookDeletedAfterTheListIsRead(
+// again.
+func TestRecoverDeliveries_SkipsAWebhookDeletedAfterTheListIsRead(
 	t *testing.T,
 ) {
 	t.Parallel()
@@ -1179,7 +1180,7 @@ func TestRecoverInFlight_SkipsAWebhookDeletedAfterTheListIsRead(
 		&http.Client{Timeout: 5 * time.Second}, 1,
 	)
 
-	engine.ExportRecoverInFlight(context.Background())
+	engine.ExportRecoverDeliveries(context.Background(), atStart)
 
 	require.True(t, deleted)
 	assert.False(t, dbMgr.DBExists(webhookID))
@@ -1232,7 +1233,7 @@ func TestDeliverHTTP_CustomTargetHeaders(t *testing.T) {
 	task := iTask(
 		d, event, s.WebhookID, targetID,
 		"auth-target", string(cfgJSON),
-		0, 1, &bodyStr,
+		1, 1, &bodyStr,
 	)
 
 	s.Engine.ExportProcessNewTask(
@@ -1277,7 +1278,7 @@ func TestDeliverHTTP_TargetTimeout(t *testing.T) {
 
 	task, d := iHTTPTaskAndDelivery(
 		event, del, "timeout-target",
-		string(cfgJSON), 0, 1,
+		string(cfgJSON), 1, 1,
 	)
 
 	e.ExportDeliverHTTP(context.TODO(), db, d, task)
@@ -1339,7 +1340,7 @@ func TestDeliverHTTP_CutsStoredResponseAtMaxBodyLog(
 	bodyStr := event.Body
 	task := iTask(
 		del, event, s.WebhookID, targetID,
-		"cut-target", cfgJSON, 0, 1, &bodyStr,
+		"cut-target", cfgJSON, 1, 1, &bodyStr,
 	)
 
 	s.Engine.ExportProcessNewTask(context.TODO(), &task)
@@ -1403,7 +1404,7 @@ func iHTTPTaskAndDelivery(
 	event database.Event,
 	del database.Delivery,
 	name, config string,
-	maxRetries, attemptNum int,
+	maxAttempts, attemptNum int,
 ) (*delivery.Task, *database.Delivery) {
 	task := &delivery.Task{
 		DeliveryID:   del.ID,
@@ -1413,7 +1414,7 @@ func iHTTPTaskAndDelivery(
 		TargetName:   name,
 		TargetType:   database.TargetTypeHTTP,
 		TargetConfig: config,
-		MaxRetries:   maxRetries,
+		MaxAttempts:  maxAttempts,
 		AttemptNum:   attemptNum,
 	}
 
@@ -1423,9 +1424,10 @@ func iHTTPTaskAndDelivery(
 		Status:   database.DeliveryStatusPending,
 		Event:    event,
 		Target: database.Target{
-			Name:   name,
+			Name:        name,
-			Type:   database.TargetTypeHTTP,
+			Type:        database.TargetTypeHTTP,
-			Config: config,
+			Config:      config,
+			MaxAttempts: maxAttempts,
 		},
 	}
 	d.ID = del.ID
@@ -1466,7 +1468,7 @@ func TestDeliverHTTP_InvalidConfig(t *testing.T) {
 	)
 
 	task, d := iHTTPTaskAndDelivery(
-		event, del, "bad-config", `not-json`, 0, 1,
+		event, del, "bad-config", `not-json`, 1, 1,
 	)
 
 	e.ExportDeliverHTTP(context.TODO(), db, d, task)
@@ -1490,7 +1492,7 @@ func TestDeliverHTTP_InvalidConfigUnrecordedStaysPending(t *testing.T) {
 	)
 
 	task, d := iHTTPTaskAndDelivery(
-		event, del, "bad-config", `not-json`, 0, 1,
+		event, del, "bad-config", `not-json`, 1, 1,
 	)
 
 	require.NoError(t, db.Exec("drop table delivery_results").Error)

internal/delivery/engine_lifecycle_test.go

@@ -2,11 +2,16 @@ package delivery_test
 
 import (
 	"context"
+	"io"
+	"net/http"
+	"net/http/httptest"
 	"path/filepath"
+	"sync"
 	"testing"
 	"time"
 
 	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"go.uber.org/fx"
 	"gorm.io/gorm/clause"
@@ -94,7 +99,7 @@ func requireStopHookExpires(
 // the caller can drive OnStop too.
 //
 // Callers must not seed pending or retrying deliveries before
-// calling this: restart recovery enqueues those during startup,
+// calling this: the recovery routine's run at start enqueues those,
 // which would put work in the queue while the pool is still
 // racing its first select.
 func startEngineViaHook(
@@ -144,7 +149,7 @@ func seedLogTask(
 	bodyStr := event.Body
 	task := iTask(
 		d, event, s.WebhookID, targetID,
-		"hook-context-test", "", 0, 1, &bodyStr,
+		"hook-context-test", "", 1, 1, &bodyStr,
 	)
 	task.TargetType = database.TargetTypeLog
 
@@ -173,8 +178,8 @@ func TestEngine_WorkersOutliveStartHookContext(t *testing.T) {
 		_ = lc.hooks[0].OnStop(context.Background())
 	})
 
-	// Seeded only after the pool has settled, so restart recovery
+	// Seeded only after the pool has settled, so the recovery
-	// cannot enqueue it during startup.
+	// routine's run at start cannot enqueue it.
 	deliveryID, task := seedLogTask(t, s)
 
 	s.Engine.Notify([]delivery.Task{task})
@@ -272,19 +277,169 @@ func TestEngine_StopHookHonoursStopTimeout(t *testing.T) {
 	requireStopHookExpires(t, lc.hooks[0], "delivery engine")
 }
 
+// seedHeldDelivery gives the setup's webhook an http target with
+// maxAttempts, pointed at a receiver that keeps every request open until
+// the client gives up on it, and seeds one delivery to that target at
+// status. It returns the task that sends attempt attemptNum of the
+// delivery, and a channel that is closed when a request reaches the
+// receiver.
+func seedHeldDelivery(
+	t *testing.T,
+	s iSetup,
+	maxAttempts int,
+	status database.DeliveryStatus,
+	attemptNum int,
+) (delivery.Task, <-chan struct{}) {
+	t.Helper()
+
+	arrived := make(chan struct{})
+
+	var once sync.Once
+
+	ts := httptest.NewServer(http.HandlerFunc(
+		func(_ http.ResponseWriter, r *http.Request) {
+			// The server notices the client hanging up only once the
+			// body has been read; until then r.Context() never ends.
+			_, _ = io.Copy(io.Discard, r.Body)
+
+			once.Do(func() { close(arrived) })
+
+			<-r.Context().Done()
+		},
+	))
+	t.Cleanup(ts.Close)
+
+	cfg := iHTTPConfig(ts.URL)
+	targetID := uuid.New().String()
+
+	iCreateWebhook(t, s.MainDB, s.WebhookID, "hook")
+	iCreateTarget(
+		t, s.MainDB, targetID, s.WebhookID, "held",
+		database.TargetTypeHTTP, cfg, maxAttempts,
+	)
+
+	event := iSeedEvent(t, s.WebhookDB, s.WebhookID, `{"held":true}`)
+	d := iSeedDelivery(t, s.WebhookDB, event.ID, targetID, status)
+
+	bodyStr := event.Body
+
+	return iTask(
+		d, event, s.WebhookID, targetID, "held", cfg,
+		maxAttempts, attemptNum, &bodyStr,
+	), arrived
+}
+
+// stopDuringAttempt waits until the receiver holds an attempt open, then
+// stops the engine through its real stop hook.
+func stopDuringAttempt(
+	t *testing.T, lc *recordingLifecycle, arrived <-chan struct{},
+) {
+	t.Helper()
+
+	select {
+	case <-arrived:
+	case <-time.After(5 * time.Second):
+		t.Fatal("the delivery attempt never reached the receiver")
+	}
+
+	require.NoError(t, lc.hooks[0].OnStop(context.Background()))
+}
+
+// requireRequeued runs the recovery routine as at start on the stopped
+// engine and requires it to queue task's attempt again on ch.
+func requireRequeued(
+	t *testing.T, s iSetup, ch <-chan delivery.Task, task delivery.Task,
+) {
+	t.Helper()
+
+	s.Engine.ExportRecoverWebhookDeliveries(
+		context.Background(), s.WebhookID, atStart,
+	)
+
+	select {
+	case got := <-ch:
+		assert.Equal(t, task.DeliveryID, got.DeliveryID)
+		assert.Equal(t, task.AttemptNum, got.AttemptNum)
+	case <-time.After(5 * time.Second):
+		t.Fatal("recovery at start did not queue the delivery again")
+	}
+}
+
+// TestEngine_StopLeavesFireAndForgetAttemptPending is the regression
+// test for a stop that turned an attempt in flight into a terminal
+// failure. Stopping the engine cancels the request; for a target with
+// no retries that was the delivery's only attempt, recorded as failed
+// with "context canceled", and nothing ever sent it again. The
+// delivery must instead stay pending, with no result and no count in
+// the attempt metrics, for the recovery routine to send at the next
+// start.
+func TestEngine_StopLeavesFireAndForgetAttemptPending(t *testing.T) {
+	t.Parallel()
+
+	s := newISetup(t)
+	reg := mIsolate(t, s)
+	lc := startEngineViaHook(t, s.Engine)
+
+	task, arrived := seedHeldDelivery(
+		t, s, 1, database.DeliveryStatusPending, 1,
+	)
+
+	s.Engine.Notify([]delivery.Task{task})
+	stopDuringAttempt(t, lc, arrived)
+
+	iAssertStatus(
+		t, s.WebhookDB, task.DeliveryID, database.DeliveryStatusPending,
+	)
+	assert.Empty(t, iResults(t, s.WebhookDB, task.DeliveryID))
+	assert.Zero(t, mCounter(t, reg, mAttempts, mTypeHTTP))
+	assert.Zero(t, mHTTPDurations(t, reg))
+
+	requireRequeued(t, s, s.Engine.ExportDeliveryCh(), task)
+}
+
+// TestEngine_StopLeavesLastRetryAttemptRetrying is the same regression
+// for a target with retries, on its last attempt: the cancelled attempt
+// used to exhaust the retries and end the delivery failed. It must stay
+// retrying with only its earlier attempt recorded, and the recovery
+// routine at the next start must send that last attempt again.
+func TestEngine_StopLeavesLastRetryAttemptRetrying(t *testing.T) {
+	t.Parallel()
+
+	const maxAttempts = 2
+
+	s := newISetup(t)
+	lc := startEngineViaHook(t, s.Engine)
+
+	task, arrived := seedHeldDelivery(
+		t, s, maxAttempts, database.DeliveryStatusRetrying, maxAttempts,
+	)
+	iSeedFailedResult(t, s.WebhookDB, task.DeliveryID)
+
+	s.Engine.ExportScheduleRetry(task, 0)
+	stopDuringAttempt(t, lc, arrived)
+
+	iAssertStatus(
+		t, s.WebhookDB, task.DeliveryID, database.DeliveryStatusRetrying,
+	)
+	assert.Len(t, iResults(t, s.WebhookDB, task.DeliveryID), 1)
+
+	requireRequeued(t, s, s.Engine.ExportRetryCh(), task)
+}
+
 // deliverToArchive gives the setup's webhook a database target,
 // runs one delivery to it through the running engine, and returns
-// the target's ID and archive file path. The archive writer holds
+// the target's archive file path. The archive writer holds the file
-// the file open afterwards.
+// open afterwards.
-func deliverToArchive(t *testing.T, s iSetup) (string, string) {
+func deliverToArchive(t *testing.T, s iSetup) string {
 	t.Helper()
 
 	iCreateWebhook(t, s.MainDB, s.WebhookID, "hook")
 
 	tgt := &database.Target{
-		WebhookID: s.WebhookID,
+		WebhookID:   s.WebhookID,
-		Name:      "archive",
+		Name:        "archive",
-		Type:      database.TargetTypeDatabase,
+		Type:        database.TargetTypeDatabase,
+		MaxAttempts: 1,
 	}
 	require.NoError(
 		t, s.MainDB.Omit(clause.Associations).Create(tgt).Error,
@@ -298,7 +453,7 @@ func deliverToArchive(t *testing.T, s iSetup) (string, string) {
 
 	iWaitForDelivered(t, s.WebhookDB, deliveryID)
 
-	return tgt.ID, filepath.Join(
+	return filepath.Join(
 		filepath.Dir(s.DBMgr.DBPath(s.WebhookID)),
 		"archive-hook-archive-"+tgt.ID+".db",
 	)
@@ -317,7 +472,7 @@ func TestEngine_StopHookClosesArchives(t *testing.T) {
 
 	lc := startEngineViaHook(t, s.Engine)
 
-	_, path := deliverToArchive(t, s)
+	path := deliverToArchive(t, s)
 	require.FileExists(
 		t, path+"-wal",
 		"an open archive should have a -wal for the stop to remove",
@@ -351,21 +506,23 @@ func TestEngine_StopHookTimeoutLeavesArchivesOpen(t *testing.T) {
 
 	lc := startEngineViaHook(t, s.Engine)
 
-	targetID, _ := deliverToArchive(t, s)
+	path := deliverToArchive(t, s)
 
 	release := make(chan struct{})
 
 	t.Cleanup(func() {
 		close(release)
-		s.Engine.EvictWebhook(s.WebhookID)
+		s.Engine.ExportArchives().EvictWebhook(s.WebhookID)
 	})
 
 	s.Engine.ExportWedgeWorker(release)
 
 	requireStopHookExpires(t, lc.hooks[0], "delivery engine")
 
-	require.True(
+	// Closing the last handle on an archive removes its -wal, so a
-		t, s.Engine.ExportArchiveHandleOpen(targetID),
+	// -wal still there is a writer still open.
+	require.FileExists(
+		t, path+"-wal",
 		"a stop that timed out must not close archive writers",
 	)
 }

internal/delivery/engine_test.go

@@ -117,6 +117,18 @@ func seedDelivery(
 	return d
 }
 
+// assertStoredTime asserts that text, a timestamp as SQLite holds it,
+// is in the form GORM stores created_at in: the layout of
+// time.Time.String, with no " m=+…" monotonic clock reading after it.
+func assertStoredTime(t *testing.T, text string) {
+	t.Helper()
+
+	_, err := time.Parse(
+		"2006-01-02 15:04:05.999999999 -0700 MST", text,
+	)
+	assert.NoError(t, err, "stored as %q", text)
+}
+
 // httpDeliveryFixture holds the task and delivery needed
 // for HTTP delivery tests.
 type httpDeliveryFixture struct {
@@ -130,7 +142,7 @@ func buildHTTPFixture(
 	dlv database.Delivery,
 	event database.Event,
 	targetID, name, config string,
-	maxRetries, attemptNum int,
+	maxAttempts, attemptNum int,
 ) httpDeliveryFixture {
 	task := &delivery.Task{
 		DeliveryID:   dlv.ID,
@@ -140,7 +152,7 @@ func buildHTTPFixture(
 		TargetName:   name,
 		TargetType:   database.TargetTypeHTTP,
 		TargetConfig: config,
-		MaxRetries:   maxRetries,
+		MaxAttempts:  maxAttempts,
 		AttemptNum:   attemptNum,
 	}
 
@@ -150,10 +162,10 @@ func buildHTTPFixture(
 		Status:   dlv.Status,
 		Event:    event,
 		Target: database.Target{
-			Name:       name,
+			Name:        name,
-			Type:       database.TargetTypeHTTP,
+			Type:        database.TargetTypeHTTP,
-			Config:     config,
+			Config:      config,
-			MaxRetries: maxRetries,
+			MaxAttempts: maxAttempts,
 		},
 	}
 	d.ID = dlv.ID
@@ -265,7 +277,7 @@ func TestDeliverHTTP_Success(t *testing.T) {
 
 	cfg := newHTTPTargetConfig(ts.URL)
 	fix := buildHTTPFixture(
-		dlv, event, targetID, "test-http", cfg, 0, 1,
+		dlv, event, targetID, "test-http", cfg, 1, 1,
 	)
 
 	e.ExportDeliverHTTP(
@@ -312,7 +324,7 @@ func TestDeliverHTTP_Failure(t *testing.T) {
 	cfg := newHTTPTargetConfig(ts.URL)
 	fix := buildHTTPFixture(
 		dlv, event, targetID,
-		"test-http-fail", cfg, 0, 1,
+		"test-http-fail", cfg, 1, 1,
 	)
 
 	e.ExportDeliverHTTP(
@@ -461,14 +473,23 @@ func TestDeliverHTTP_WithRetries_Success(t *testing.T) {
 	)
 }
 
-func TestDeliverHTTP_MaxRetriesExhausted(t *testing.T) {
+// TestDeliverHTTP_MaxAttemptsExhausted proves a target with three
+// delivery attempts makes at most three: the first two failures are
+// retried, the third is final, and each attempt goes through the
+// target's circuit breaker.
+func TestDeliverHTTP_MaxAttemptsExhausted(t *testing.T) {
 	t.Parallel()
 
+	const maxAttempts = 3
+
 	db := testWebhookDB(t)
 
+	var requests atomic.Int32
+
 	ts := httptest.NewServer(
 		http.HandlerFunc(
 			func(w http.ResponseWriter, _ *http.Request) {
+				requests.Add(1)
 				w.WriteHeader(http.StatusBadGateway)
 			},
 		),
@@ -477,26 +498,103 @@ func TestDeliverHTTP_MaxRetriesExhausted(t *testing.T) {
 
 	e := testEngine(t, 1)
 	targetID := uuid.New().String()
+
+	// It opens on the last failure only if every attempt reached it.
+	cb := delivery.NewTestCircuitBreaker(maxAttempts, time.Minute)
+	e.ExportSetCircuitBreaker(targetID, cb)
+
 	event := seedEvent(t, db, `{"retry":"exhaust"}`)
 
 	dlv := seedDelivery(
 		t, db, event.ID, targetID,
-		database.DeliveryStatusRetrying,
+		database.DeliveryStatusPending,
+	)
+
+	cfg := newHTTPTargetConfig(ts.URL)
+	sched := &recordingScheduler{}
+
+	for attempt := 1; attempt <= maxAttempts; attempt++ {
+		fix := buildHTTPFixture(
+			dlv, event, targetID,
+			"test-http-exhaust", cfg, maxAttempts, attempt,
+		)
+
+		e.ExportDeliverHTTPWithScheduler(
+			context.TODO(), db, fix.Delivery, fix.Task, sched,
+		)
+	}
+
+	assert.Equal(t, int32(maxAttempts), requests.Load())
+	assert.Len(t, sched.delays, maxAttempts-1,
+		"every failure but the last should be retried",
+	)
+	assertDeliveryStatus(t, db, dlv.ID,
+		database.DeliveryStatusFailed,
+	)
+	assert.Equal(t, delivery.CircuitOpen, cb.State(),
+		"every attempt should be counted by the circuit breaker",
+	)
+}
+
+// TestDeliverHTTP_SingleAttemptSkipsCircuitBreaker proves a target
+// with one delivery attempt makes exactly that attempt, even while
+// its circuit breaker is open, and that a failure is final.
+func TestDeliverHTTP_SingleAttemptSkipsCircuitBreaker(t *testing.T) {
+	t.Parallel()
+
+	db := testWebhookDB(t)
+
+	var requests atomic.Int32
+
+	ts := httptest.NewServer(
+		http.HandlerFunc(
+			func(w http.ResponseWriter, _ *http.Request) {
+				requests.Add(1)
+				w.WriteHeader(http.StatusBadGateway)
+			},
+		),
+	)
+	defer ts.Close()
+
+	e := testEngine(t, 1)
+	targetID := uuid.New().String()
+
+	cb := e.ExportGetCircuitBreaker(targetID)
+
+	for range delivery.ExportDefaultFailureThreshold {
+		cb.RecordFailure()
+	}
+
+	require.Equal(t, delivery.CircuitOpen, cb.State())
+
+	event := seedEvent(t, db, `{"retry":"none"}`)
+
+	dlv := seedDelivery(
+		t, db, event.ID, targetID,
+		database.DeliveryStatusPending,
 	)
 
 	cfg := newHTTPTargetConfig(ts.URL)
 	fix := buildHTTPFixture(
 		dlv, event, targetID,
-		"test-http-exhaust", cfg, 3, 3,
+		"test-http-single", cfg, 1, 1,
+	)
+	sched := &recordingScheduler{}
+
+	e.ExportDeliverHTTPWithScheduler(
+		context.TODO(), db, fix.Delivery, fix.Task, sched,
 	)
 
-	e.ExportDeliverHTTP(
+	assert.Equal(t, int32(1), requests.Load(),
-		context.TODO(), db, fix.Delivery, fix.Task,
+		"the open circuit breaker should not hold the attempt back",
 	)
-
+	assert.Empty(t, sched.delays, "no retry should be scheduled")
 	assertDeliveryStatus(t, db, dlv.ID,
 		database.DeliveryStatusFailed,
 	)
+	assertDeliveryResult(
+		t, db, dlv.ID, false, http.StatusBadGateway,
+	)
 }
 
 func TestDeliverHTTP_SchedulesRetryOnFailure(
@@ -715,9 +813,10 @@ func seedConcurrencyTasks(
 			Status:   database.DeliveryStatusPending,
 			Event:    event,
 			Target: database.Target{
-				Name:   fmt.Sprintf("task-%d", i),
+				Name:        fmt.Sprintf("task-%d", i),
-				Type:   database.TargetTypeHTTP,
+				Type:        database.TargetTypeHTTP,
-				Config: targetCfg,
+				Config:      targetCfg,
+				MaxAttempts: 1,
 			},
 		}
 		tasks[i].ID = dlv.ID
@@ -729,7 +828,7 @@ func seedConcurrencyTasks(
 			TargetName:   tasks[i].Target.Name,
 			TargetType:   tasks[i].Target.Type,
 			TargetConfig: tasks[i].Target.Config,
-			MaxRetries:   0,
+			MaxAttempts:  1,
 			AttemptNum:   1,
 		}
 	}
@@ -1676,9 +1775,10 @@ func buildSlackDelivery(
 		Status:   dlv.Status,
 		Event:    event,
 		Target: database.Target{
-			Name:   name,
+			Name:        name,
-			Type:   database.TargetTypeSlack,
+			Type:        database.TargetTypeSlack,
-			Config: slackCfg,
+			Config:      slackCfg,
+			MaxAttempts: 1,
 		},
 	}
 	d.ID = dlv.ID
@@ -1862,9 +1962,10 @@ func TestDeliverSlack_InvalidConfig(t *testing.T) {
 		Status:   database.DeliveryStatusPending,
 		Event:    event,
 		Target: database.Target{
-			Name:   "test-slack-bad",
+			Name:        "test-slack-bad",
-			Type:   database.TargetTypeSlack,
+			Type:        database.TargetTypeSlack,
-			Config: `{"not_webhook_url":"missing"}`,
+			Config:      `{"not_webhook_url":"missing"}`,
+			MaxAttempts: 1,
 		},
 	}
 	d.ID = dlv.ID
@@ -1921,8 +2022,9 @@ func TestProcessDelivery_RoutesToSlack(t *testing.T) {
 	)
 
 	task := &delivery.Task{
-		DeliveryID: dlv.ID,
+		DeliveryID:  dlv.ID,
-		TargetType: database.TargetTypeSlack,
+		TargetType:  database.TargetTypeSlack,
+		MaxAttempts: 1,
 	}
 
 	e.ExportProcessDelivery(
@@ -2039,10 +2141,10 @@ func buildSlackRetryDelivery(
 		Status:   database.DeliveryStatusPending,
 		Event:    event,
 		Target: database.Target{
-			Name:       "test-slack-retry",
+			Name:        "test-slack-retry",
-			Type:       database.TargetTypeSlack,
+			Type:        database.TargetTypeSlack,
-			Config:     cfg,
+			Config:      cfg,
-			MaxRetries: 5,
+			MaxAttempts: 5,
 		},
 	}
 	d.ID = dlv.ID
@@ -2077,11 +2179,11 @@ func TestDeliverSlack_WithRetries_SchedulesRetry(
 	)
 
 	task := &delivery.Task{
-		DeliveryID: dlv.ID,
+		DeliveryID:  dlv.ID,
-		TargetID:   targetID,
+		TargetID:    targetID,
-		TargetType: database.TargetTypeSlack,
+		TargetType:  database.TargetTypeSlack,
-		MaxRetries: 5,
+		MaxAttempts: 5,
-		AttemptNum: 1,
+		AttemptNum:  1,
 	}
 
 	e.ExportProcessDelivery(context.TODO(), db, d, task)

internal/delivery/event_db_isolation_test.go

@@ -152,7 +152,7 @@ func TestEventDBHoldsNoTargetRowsOnFailedDelivery(t *testing.T) {
 	)
 	task := iTask(
 		d, event, s.WebhookID, targetID,
-		"leaky-target", cfg, 0, 1, &body,
+		"leaky-target", cfg, 1, 1, &body,
 	)
 
 	s.Engine.ExportProcessNewTask(context.TODO(), &task)

internal/delivery/event_timestamp_test.go

@@ -147,11 +147,12 @@ func tsSeedTarget(
 	t.Helper()
 
 	target := database.Target{
-		WebhookID: webhookID,
+		WebhookID:   webhookID,
-		Name:      "slack-sink",
+		Name:        "slack-sink",
-		Type:      database.TargetTypeSlack,
+		Type:        database.TargetTypeSlack,
-		Config:    config,
+		Config:      config,
-		Active:    true,
+		Active:      true,
+		MaxAttempts: 1,
 	}
 
 	require.NoError(t, mainDB.Create(&target).Error)
@@ -176,7 +177,7 @@ func tsTask(
 		TargetName:   target.Name,
 		TargetType:   database.TargetTypeSlack,
 		TargetConfig: target.Config,
-		MaxRetries:   0,
+		MaxAttempts:  1,
 		Method:       event.Method,
 		Headers:      event.Headers,
 		ContentType:  event.ContentType,

internal/delivery/export_test.go

@@ -12,16 +12,11 @@ import (
 	"github.com/prometheus/client_golang/prometheus"
 	"go.uber.org/fx"
 	"gorm.io/gorm"
+	"sneak.berlin/go/webhooker/internal/archive"
 	"sneak.berlin/go/webhooker/internal/database"
 	"sneak.berlin/go/webhooker/internal/metrics"
 )
 
-// ErrExportArchiveWriterEvicted exposes the sentinel returned by
-// an evicted archive writer. It carries the Err prefix rather
-// than this file's usual Export one because it is a sentinel
-// error.
-var ErrExportArchiveWriterEvicted = errArchiveWriterEvicted
-
 // Exported constants for test access.
 const (
 	ExportDeliveryChannelSize     = deliveryChannelSize
@@ -142,9 +137,10 @@ func (e *Engine) ExportDeliverSlack(
 	d *database.Delivery,
 ) {
 	task := &Task{
-		DeliveryID: d.ID,
+		DeliveryID:  d.ID,
-		TargetID:   d.TargetID,
+		TargetID:    d.TargetID,
-		AttemptNum: 1,
+		MaxAttempts: d.Target.MaxAttempts,
+		AttemptNum:  1,
 	}
 
 	e.targets[database.TargetTypeSlack].Deliver(
@@ -285,32 +281,27 @@ func (e *Engine) ExportRecoverPendingDeliveries(
 	ctx context.Context,
 	webhookDB *gorm.DB,
 	webhookID string,
+	atStart bool,
 ) {
 	e.recoverPendingDeliveries(
-		ctx, webhookDB, webhookID,
+		ctx, webhookDB, webhookID, atStart,
 	)
 }
 
 // ExportRecoverWebhookDeliveries exposes
 // recoverWebhookDeliveries.
 func (e *Engine) ExportRecoverWebhookDeliveries(
-	ctx context.Context, webhookID string,
+	ctx context.Context, webhookID string, atStart bool,
 ) {
-	e.recoverWebhookDeliveries(ctx, webhookID)
+	e.recoverWebhookDeliveries(ctx, webhookID, atStart)
 }
 
-// ExportRecoverInFlight exposes recoverInFlight.
+// ExportRecoverDeliveries exposes recoverDeliveries, the recovery
-func (e *Engine) ExportRecoverInFlight(
+// routine.
-	ctx context.Context,
+func (e *Engine) ExportRecoverDeliveries(
+	ctx context.Context, atStart bool,
 ) {
-	e.recoverInFlight(ctx)
+	e.recoverDeliveries(ctx, atStart)
-}
-
-// ExportSweepWebhookRetries exposes sweepWebhookRetries.
-func (e *Engine) ExportSweepWebhookRetries(
-	ctx context.Context, webhookID string,
-) {
-	e.sweepWebhookRetries(ctx, webhookID)
 }
 
 // ExportStart exposes start for testing.
@@ -357,9 +348,9 @@ func (e *Engine) ExportRetainDelivery(deliveryID string) bool {
 
 // ExportRecoverRetryingDeliveries exposes recoverRetryingDeliveries.
 func (e *Engine) ExportRecoverRetryingDeliveries(
-	webhookDB *gorm.DB, webhookID string,
+	ctx context.Context, webhookDB *gorm.DB, webhookID string,
 ) {
-	e.recoverRetryingDeliveries(webhookDB, webhookID)
+	e.recoverRetryingDeliveries(ctx, webhookDB, webhookID)
 }
 
 // ExportFailMissingTarget exposes failMissingTarget, so a test can hand
@@ -398,7 +389,8 @@ func (e *Engine) ExportRetryCh() chan Task {
 }
 
 // NewTestEngine creates an Engine for unit tests without
-// database dependencies.
+// database dependencies. Its archive writers have no data
+// directory, so a delivery to a database target fails.
 func NewTestEngine(
 	log *slog.Logger,
 	client *http.Client,
@@ -410,6 +402,7 @@ func NewTestEngine(
 		retryCh:    make(chan Task, retryChannelSize),
 		workers:    workers,
 		mtr:        metrics.New(prometheus.NewRegistry()),
+		archives:   archive.NewWriters(archive.WritersParams{Logger: log}),
 	}
 	e.initTargets(client)
 
@@ -422,9 +415,10 @@ func NewTestEngineSmallRetry(
 	log *slog.Logger,
 ) *Engine {
 	e := &Engine{
-		log:     log,
+		log:      log,
-		retryCh: make(chan Task, 1),
+		retryCh:  make(chan Task, 1),
-		mtr:     metrics.New(prometheus.NewRegistry()),
+		mtr:      metrics.New(prometheus.NewRegistry()),
+		archives: archive.NewWriters(archive.WritersParams{Logger: log}),
 	}
 	e.initTargets(nil)
 
@@ -432,7 +426,8 @@ func NewTestEngineSmallRetry(
 }
 
 // NewTestEngineWithDB creates an Engine with a real
-// database and dbManager for integration tests.
+// database and dbManager for integration tests, and archive
+// writers of its own over the same two.
 func NewTestEngineWithDB(
 	db *database.Database,
 	dbMgr *database.WebhookDBManager,
@@ -448,12 +443,22 @@ func NewTestEngineWithDB(
 		retryCh:    make(chan Task, retryChannelSize),
 		workers:    workers,
 		mtr:        metrics.New(prometheus.NewRegistry()),
+		archives: archive.NewWriters(archive.WritersParams{
+			Database:  db,
+			DBManager: dbMgr,
+			Logger:    log,
+		}),
 	}
 	e.initTargets(client)
 
 	return e
 }
 
+// ExportArchives returns the engine's archive writers.
+func (e *Engine) ExportArchives() *archive.Writers {
+	return e.archives
+}
+
 // ExportSetMetrics substitutes the engine's metric set, so a test can
 // assert on collectors registered on a registry it holds.
 func (e *Engine) ExportSetMetrics(mtr *metrics.Set) {
@@ -476,273 +481,3 @@ func NewTestCircuitBreaker(
 		cooldown:  cooldown,
 	}
 }
-
-// ExportArchivedEvent aliases the archive row type so black-box
-// tests can construct and read archive rows.
-type ExportArchivedEvent = archivedEvent
-
-// ExportArchiveWriter wraps an archiveWriter so black-box tests
-// can exercise the archive file mechanics.
-type ExportArchiveWriter struct {
-	w *archiveWriter
-}
-
-// NewExportArchiveWriter builds an archive writer for tests,
-// optionally overriding the reopen debounce (a non-positive
-// debounce keeps the production default).
-func NewExportArchiveWriter(
-	path string, log *slog.Logger, debounce time.Duration,
-) *ExportArchiveWriter {
-	w := newArchiveWriter(path, log)
-	if debounce > 0 {
-		w.debounce = debounce
-	}
-
-	return &ExportArchiveWriter{w: w}
-}
-
-// Write archives a row through the writer, into the file named
-// without a period.
-func (e *ExportArchiveWriter) Write(
-	row ExportArchivedEvent, expiry time.Duration,
-) error {
-	return e.w.write(row, expiry, "")
-}
-
-// WritePeriod archives a row through the writer, into the file for
-// period.
-func (e *ExportArchiveWriter) WritePeriod(
-	row ExportArchivedEvent, expiry time.Duration, period string,
-) error {
-	return e.w.write(row, expiry, period)
-}
-
-// Open opens the archive file, pruning when expiry is positive.
-func (e *ExportArchiveWriter) Open(expiry time.Duration) error {
-	return e.w.open(e.w.path, expiry)
-}
-
-// Reopen closes and reopens the archive file.
-func (e *ExportArchiveWriter) Reopen(
-	expiry time.Duration,
-) error {
-	return e.w.reopen(e.w.path, expiry)
-}
-
-// SetNow replaces the clock the writer measures its reopen
-// debounce on.
-func (e *ExportArchiveWriter) SetNow(now func() time.Time) {
-	e.w.now = now
-}
-
-// Reopens reports how many times the file has been opened.
-func (e *ExportArchiveWriter) Reopens() int {
-	return e.w.reopens
-}
-
-// DB returns the writer's current open handle for row
-// inspection in tests.
-func (e *ExportArchiveWriter) DB() *gorm.DB {
-	return e.w.db
-}
-
-// Path returns the archive file the writer owns.
-func (e *ExportArchiveWriter) Path() string {
-	return e.w.path
-}
-
-// OpenExisting opens the archive without permitting creation,
-// the way the idle sweep does.
-func (e *ExportArchiveWriter) OpenExisting(
-	expiry time.Duration,
-) error {
-	return e.w.openMode(e.w.path, archiveModeExisting, expiry)
-}
-
-// SweepExpired runs an idle sweep of the archive.
-func (e *ExportArchiveWriter) SweepExpired(
-	expiry time.Duration,
-) error {
-	return e.w.sweepExpired(expiry)
-}
-
-// Evict marks the writer evicted and closes its handle, exactly
-// as leaving the registry does.
-func (e *ExportArchiveWriter) Evict() {
-	e.w.evict()
-}
-
-// Rename gives the archive file a new name in the same directory,
-// as a rename of the webhook or target does.
-func (e *ExportArchiveWriter) Rename(name string) error {
-	return e.w.rename(name)
-}
-
-// HandleOpen reports whether the writer currently holds an open
-// archive handle.
-func (e *ExportArchiveWriter) HandleOpen() bool {
-	e.w.mu.Lock()
-	defer e.w.mu.Unlock()
-
-	return e.w.db != nil
-}
-
-// Same reports whether both wrappers refer to the very same
-// underlying archive writer, so a test can prove a registry entry
-// is the writer it was handed rather than a replacement.
-func (e *ExportArchiveWriter) Same(
-	other *ExportArchiveWriter,
-) bool {
-	return other != nil && e.w == other.w
-}
-
-// ExportArchiveWriterFor returns the archive writer the registry
-// currently caches for a database target, or nil when none is
-// cached. It never creates one, so a test can hold a reference to
-// the very writer an eviction is about to detach.
-func (e *Engine) ExportArchiveWriterFor(
-	targetID string,
-) *ExportArchiveWriter {
-	e.dbTarget.mu.Lock()
-	defer e.dbTarget.mu.Unlock()
-
-	w, ok := e.dbTarget.writers[targetID]
-	if !ok {
-		return nil
-	}
-
-	return &ExportArchiveWriter{w: w}
-}
-
-// ExportHasArchiveWriter reports whether the database target
-// type currently caches an archive writer for a target.
-func (e *Engine) ExportHasArchiveWriter(
-	targetID string,
-) bool {
-	e.dbTarget.mu.Lock()
-	defer e.dbTarget.mu.Unlock()
-
-	_, ok := e.dbTarget.writers[targetID]
-
-	return ok
-}
-
-// ExportArchiveHandleOpen reports whether the cached archive
-// writer for a target holds an open database handle. It
-// returns false when no writer is cached.
-func (e *Engine) ExportArchiveHandleOpen(
-	targetID string,
-) bool {
-	e.dbTarget.mu.Lock()
-	w, ok := e.dbTarget.writers[targetID]
-	e.dbTarget.mu.Unlock()
-
-	if !ok {
-		return false
-	}
-
-	w.mu.Lock()
-	defer w.mu.Unlock()
-
-	return w.db != nil
-}
-
-// ExportEnsureArchiveWriter creates (if needed) and returns the
-// archive file path of the cached writer for a target, so a
-// test can prime the registry the way a delivery would.
-func (e *Engine) ExportEnsureArchiveWriter(
-	targetID string,
-) (string, error) {
-	w, err := e.dbTarget.writerFor(targetID)
-	if err != nil {
-		return "", err
-	}
-
-	return w.path, nil
-}
-
-// ExportSweepWriterFor takes a target's registry writer exactly
-// as the idle sweep does, reporting whether the sweep had to
-// create the entry. It lets a test drive the registry through the
-// sweep's own entry point instead of choreographing goroutines.
-func (e *Engine) ExportSweepWriterFor(
-	targetID string,
-) (*ExportArchiveWriter, bool, error) {
-	w, created, err := e.dbTarget.sweepWriterFor(targetID)
-	if err != nil {
-		return nil, false, err
-	}
-
-	return &ExportArchiveWriter{w: w}, created, nil
-}
-
-// ExportReleaseSweepWriter releases a sweep-created registry entry
-// exactly as a finished sweep does.
-func (e *Engine) ExportReleaseSweepWriter(
-	targetID string, w *ExportArchiveWriter,
-) {
-	e.dbTarget.releaseSweepWriter(targetID, w.w)
-}
-
-// NewTestArchiveSweeper builds an ArchiveSweeper backed by the
-// given main database and engine, without the fx lifecycle.
-// Intended for tests.
-func NewTestArchiveSweeper(
-	db *database.Database,
-	eng *Engine,
-	log *slog.Logger,
-) *ArchiveSweeper {
-	return &ArchiveSweeper{
-		db:       db,
-		eng:      eng,
-		log:      log,
-		interval: time.Hour,
-	}
-}
-
-// ExportSweep runs a single archive sweep synchronously for
-// tests.
-func (s *ArchiveSweeper) ExportSweep(ctx context.Context) {
-	s.sweep(ctx)
-}
-
-// ExportStart starts the sweeper's background loop for tests.
-func (s *ArchiveSweeper) ExportStart() {
-	s.start()
-}
-
-// ExportRegisterHooks registers the sweeper's real fx lifecycle
-// hooks on a lifecycle supplied by a test, so a test can drive
-// the exact OnStart/OnStop functions the application runs and
-// hand OnStart the kind of context fx actually supplies.
-func (s *ArchiveSweeper) ExportRegisterHooks(lc fx.Lifecycle) {
-	s.registerHooks(lc)
-}
-
-// ExportStop stops the sweeper's background loop for tests.
-func (s *ArchiveSweeper) ExportStop(ctx context.Context) error {
-	return s.stop(ctx)
-}
-
-// ExportWedgeLoop adds a goroutine to the sweeper's WaitGroup
-// that never observes cancellation and returns only when release
-// is closed. It stands in for a prune stuck on a locked archive.
-func (s *ArchiveSweeper) ExportWedgeLoop(
-	release <-chan struct{},
-) {
-	s.wg.Go(func() {
-		<-release
-	})
-}
-
-// ExportSetInterval overrides the sweep interval for tests.
-func (s *ArchiveSweeper) ExportSetInterval(d time.Duration) {
-	s.interval = d
-}
-
-// ExportParseArchiveExpiry exposes parseArchiveExpiry.
-func ExportParseArchiveExpiry(
-	configJSON string,
-) (time.Duration, error) {
-	return parseArchiveExpiry(configJSON)
-}

internal/delivery/inflight.go

@@ -6,10 +6,10 @@ import "sync"
 //
 // A delivery is owned from the moment a task for it is handed to a
 // channel or to a retry timer until the engine has no further plan for
-// it in memory. Restart recovery and both arms of the periodic sweep
+// it in memory. The recovery routine, at start and on every tick of the
-// re-dispatch only deliveries the set does not hold, which is what
+// sweep, re-dispatches only deliveries the set does not hold, which is
-// makes them exact rather than a guess about how long a row has sat at
+// what makes it exact rather than a guess about how long a row has sat
-// pending.
+// at pending.
 //
 // This replaces reasoning from timestamps. A delivery's row says
 // pending from creation until its outcome is written, which covers
@@ -25,8 +25,8 @@ import "sync"
 // In-memory state is sufficient because a data directory admits one
 // process: internal/datadir takes an flock on it at startup and a
 // second instance refuses to run. Deliveries owned by a process that
-// died are not in any successor's set, and restart recovery is what
+// died are not in any successor's set, and the recovery routine's run
-// picks those up.
+// at start is what picks those up.
 //
 // References are counted rather than held as a plain set because
 // ownership outlives the worker that took it. A target that schedules
@@ -61,9 +61,9 @@ func (s *inflightSet) retain(deliveryID string) {
 
 // retainIdle takes the first reference on a delivery, and reports
 // whether it got it. It fails when the engine already owns the
-// delivery, which is what makes two claimants — restart recovery and
+// delivery, which is what makes two claimants — Notify and the
-// the sweep run concurrently, or two sweep arms — mutually exclusive
+// recovery routine, say — mutually exclusive rather than merely
-// rather than merely atomic.
+// atomic.
 func (s *inflightSet) retainIdle(deliveryID string) bool {
 	s.mu.Lock()
 	defer s.mu.Unlock()

internal/delivery/inflight_test.go

@@ -2,8 +2,6 @@ package delivery_test
 
 import (
 	"context"
-	"path/filepath"
-	"strings"
 	"sync"
 	"testing"
 	"time"
@@ -32,7 +30,7 @@ func fSweepSetup(
 
 	iCreateTarget(t, s.MainDB, targetID,
 		s.WebhookID, name,
-		database.TargetTypeLog, "", 0,
+		database.TargetTypeLog, "", 1,
 	)
 
 	require.NoError(t, s.MainDB.Create(&database.Webhook{
@@ -66,33 +64,6 @@ func fDrain(e *delivery.Engine) []delivery.Task {
 	}
 }
 
-// TestArchiveHandleIsWAL closes the last gap in the durability
-// evidence: the main and per-webhook tiers each assert their journal
-// mode on a live handle, and the archive tier gets its settings from
-// the same code path but nothing checked the running file.
-func TestArchiveHandleIsWAL(t *testing.T) {
-	t.Parallel()
-
-	w := delivery.NewExportArchiveWriter(
-		filepath.Join(t.TempDir(), "archive-wal.db"),
-		archiveTestLogger(), 0,
-	)
-
-	require.NoError(t, w.Open(0))
-
-	var mode string
-
-	row := w.DB().Raw("pragma journal_mode").Row()
-	require.NoError(t, row.Scan(&mode))
-	assert.Equal(t, "wal", strings.ToLower(mode))
-
-	var busy string
-
-	row = w.DB().Raw("pragma busy_timeout").Row()
-	require.NoError(t, row.Scan(&busy))
-	assert.Equal(t, "10000", busy)
-}
-
 // TestSweepLeavesAQueuedDeliveryAlone is the case the age bound cannot
 // see. The delivery is queued and untouched, so its row is arbitrarily
 // old and still perfectly healthy; only ownership distinguishes it
@@ -124,8 +95,8 @@ func TestSweepLeavesAQueuedDeliveryAlone(t *testing.T) {
 
 	require.Equal(t, 1, s.Engine.ExportInflightHeld())
 
-	s.Engine.ExportSweepWebhookRetries(
+	s.Engine.ExportRecoverWebhookDeliveries(
-		context.Background(), s.WebhookID,
+		context.Background(), s.WebhookID, onTick,
 	)
 
 	tasks := fDrain(s.Engine)
@@ -136,9 +107,11 @@ func TestSweepLeavesAQueuedDeliveryAlone(t *testing.T) {
 	)
 }
 
-// TestRecoveryAndSweepDoNotDoubleDispatch drives the two entry points
+// TestRecoveryAndSweepDoNotDoubleDispatch drives the recovery routine's
-// the engine starts concurrently against one aged pending row. Before
+// run at start and a tick of the sweep at once against one aged pending
-// ownership they both dispatched it.
+// row. The engine runs them one after the other, but Notify can race
+// either, and ownership is what keeps any two claimants from both
+// sending. Before ownership the two runs both dispatched the row.
 func TestRecoveryAndSweepDoNotDoubleDispatch(t *testing.T) {
 	t.Parallel()
 
@@ -162,12 +135,12 @@ func TestRecoveryAndSweepDoNotDoubleDispatch(t *testing.T) {
 
 		wg.Go(func() {
 			s.Engine.ExportRecoverPendingDeliveries(
-				ctx, s.WebhookDB, s.WebhookID,
+				ctx, s.WebhookDB, s.WebhookID, atStart,
 			)
 		})
 		wg.Go(func() {
-			s.Engine.ExportSweepWebhookRetries(
+			s.Engine.ExportRecoverWebhookDeliveries(
-				ctx, s.WebhookID,
+				ctx, s.WebhookID, onTick,
 			)
 		})
 		wg.Wait()
@@ -229,7 +202,7 @@ func TestOwnershipIsReleasedAfterDelivery(t *testing.T) {
 
 	iCreateTarget(t, s.MainDB, targetID,
 		s.WebhookID, "released",
-		database.TargetTypeLog, "", 0,
+		database.TargetTypeLog, "", 1,
 	)
 
 	event := iSeedEvent(
@@ -276,9 +249,10 @@ func TestOwnershipIsReleasedAfterDelivery(t *testing.T) {
 
 // TestNotifyAfterRecoveryDoesNotSendAgain is the startup race of
 // https://git.eeqj.de/sneak/webhooker/issues/299. The receiver has
-// written a delivery, restart recovery finds it pending, sends it and
+// written a delivery, the recovery routine's run at start finds it
-// releases it, and only then does the receiver's Notify for it arrive.
+// pending, sends it and releases it, and only then does the receiver's
-// Nothing owns the delivery by then, so Notify takes it.
+// Notify for it arrive. Nothing owns the delivery by then, so Notify
+// takes it.
 func TestNotifyAfterRecoveryDoesNotSendAgain(t *testing.T) {
 	t.Parallel()
 
@@ -302,7 +276,8 @@ func TestNotifyAfterRecoveryDoesNotSendAgain(t *testing.T) {
 		)
 	}()
 
-	// Restart recovery sends the delivery and lets it go.
+	// The recovery routine's run at start sends the delivery and lets
+	// it go.
 	iWaitForDelivered(t, s.WebhookDB, d.ID)
 	require.Eventually(
 		t,
@@ -363,7 +338,7 @@ func TestRetryingRecoverySkipsASuccessfulResult(t *testing.T) {
 	rSeedResult(t, s.WebhookDB, d.ID, 2, true)
 
 	s.Engine.ExportRecoverRetryingDeliveries(
-		s.WebhookDB, s.WebhookID,
+		context.Background(), s.WebhookDB, s.WebhookID,
 	)
 
 	assert.Empty(
@@ -378,8 +353,8 @@ func TestRetryingRecoverySkipsASuccessfulResult(t *testing.T) {
 	)
 }
 
-// TestRetryingSweepSkipsASuccessfulResult is the same rule on the
+// TestRetryingSweepSkipsASuccessfulResult is the same rule on a tick of
-// periodic sweep's retrying arm.
+// the sweep.
 func TestRetryingSweepSkipsASuccessfulResult(t *testing.T) {
 	t.Parallel()
 
@@ -397,8 +372,8 @@ func TestRetryingSweepSkipsASuccessfulResult(t *testing.T) {
 	rSeedResult(t, s.WebhookDB, d.ID, 1, false)
 	rSeedResult(t, s.WebhookDB, d.ID, 2, true)
 
-	s.Engine.ExportSweepWebhookRetries(
+	s.Engine.ExportRecoverWebhookDeliveries(
-		context.Background(), s.WebhookID,
+		context.Background(), s.WebhookID, onTick,
 	)
 
 	assert.Empty(t, fDrain(s.Engine))
@@ -449,8 +424,8 @@ func TestScheduledRetryIsNotSweptDuringBackoff(t *testing.T) {
 
 	require.Equal(t, 1, s.Engine.ExportInflightHeld())
 
-	s.Engine.ExportSweepWebhookRetries(
+	s.Engine.ExportRecoverWebhookDeliveries(
-		context.Background(), s.WebhookID,
+		context.Background(), s.WebhookID, onTick,
 	)
 
 	assert.Empty(
@@ -462,7 +437,8 @@ func TestScheduledRetryIsNotSweptDuringBackoff(t *testing.T) {
 
 // TestRedispatchStampsTheRow pins the cadence control: a stranded
 // delivery that has just been handed out is not selected again by the
-// next tick a minute later.
+// next tick a minute later. The stamp is stored in the same form as
+// created_at.
 func TestRedispatchStampsTheRow(t *testing.T) {
 	t.Parallel()
 
@@ -481,7 +457,7 @@ func TestRedispatchStampsTheRow(t *testing.T) {
 
 	ctx := context.Background()
 
-	s.Engine.ExportSweepWebhookRetries(ctx, s.WebhookID)
+	s.Engine.ExportRecoverWebhookDeliveries(ctx, s.WebhookID, onTick)
 	require.Len(t, fDrain(s.Engine), 1)
 
 	var row database.Delivery
@@ -493,4 +469,13 @@ func TestRedispatchStampsTheRow(t *testing.T) {
 		"a re-dispatched delivery must be stamped so the "+
 			"next tick does not select it again",
 	)
+
+	var createdAt, updatedAt string
+
+	require.NoError(t, s.WebhookDB.Raw(
+		`SELECT CAST(created_at AS TEXT), CAST(updated_at AS TEXT)
+		FROM deliveries WHERE id = ?`, d.ID,
+	).Row().Scan(&createdAt, &updatedAt))
+	assertStoredTime(t, createdAt)
+	assertStoredTime(t, updatedAt)
 }

internal/delivery/metrics_test.go

@@ -291,20 +291,20 @@ func TestDeliveryMetrics_CircuitBreakerGauge(t *testing.T) {
 	body := event.Body
 	cfg := iHTTPConfig(ts.URL)
 
-	// A retry budget above the failure threshold, so the breaker
+	// An attempt budget above the failure threshold, so the breaker
 	// rather than the budget is what stops the delivery.
-	maxRetries := delivery.ExportDefaultFailureThreshold + 5
+	maxAttempts := delivery.ExportDefaultFailureThreshold + 5
 
 	// The retries below are only run if their target still exists;
 	// see https://git.eeqj.de/sneak/webhooker/issues/107.
 	iCreateTarget(
 		t, s.MainDB, targetID, s.WebhookID, "metrics-trip",
-		database.TargetTypeHTTP, cfg, maxRetries,
+		database.TargetTypeHTTP, cfg, maxAttempts,
 	)
 
 	first := iTask(
 		d, event, s.WebhookID, targetID,
-		"metrics-trip", cfg, maxRetries, 1, &body,
+		"metrics-trip", cfg, maxAttempts, 1, &body,
 	)
 
 	s.Engine.ExportProcessNewTask(context.TODO(), &first)
@@ -316,7 +316,7 @@ func TestDeliveryMetrics_CircuitBreakerGauge(t *testing.T) {
 		ExportDefaultFailureThreshold; attempt++ {
 		task := iTask(
 			d, event, s.WebhookID, targetID,
-			"metrics-trip", cfg, maxRetries, attempt, &body,
+			"metrics-trip", cfg, maxAttempts, attempt, &body,
 		)
 
 		s.Engine.ExportProcessRetryTask(
@@ -364,16 +364,16 @@ func TestDeliveryMetrics_BreakerBlockedIsNotAnAttempt(
 
 	body := event.Body
 	cfg := iHTTPConfig(ts.URL)
-	maxRetries := delivery.ExportDefaultFailureThreshold + 5
+	maxAttempts := delivery.ExportDefaultFailureThreshold + 5
 
 	iCreateTarget(
 		t, s.MainDB, targetID, s.WebhookID, "metrics-blocked",
-		database.TargetTypeHTTP, cfg, maxRetries,
+		database.TargetTypeHTTP, cfg, maxAttempts,
 	)
 
 	first := iTask(
 		d, event, s.WebhookID, targetID,
-		"metrics-blocked", cfg, maxRetries, 1, &body,
+		"metrics-blocked", cfg, maxAttempts, 1, &body,
 	)
 
 	s.Engine.ExportProcessNewTask(context.TODO(), &first)
@@ -382,7 +382,7 @@ func TestDeliveryMetrics_BreakerBlockedIsNotAnAttempt(
 		ExportDefaultFailureThreshold; attempt++ {
 		task := iTask(
 			d, event, s.WebhookID, targetID,
-			"metrics-blocked", cfg, maxRetries, attempt, &body,
+			"metrics-blocked", cfg, maxAttempts, attempt, &body,
 		)
 
 		s.Engine.ExportProcessRetryTask(context.TODO(), &task)
@@ -405,7 +405,7 @@ func TestDeliveryMetrics_BreakerBlockedIsNotAnAttempt(
 
 	blocked := iTask(
 		d, event, s.WebhookID, targetID,
-		"metrics-blocked", cfg, maxRetries,
+		"metrics-blocked", cfg, maxAttempts,
 		delivery.ExportDefaultFailureThreshold+1, &body,
 	)
 
@@ -444,8 +444,8 @@ func TestDeliveryMetrics_OrphanedRetryFailureLabelled(
 		t, s, database.TargetTypeLog,
 	)
 
-	s.Engine.ExportSweepWebhookRetries(
+	s.Engine.ExportRecoverWebhookDeliveries(
-		context.Background(), s.WebhookID,
+		context.Background(), s.WebhookID, onTick,
 	)
 
 	iAssertStatus(t, s.WebhookDB, deliveryID,

internal/delivery/queue_depth.go

@@ -20,7 +20,8 @@ const queueDepthSampleInterval = 30 * time.Second
 // to be seeded correctly at startup from rows written by a previous
 // process, and would drift permanently on any transition that failed
 // to persist. Counting is the measurement that cannot go wrong, and
-// it is the same whole-database walk the retry sweep already makes.
+// it is the same whole-database walk each tick of the sweep already
+// makes.
 func (e *Engine) queueDepthSampler(ctx context.Context) {
 	defer e.wg.Done()
 

internal/delivery/recovery_durability_test.go

@@ -66,7 +66,7 @@ func TestRecoverySkipsPendingWithSuccessfulResult(
 
 	iCreateTarget(t, s.MainDB, targetID,
 		s.WebhookID, "already-delivered",
-		database.TargetTypeLog, "", 0,
+		database.TargetTypeLog, "", 1,
 	)
 
 	event := iSeedEvent(
@@ -88,7 +88,7 @@ func TestRecoverySkipsPendingWithSuccessfulResult(
 	)
 
 	s.Engine.ExportRecoverPendingDeliveries(
-		context.Background(), s.WebhookDB, s.WebhookID,
+		context.Background(), s.WebhookDB, s.WebhookID, atStart,
 	)
 
 	select {
@@ -129,7 +129,7 @@ func TestRecoveryContinuesTheAttemptNumbering(t *testing.T) {
 
 	iCreateTarget(t, s.MainDB, targetID,
 		s.WebhookID, "numbering",
-		database.TargetTypeLog, "", 0,
+		database.TargetTypeLog, "", 1,
 	)
 
 	event := iSeedEvent(
@@ -145,7 +145,7 @@ func TestRecoveryContinuesTheAttemptNumbering(t *testing.T) {
 	rSeedResult(t, s.WebhookDB, d.ID, 2, false)
 
 	s.Engine.ExportRecoverPendingDeliveries(
-		context.Background(), s.WebhookDB, s.WebhookID,
+		context.Background(), s.WebhookDB, s.WebhookID, atStart,
 	)
 
 	select {
@@ -183,8 +183,8 @@ func TestSweepRecoversStrandedPending(t *testing.T) {
 		database.DeliveryStatusPending,
 	)
 
-	s.Engine.ExportSweepWebhookRetries(
+	s.Engine.ExportRecoverWebhookDeliveries(
-		context.Background(), s.WebhookID,
+		context.Background(), s.WebhookID, onTick,
 	)
 
 	select {
@@ -230,7 +230,7 @@ func TestSweepClaimsAStrandedDeliveryOnlyOnce(t *testing.T) {
 
 	ctx := context.Background()
 
-	s.Engine.ExportSweepWebhookRetries(ctx, s.WebhookID)
+	s.Engine.ExportRecoverWebhookDeliveries(ctx, s.WebhookID, onTick)
 
 	select {
 	case task := <-s.Engine.ExportDeliveryCh():
@@ -246,7 +246,7 @@ func TestSweepClaimsAStrandedDeliveryOnlyOnce(t *testing.T) {
 		database.DeliveryStatusPending,
 	)
 
-	s.Engine.ExportSweepWebhookRetries(ctx, s.WebhookID)
+	s.Engine.ExportRecoverWebhookDeliveries(ctx, s.WebhookID, onTick)
 
 	select {
 	case task := <-s.Engine.ExportDeliveryCh():
@@ -258,9 +258,9 @@ func TestSweepClaimsAStrandedDeliveryOnlyOnce(t *testing.T) {
 	}
 }
 
-// TestSweepSettlesStrandedPendingWithoutResending is the sweep's own
+// TestSweepSettlesStrandedPendingWithoutResending is the reconcile on a
-// version of the reconcile: a stranded delivery holding a successful
+// tick of the sweep: a stranded delivery holding a successful result is
-// result is settled where it stands, and the receiver hears nothing.
+// settled where it stands, and the receiver hears nothing.
 func TestSweepSettlesStrandedPendingWithoutResending(
 	t *testing.T,
 ) {
@@ -280,8 +280,8 @@ func TestSweepSettlesStrandedPendingWithoutResending(
 	rSeedResult(t, s.WebhookDB, d.ID, 1, true)
 	rAgePending(t, s.WebhookDB, d.ID)
 
-	s.Engine.ExportSweepWebhookRetries(
+	s.Engine.ExportRecoverWebhookDeliveries(
-		context.Background(), s.WebhookID,
+		context.Background(), s.WebhookID, onTick,
 	)
 
 	select {
@@ -312,8 +312,9 @@ func TestSweepSettlesStrandedPendingWithoutResending(
 
 // TestFailedResultWriteLeavesDeliveryRecoverable is the rule the
 // targets now follow: a bookkeeping write that fails must not advance
-// the status, because pending and retrying are the states the sweeps
+// the status, because pending and retrying are the states the recovery
-// recover and delivered is a claim the database refused to record.
+// routine recovers and delivered is a claim the database refused to
+// record.
 func TestFailedResultWriteLeavesDeliveryRecoverable(
 	t *testing.T,
 ) {
@@ -354,16 +355,17 @@ func TestFailedResultWriteLeavesDeliveryRecoverable(
 		Status:   database.DeliveryStatusPending,
 		Event:    event,
 		Target: database.Target{
-			Name:   "unwritable",
+			Name:        "unwritable",
-			Type:   database.TargetTypeHTTP,
+			Type:        database.TargetTypeHTTP,
-			Config: iHTTPConfig(ts.URL),
+			Config:      iHTTPConfig(ts.URL),
+			MaxAttempts: 1,
 		},
 	}
 	full.ID = d.ID
 
 	s.Engine.ExportDeliverHTTP(
 		context.Background(), s.WebhookDB, full,
-		&delivery.Task{DeliveryID: d.ID, AttemptNum: 1},
+		&delivery.Task{DeliveryID: d.ID, MaxAttempts: 1, AttemptNum: 1},
 	)
 
 	assert.Equal(
@@ -444,10 +446,10 @@ func TestFailedResultWriteWithRetriesLeavesDeliveryRecoverable(
 				Status:   database.DeliveryStatusPending,
 				Event:    event,
 				Target: database.Target{
-					Name:       "unwritable",
+					Name:        "unwritable",
-					Type:       database.TargetTypeHTTP,
+					Type:        database.TargetTypeHTTP,
-					Config:     iHTTPConfig(ts.URL),
+					Config:      iHTTPConfig(ts.URL),
-					MaxRetries: 3,
+					MaxAttempts: 3,
 				},
 			}
 			full.ID = d.ID
@@ -457,9 +459,8 @@ func TestFailedResultWriteWithRetriesLeavesDeliveryRecoverable(
 			s.Engine.ExportDeliverHTTPWithScheduler(
 				context.Background(), s.WebhookDB, full,
 				&delivery.Task{
-					DeliveryID: d.ID,
+					DeliveryID: d.ID, TargetID: targetID,
-					TargetID:   targetID,
+					MaxAttempts: 3, AttemptNum: 1,
-					AttemptNum: 1,
 				},
 				sched,
 			)

internal/delivery/recovery_test.go

@@ -0,0 +1,340 @@
+package delivery_test
+
+import (
+	"context"
+	"log/slog"
+	"net/http"
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/webhooker/internal/database"
+	"sneak.berlin/go/webhooker/internal/database/databasetest"
+	"sneak.berlin/go/webhooker/internal/delivery"
+)
+
+// These tests cover the recovery routine, which the engine runs once
+// when it starts and then on every tick of the sweep
+// (https://git.eeqj.de/sneak/webhooker/issues/542). Every case runs it
+// both ways, each on a webhook of its own.
+
+// atStart and onTick are the two values of the recovery routine's
+// atStart parameter: its run when the engine starts, and a tick of the
+// sweep.
+const (
+	atStart = true
+	onTick  = false
+)
+
+// recoveryRun names one of the two runs of the recovery routine.
+type recoveryRun struct {
+	name    string
+	atStart bool
+}
+
+// recoveryRuns returns the routine's run at start and a tick.
+func recoveryRuns() []recoveryRun {
+	return []recoveryRun{
+		{"at start", atStart},
+		{"on a tick", onTick},
+	}
+}
+
+// recoverySetup gives a fresh webhook its main-database row and an http
+// target with retries, and returns the setup and the target's ID. No
+// worker runs, so whatever the routine queues stays in the channels for
+// the test to read, and nothing is sent to the target.
+func recoverySetup(t *testing.T) (iSetup, string) {
+	t.Helper()
+
+	s := newISetup(t)
+	targetID := uuid.New().String()
+
+	iCreateWebhook(t, s.MainDB, s.WebhookID, "recovery")
+	iCreateTarget(
+		t, s.MainDB, targetID, s.WebhookID, "recovery",
+		database.TargetTypeHTTP,
+		iHTTPConfig("http://example.com/hook"), 20,
+	)
+
+	return s, targetID
+}
+
+// seedRecoveryDelivery seeds a delivery at status with the given
+// recorded attempts, failed but for the last when lastSucceeded is set,
+// all recorded now.
+func seedRecoveryDelivery(
+	t *testing.T,
+	s iSetup,
+	targetID string,
+	status database.DeliveryStatus,
+	attempts int,
+	lastSucceeded bool,
+) string {
+	t.Helper()
+
+	event := iSeedEvent(t, s.WebhookDB, s.WebhookID, `{"recovery":true}`)
+	d := iSeedDelivery(t, s.WebhookDB, event.ID, targetID, status)
+
+	for n := 1; n <= attempts; n++ {
+		rSeedResult(
+			t, s.WebhookDB, d.ID, n, lastSucceeded && n == attempts,
+		)
+	}
+
+	return d.ID
+}
+
+// backdateAttempts moves every recorded attempt of a delivery an hour
+// into the past, long past the backoff after its first attempt.
+func backdateAttempts(t *testing.T, s iSetup, deliveryID string) {
+	t.Helper()
+
+	require.NoError(t, s.WebhookDB.Model(&database.DeliveryResult{}).
+		Where("delivery_id = ?", deliveryID).
+		UpdateColumn("created_at", s.WebhookDB.NowFunc().Add(-time.Hour)).
+		Error)
+}
+
+// requireQueued waits for a task on ch. A retrying delivery reaches the
+// retry channel through a timer, even one due now, so it is waited for.
+func requireQueued(
+	t *testing.T, ch <-chan delivery.Task,
+) delivery.Task {
+	t.Helper()
+
+	select {
+	case task := <-ch:
+		return task
+	case <-time.After(5 * time.Second):
+		t.Fatal("the recovery routine queued nothing")
+
+		return delivery.Task{}
+	}
+}
+
+// assertNothingQueued asserts the engine queues nothing, giving a retry
+// timer that is due now the moment it needs to fire.
+func assertNothingQueued(t *testing.T, e *delivery.Engine) {
+	t.Helper()
+
+	select {
+	case task := <-e.ExportDeliveryCh():
+		t.Errorf("queued pending delivery %s", task.DeliveryID)
+	case task := <-e.ExportRetryCh():
+		t.Errorf("queued retrying delivery %s", task.DeliveryID)
+	case <-time.After(200 * time.Millisecond):
+	}
+}
+
+// TestRecovery_RetryingBackoffPassed: a retrying delivery whose backoff
+// is over is queued for its next attempt at once.
+func TestRecovery_RetryingBackoffPassed(t *testing.T) {
+	t.Parallel()
+
+	for _, run := range recoveryRuns() {
+		t.Run(run.name, func(t *testing.T) {
+			t.Parallel()
+
+			s, targetID := recoverySetup(t)
+			id := seedRecoveryDelivery(
+				t, s, targetID, database.DeliveryStatusRetrying, 1, false,
+			)
+			backdateAttempts(t, s, id)
+
+			s.Engine.ExportRecoverDeliveries(context.Background(), run.atStart)
+
+			task := requireQueued(t, s.Engine.ExportRetryCh())
+			assert.Equal(t, id, task.DeliveryID)
+			assert.Equal(t, 2, task.AttemptNum)
+			iAssertStatus(t, s.WebhookDB, id, database.DeliveryStatusRetrying)
+		})
+	}
+}
+
+// TestRecovery_RetryingBackoffNotPassed: a retrying delivery whose last
+// attempt was just now waits out the rest of its backoff, ten attempts
+// in, eight and a half minutes. It is not sent now, and the engine holds
+// it, so a later tick leaves it to the timer.
+func TestRecovery_RetryingBackoffNotPassed(t *testing.T) {
+	t.Parallel()
+
+	for _, run := range recoveryRuns() {
+		t.Run(run.name, func(t *testing.T) {
+			t.Parallel()
+
+			s, targetID := recoverySetup(t)
+			id := seedRecoveryDelivery(
+				t, s, targetID, database.DeliveryStatusRetrying, 10, false,
+			)
+
+			s.Engine.ExportRecoverDeliveries(context.Background(), run.atStart)
+
+			assertNothingQueued(t, s.Engine)
+			iAssertStatus(t, s.WebhookDB, id, database.DeliveryStatusRetrying)
+			assert.Equal(t, 1, s.Engine.ExportInflightHeld(),
+				"no retry timer holds the delivery",
+			)
+		})
+	}
+}
+
+// TestRecovery_PendingOlderThanTheAgeBound: a pending delivery untouched
+// for longer than the sweep's age bound is sent by either run.
+func TestRecovery_PendingOlderThanTheAgeBound(t *testing.T) {
+	t.Parallel()
+
+	for _, run := range recoveryRuns() {
+		t.Run(run.name, func(t *testing.T) {
+			t.Parallel()
+
+			s, targetID := recoverySetup(t)
+			id := seedRecoveryDelivery(
+				t, s, targetID, database.DeliveryStatusPending, 0, false,
+			)
+			rAgePending(t, s.WebhookDB, id)
+
+			s.Engine.ExportRecoverDeliveries(context.Background(), run.atStart)
+
+			task := requireQueued(t, s.Engine.ExportDeliveryCh())
+			assert.Equal(t, id, task.DeliveryID)
+			assert.Equal(t, 1, task.AttemptNum)
+		})
+	}
+}
+
+// TestRecovery_PendingYoungerThanTheAgeBound: a pending delivery touched
+// a moment ago, as one a stop cut off is, is sent at start, which is how
+// it reaches its target on the next start
+// (https://git.eeqj.de/sneak/webhooker/issues/527). A tick leaves it.
+func TestRecovery_PendingYoungerThanTheAgeBound(t *testing.T) {
+	t.Parallel()
+
+	for _, run := range recoveryRuns() {
+		t.Run(run.name, func(t *testing.T) {
+			t.Parallel()
+
+			s, targetID := recoverySetup(t)
+			id := seedRecoveryDelivery(
+				t, s, targetID, database.DeliveryStatusPending, 0, false,
+			)
+
+			s.Engine.ExportRecoverDeliveries(context.Background(), run.atStart)
+
+			if run.atStart {
+				task := requireQueued(t, s.Engine.ExportDeliveryCh())
+				assert.Equal(t, id, task.DeliveryID)
+
+				return
+			}
+
+			assertNothingQueued(t, s.Engine)
+			iAssertStatus(t, s.WebhookDB, id, database.DeliveryStatusPending)
+			assert.Zero(t, s.Engine.ExportInflightHeld())
+		})
+	}
+}
+
+// TestRecovery_AlreadySucceeded: a pending or retrying delivery whose
+// success is recorded but whose status write was lost is marked
+// delivered where it stands, and not sent again.
+func TestRecovery_AlreadySucceeded(t *testing.T) {
+	t.Parallel()
+
+	for _, run := range recoveryRuns() {
+		t.Run(run.name, func(t *testing.T) {
+			t.Parallel()
+
+			s, targetID := recoverySetup(t)
+			pending := seedRecoveryDelivery(
+				t, s, targetID, database.DeliveryStatusPending, 1, true,
+			)
+			rAgePending(t, s.WebhookDB, pending)
+
+			retrying := seedRecoveryDelivery(
+				t, s, targetID, database.DeliveryStatusRetrying, 2, true,
+			)
+			backdateAttempts(t, s, retrying)
+
+			s.Engine.ExportRecoverDeliveries(context.Background(), run.atStart)
+
+			assertNothingQueued(t, s.Engine)
+
+			for id, attempts := range map[string]int{pending: 1, retrying: 2} {
+				iAssertStatus(
+					t, s.WebhookDB, id, database.DeliveryStatusDelivered,
+				)
+				assert.Len(t, iResults(t, s.WebhookDB, id), attempts,
+					"marking the delivery delivered recorded an attempt",
+				)
+			}
+		})
+	}
+}
+
+// TestRecovery_MissingDatabase: a tick leaves a webhook whose database
+// file is missing alone, and the run at start opens it, which creates an
+// empty one and reports the loss (see
+// TestRecoverDeliveries_ReportsAMissingWebhookDatabase).
+func TestRecovery_MissingDatabase(t *testing.T) {
+	t.Parallel()
+
+	mainDB := iMainDB(t)
+	webhookID := uuid.New().String()
+	iCreateWebhook(t, mainDB.DB(), webhookID, "missing-database")
+
+	dbMgr := databasetest.NewWebhookDBManager(t, t.TempDir())
+	t.Cleanup(func() { _ = dbMgr.CloseAll() })
+
+	engine := delivery.NewTestEngineWithDB(
+		mainDB, dbMgr,
+		slog.New(slog.DiscardHandler),
+		&http.Client{Timeout: 5 * time.Second}, 1,
+	)
+
+	engine.ExportRecoverDeliveries(context.Background(), onTick)
+	assert.False(t, dbMgr.DBExists(webhookID),
+		"a tick created the missing database",
+	)
+
+	engine.ExportRecoverDeliveries(context.Background(), atStart)
+	assert.True(t, dbMgr.DBExists(webhookID),
+		"the run at start did not open the missing database",
+	)
+}
+
+// TestRecovery_LeavesADeliveryTheEngineHolds: a delivery the engine is
+// working on, has queued, or holds a retry timer for is left alone by
+// either run, pending and retrying alike, however old.
+func TestRecovery_LeavesADeliveryTheEngineHolds(t *testing.T) {
+	t.Parallel()
+
+	for _, run := range recoveryRuns() {
+		t.Run(run.name, func(t *testing.T) {
+			t.Parallel()
+
+			s, targetID := recoverySetup(t)
+			pending := seedRecoveryDelivery(
+				t, s, targetID, database.DeliveryStatusPending, 0, false,
+			)
+			rAgePending(t, s.WebhookDB, pending)
+
+			retrying := seedRecoveryDelivery(
+				t, s, targetID, database.DeliveryStatusRetrying, 1, false,
+			)
+			backdateAttempts(t, s, retrying)
+
+			require.True(t, s.Engine.ExportRetainDelivery(pending))
+			require.True(t, s.Engine.ExportRetainDelivery(retrying))
+
+			s.Engine.ExportRecoverDeliveries(context.Background(), run.atStart)
+
+			assertNothingQueued(t, s.Engine)
+			iAssertStatus(t, s.WebhookDB, pending, database.DeliveryStatusPending)
+			iAssertStatus(t, s.WebhookDB, retrying, database.DeliveryStatusRetrying)
+			assert.Equal(t, 2, s.Engine.ExportInflightHeld())
+		})
+	}
+}

internal/delivery/redirect_test.go

@@ -96,7 +96,7 @@ func deliverWithProbeHeaders(
 	body := event.Body
 	task := iTask(
 		d, event, s.WebhookID, targetID,
-		"redirect-target", string(cfg), 0, 1, &body,
+		"redirect-target", string(cfg), 1, 1, &body,
 	)
 
 	s.Engine.ExportProcessNewTask(context.TODO(), &task)

internal/delivery/target.go

@@ -13,8 +13,8 @@ import (
 // The engine provides one to each target so a target can own
 // its retries durably: it records the attempt, marks the
 // delivery retrying, and asks the Scheduler to deliver the
-// next attempt after delay — exactly what the engine does for
+// next attempt after delay — exactly what the engine's
-// its own restart recovery.
+// recovery routine does for a retrying delivery.
 type Scheduler interface {
 	ScheduleRetry(task Task, delay time.Duration)
 }
@@ -32,7 +32,8 @@ type Scheduler interface {
 // Engine.observeAttempt, alongside the DeliveryResult it records for
 // it. Deliver is also entered for attempts that never happen — an
 // open circuit breaker refuses one — so the count cannot be taken
-// from around this call.
+// from around this call. An attempt cut off by a stop is neither
+// counted nor recorded.
 type Target interface {
 	Deliver(
 		ctx context.Context,
@@ -44,29 +45,20 @@ type Target interface {
 }
 
 // rescheduler is implemented by targets that own durable
-// retries. The engine's restart recovery and periodic sweep
+// retries. The engine's recovery routine uses it to let the
-// use it to let the target recompute the schedule for an
+// target recompute the schedule for an orphaned retrying
-// orphaned retrying delivery, keeping the retry schedule
+// delivery, keeping the retry schedule target-owned.
-// target-owned. Fire-and-forget targets do not implement it
+// Fire-and-forget targets do not implement it, and a retrying
-// and their (never-occurring) retrying deliveries are
+// delivery found for one is terminally failed.
-// skipped.
 type rescheduler interface {
 	// remainingBackoff returns how long to wait before the
-	// next attempt of a recovered retrying delivery.
+	// next attempt of a recovered retrying delivery: zero once
+	// its backoff has passed.
 	remainingBackoff(
 		webhookDB *gorm.DB,
 		deliveryID string,
 		attemptNum int,
 	) time.Duration
-
-	// backoffElapsed reports whether the backoff window for
-	// the last attempt has already passed, so the periodic
-	// sweep can re-enqueue the delivery now.
-	backoffElapsed(
-		webhookDB *gorm.DB,
-		deliveryID string,
-		attemptNum int,
-	) bool
 }
 
 // attemptResult is the outcome of a single delivery attempt,
@@ -102,16 +94,13 @@ func (e *Engine) initTargets(client *http.Client) {
 		client:   client,
 	}
 
-	dbT := &databaseTarget{eng: e}
-
 	e.httpTarget = httpT
 	e.slackTarget = slackT
-	e.dbTarget = dbT
 
 	e.targets = map[database.TargetType]Target{
 		database.TargetTypeHTTP:     httpT,
 		database.TargetTypeSlack:    slackT,
-		database.TargetTypeDatabase: dbT,
+		database.TargetTypeDatabase: &databaseTarget{eng: e},
 		database.TargetTypeLog:      &logTarget{eng: e},
 	}
 }

internal/delivery/target_config_edit.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 
+	"sneak.berlin/go/webhooker/internal/archive"
 	"sneak.berlin/go/webhooker/internal/database"
 )
 
@@ -105,7 +106,7 @@ func databaseConfigForm(
 		return TargetConfigForm{}, nil
 	}
 
-	var cfg databaseTargetConfig
+	var cfg archive.DatabaseTargetConfig
 
 	err := json.Unmarshal([]byte(configJSON), &cfg)
 	if err != nil {
@@ -114,18 +115,18 @@ func databaseConfigForm(
 		)
 	}
 
-	err = ValidateArchiveRotation(cfg.Rotation)
+	err = archive.ValidateRotation(cfg.Rotation)
 	if err != nil {
 		return TargetConfigForm{}, err
 	}
 
 	form := TargetConfigForm{Rotation: cfg.Rotation}
 
-	if cfg.Expiry == "" || cfg.Expiry == archiveExpiryNever {
+	if cfg.Expiry == "" || cfg.Expiry == archive.ExpiryNever {
 		return form, nil
 	}
 
-	err = ValidateArchiveExpiry(cfg.Expiry)
+	err = archive.ValidateExpiry(cfg.Expiry)
 	if err != nil {
 		return TargetConfigForm{}, err
 	}

internal/delivery/target_config_view.go

@@ -5,6 +5,7 @@ import (
 	"strconv"
 	"time"
 
+	"sneak.berlin/go/webhooker/internal/archive"
 	"sneak.berlin/go/webhooker/internal/database"
 )
 
@@ -120,8 +121,8 @@ func unavailableConfigFields() []ConfigField {
 }
 
 // slackConfigFields describes a Slack target: its masked
-// webhook URL and its retry count. Only the masked URL is
+// webhook URL and its number of delivery attempts. Only the
-// shown; the full URL is the credential.
+// masked URL is shown; the full URL is the credential.
 func slackConfigFields(t *database.Target) []ConfigField {
 	cfg, err := parseSlackConfig(t.Config)
 	if err != nil {
@@ -131,7 +132,7 @@ func slackConfigFields(t *database.Target) []ConfigField {
 	return []ConfigField{{
 		Label: "Webhook URL",
 		Value: cfg.MaskedWebhookURL(),
-	}, maxRetriesField(t)}
+	}, maxAttemptsField(t)}
 }
 
 // httpConfigFields describes an HTTP target: its destination
@@ -178,23 +179,18 @@ func httpConfigFields(t *database.Target) []ConfigField {
 		})
 	}
 
-	fields = append(fields, maxRetriesField(t))
+	fields = append(fields, maxAttemptsField(t))
 
 	return fields
 }
 
-// maxRetriesField describes a target's retry count, which lives
+// maxAttemptsField describes a target's number of delivery
-// on the target row rather than in its configuration blob. A
+// attempts, which lives on the target row rather than in its
-// stored 0 makes a single attempt, so it is shown as 1.
+// configuration blob.
-func maxRetriesField(t *database.Target) ConfigField {
+func maxAttemptsField(t *database.Target) ConfigField {
-	attempts := strconv.Itoa(t.MaxRetries)
-	if t.MaxRetries == 0 {
-		attempts = "1 (fire-and-forget: no retries, no circuit breaker)"
-	}
-
 	return ConfigField{
 		Label: "Delivery attempts",
-		Value: attempts,
+		Value: strconv.Itoa(t.MaxAttempts),
 	}
 }
 
@@ -205,17 +201,17 @@ func maxRetriesField(t *database.Target) ConfigField {
 // not one of the four, is reported as unavailable rather than
 // echoed back.
 func databaseConfigFields(configJSON string) []ConfigField {
-	expiry, err := parseArchiveExpiry(configJSON)
+	expiry, err := archive.ParseExpiry(configJSON)
 	if err != nil {
 		return unavailableConfigFields()
 	}
 
-	rotation, err := parseArchiveRotation(configJSON)
+	rotation, err := archive.ParseRotation(configJSON)
 	if err != nil {
 		return unavailableConfigFields()
 	}
 
-	value := archiveExpiryNever
+	value := archive.ExpiryNever
 	if expiry > 0 {
 		value = plainDuration(expiry)
 	}

internal/delivery/target_config_view_test.go

@@ -32,7 +32,18 @@ const (
 	viewMaskedOrigin  = viewExampleOrigin + "/..."
 	viewUnavailable   = "(unavailable)"
 	viewExpiryNever   = "never"
-	viewMaxRetries    = "Delivery attempts"
+	viewMaxAttempts   = "Delivery attempts"
+)
+
+// The archive rotations a database target's settings can name, and
+// the config of one whose rotation is not one of the four.
+const (
+	rotationNone    = "none"
+	rotationMonthly = "monthly"
+	rotationDaily   = "daily"
+	rotationHourly  = "hourly"
+
+	weeklyConfig = `{"rotation":"weekly"}`
 )
 
 func TestMaskedWebhookURL(t *testing.T) {
@@ -171,6 +182,7 @@ func slackTarget() database.Target {
 		Active: true,
 		Config: `{"webhookUrl":"` +
 			slackWebhookURL + `"}`,
+		MaxAttempts: 1,
 	}
 }
 
@@ -189,28 +201,29 @@ func TestNewTargetViews_Slack(t *testing.T) {
 	assert.Equal(
 		t,
 		map[string]string{
-			"Webhook URL":  slackMaskedURL,
+			"Webhook URL":   slackMaskedURL,
-			viewMaxRetries: "1 (fire-and-forget: no retries, no circuit breaker)",
+			viewMaxAttempts: "1",
 		},
 		fieldMap(view.Config),
 	)
 }
 
-// TestNewTargetViews_SlackRetries proves a Slack target shows
+// TestNewTargetViews_SlackAttempts proves a Slack target shows
-// its retry count the same way an HTTP target does.
+// its number of delivery attempts the same way an HTTP target
-func TestNewTargetViews_SlackRetries(t *testing.T) {
+// does.
+func TestNewTargetViews_SlackAttempts(t *testing.T) {
 	t.Parallel()
 
 	target := slackTarget()
-	target.MaxRetries = 2
+	target.MaxAttempts = 2
 
 	view := viewFor(t, target)
 
 	assert.Equal(
 		t,
 		map[string]string{
-			"Webhook URL":  slackMaskedURL,
+			"Webhook URL":   slackMaskedURL,
-			viewMaxRetries: "2",
+			viewMaxAttempts: "2",
 		},
 		fieldMap(view.Config),
 	)
@@ -225,7 +238,7 @@ func TestNewTargetViews_HTTP(t *testing.T) {
 			`"timeout":30,` +
 			`"headers":{"Authorization":"Bearer sekrit"},` +
 			`"forwardQuery":true}`,
-		MaxRetries: 5,
+		MaxAttempts: 5,
 	})
 
 	fields := fieldMap(view.Config)
@@ -237,7 +250,7 @@ func TestNewTargetViews_HTTP(t *testing.T) {
 			"Timeout":         "30s",
 			"Headers":         "1 configured",
 			"Query string":    "passed on to this target",
-			viewMaxRetries:    "5",
+			viewMaxAttempts:   "5",
 		},
 		fields,
 	)
@@ -248,19 +261,22 @@ func TestNewTargetViews_HTTP(t *testing.T) {
 	}
 }
 
-func TestNewTargetViews_HTTPFireAndForget(t *testing.T) {
+// TestNewTargetViews_HTTPSingleAttempt proves a single attempt is
+// shown as the plain number, like any other.
+func TestNewTargetViews_HTTPSingleAttempt(t *testing.T) {
 	t.Parallel()
 
 	view := viewFor(t, database.Target{
-		Type:   database.TargetTypeHTTP,
+		Type:        database.TargetTypeHTTP,
-		Config: `{"url":"` + viewExampleHook + `"}`,
+		Config:      `{"url":"` + viewExampleHook + `"}`,
+		MaxAttempts: 1,
 	})
 
 	assert.Equal(
 		t,
 		map[string]string{
 			"Destination URL": viewMaskedOrigin,
-			viewMaxRetries:    "1 (fire-and-forget: no retries, no circuit breaker)",
+			viewMaxAttempts:   "1",
 		},
 		fieldMap(view.Config),
 	)
@@ -274,8 +290,9 @@ func TestNewTargetViews_HTTPMasksDestinationURL(t *testing.T) {
 	t.Parallel()
 
 	view := viewFor(t, database.Target{
-		Type:   database.TargetTypeHTTP,
+		Type:        database.TargetTypeHTTP,
-		Config: `{"url":"` + slackWebhookURL + `"}`,
+		Config:      `{"url":"` + slackWebhookURL + `"}`,
+		MaxAttempts: 1,
 	})
 
 	fields := fieldMap(view.Config)
@@ -398,19 +415,23 @@ func TestNewTargetViews_Unpresentable(t *testing.T) {
 			Config: blob,
 		},
 		"unparseable json": {
-			Type:   database.TargetTypeSlack,
+			Type:        database.TargetTypeSlack,
-			Config: blob,
+			Config:      blob,
+			MaxAttempts: 1,
 		},
 		"empty slack config": {
-			Type: database.TargetTypeSlack,
+			Type:        database.TargetTypeSlack,
+			MaxAttempts: 1,
 		},
 		"slack config without url": {
-			Type:   database.TargetTypeSlack,
+			Type:        database.TargetTypeSlack,
-			Config: `{}`,
+			Config:      `{}`,
+			MaxAttempts: 1,
 		},
 		"unparseable http json": {
-			Type:   database.TargetTypeHTTP,
+			Type:        database.TargetTypeHTTP,
-			Config: `{"url":`,
+			Config:      `{"url":`,
+			MaxAttempts: 1,
 		},
 		"unparseable archive json": {
 			Type:   database.TargetTypeDatabase,

internal/delivery/target_database.go

@@ -2,83 +2,23 @@ package delivery
 
 import (
 	"context"
-	"fmt"
-	"strings"
-	"sync"
 	"time"
 
 	"gorm.io/gorm"
 	"sneak.berlin/go/webhooker/internal/database"
 )
 
-// archiveNameMaxLen is how many characters of a webhook or target
-// name an archive file name keeps.
-const archiveNameMaxLen = 40
-
 // databaseTarget is a no-retry target that archives the full
 // inbound event into the target's own archive SQLite file, separate
 // from the per-webhook event database. The event is already
 // persisted in the per-webhook event DB by the time delivery runs;
 // the database target additionally writes a durable long-term copy
-// into the file ArchiveFileName names, with a period added when the
+// through the engine's archive.Writers, and then records a single
-// target rotates (see archivePeriodPath), and then records a single
 // attempt whose outcome reflects whether the archive write
-// succeeded. See archiveWriter for the close/reopen, auto-recreate,
+// succeeded. Package archive holds everything about the files
-// and expiry semantics.
+// themselves.
 type databaseTarget struct {
 	eng *Engine
-
-	// writers holds one archive writer per database target, keyed
-	// by target ID.
-	mu      sync.Mutex
-	writers map[string]*archiveWriter
-}
-
-// ArchiveFileName returns the file name of a database target's
-// archive: archive-WEBHOOKNAME-TARGETNAME-TARGETID.db, with both
-// names passed through archiveNamePart. The target ID keeps the
-// name unique when two targets' names come out the same.
-func ArchiveFileName(webhookName, targetName, targetID string) string {
-	return "archive-" + archiveNamePart(webhookName) + "-" +
-		archiveNamePart(targetName) + "-" + targetID + ".db"
-}
-
-// archiveNamePart makes a webhook or target name safe to put in a
-// file name. It is lowercased; ASCII letters and digits are kept,
-// every other run of characters becomes a single "-", and no "-" is
-// left at either end. It is cut to archiveNameMaxLen characters, and
-// a name with nothing left is "unnamed".
-func archiveNamePart(name string) string {
-	var b strings.Builder
-
-	dash := false
-
-	for _, r := range strings.ToLower(name) {
-		if (r < 'a' || r > 'z') && (r < '0' || r > '9') {
-			dash = b.Len() > 0
-
-			continue
-		}
-
-		if dash {
-			b.WriteByte('-')
-
-			dash = false
-		}
-
-		b.WriteRune(r)
-	}
-
-	part := b.String()
-	if len(part) > archiveNameMaxLen {
-		part = strings.TrimRight(part[:archiveNameMaxLen], "-")
-	}
-
-	if part == "" {
-		return "unnamed"
-	}
-
-	return part
 }
 
 // Deliver implements Target. It archives the event, then
@@ -98,7 +38,7 @@ func (t *databaseTarget) Deliver(
 ) {
 	start := time.Now()
 
-	err := t.archive(d)
+	err := t.eng.archives.Write(d)
 
 	elapsed := time.Since(start)
 
@@ -145,308 +85,3 @@ func (t *databaseTarget) Deliver(
 		database.DeliveryStatusDelivered,
 	)
 }
-
-// archive writes the full event as a row into the target's
-// archive database, honouring the optional per-target expiry and
-// rotation parsed from the target config JSON. With rotation, the
-// event goes to the file for the period of its receive time.
-func (t *databaseTarget) archive(d *database.Delivery) error {
-	webhookID := d.Event.WebhookID
-	if webhookID == "" {
-		return errArchiveMissingWebhookID
-	}
-
-	expiry, err := parseArchiveExpiry(d.Target.Config)
-	if err != nil {
-		return err
-	}
-
-	rotation, err := parseArchiveRotation(d.Target.Config)
-	if err != nil {
-		return err
-	}
-
-	// An event whose stored row was gone before its delivery ran has
-	// no receive time (see Engine.hydrateEvent), and goes to the
-	// file for now.
-	receivedAt := d.Event.CreatedAt
-	if receivedAt.IsZero() {
-		receivedAt = time.Now()
-	}
-
-	w, err := t.writerFor(d.TargetID)
-	if err != nil {
-		return err
-	}
-
-	row := archivedEvent{
-		EventID:      d.Event.ID,
-		WebhookID:    webhookID,
-		EntrypointID: d.Event.EntrypointID,
-		Method:       d.Event.Method,
-		RawQuery:     d.Event.RawQuery,
-		Headers:      d.Event.Headers,
-		Body:         d.Event.Body,
-		ContentType:  d.Event.ContentType,
-	}
-
-	return w.write(row, expiry, archivePeriod(rotation, receivedAt))
-}
-
-// writerFor returns the archive writer for a database target,
-// creating and caching it on first use. Each target has one writer
-// so its close/reopen debounce state is shared across concurrent
-// deliveries, and so a rename and the idle sweep take the same lock
-// as its writes.
-func (t *databaseTarget) writerFor(
-	targetID string,
-) (*archiveWriter, error) {
-	t.mu.Lock()
-	defer t.mu.Unlock()
-
-	w, ok := t.writers[targetID]
-	if !ok {
-		var err error
-
-		w, err = t.newWriter(targetID)
-		if err != nil {
-			return nil, err
-		}
-
-		if t.writers == nil {
-			t.writers = make(map[string]*archiveWriter)
-		}
-
-		t.writers[targetID] = w
-	}
-
-	// A delivery claims the entry: even if the idle sweep created
-	// it moments ago, it now belongs to the registry proper and
-	// the sweep must leave it in place when it finishes.
-	w.sweepOwned = false
-
-	return w, nil
-}
-
-// sweepWriterFor returns the archive writer the idle sweep should
-// prune a target's archive through, together with whether the sweep
-// itself created the registry entry.
-//
-// The sweep must route its prune through the registered writer so
-// the writer's mutex orders it against concurrent writes, but it
-// must never leave a registry entry behind: a sweep that ran
-// concurrently with the target's deletion would otherwise
-// re-create an entry that nothing will ever evict again, which is
-// exactly the leak eviction exists to prevent. An entry the sweep
-// creates is therefore marked sweep-owned and handed back to
-// releaseSweepWriter when the sweep is done.
-func (t *databaseTarget) sweepWriterFor(
-	targetID string,
-) (*archiveWriter, bool, error) {
-	t.mu.Lock()
-	defer t.mu.Unlock()
-
-	w, ok := t.writers[targetID]
-	if ok {
-		return w, false, nil
-	}
-
-	w, err := t.newWriter(targetID)
-	if err != nil {
-		return nil, false, err
-	}
-
-	if t.writers == nil {
-		t.writers = make(map[string]*archiveWriter)
-	}
-
-	w.sweepOwned = true
-	t.writers[targetID] = w
-
-	return w, true, nil
-}
-
-// releaseSweepWriter drops a registry entry that the idle sweep
-// created, so a sweep leaves the registry exactly as it found it.
-//
-// The entry is removed only if it is still the very writer the
-// sweep installed and no delivery has claimed it in the meantime
-// (writerFor clears sweepOwned when it hands a writer to the
-// write path). Both conditions are evaluated under the registry
-// lock, so an eviction that raced the sweep — which removes the
-// entry outright — simply finds nothing left to do here, and a
-// delivery that adopted the writer keeps a registered, evictable
-// one.
-func (t *databaseTarget) releaseSweepWriter(
-	targetID string, w *archiveWriter,
-) {
-	t.mu.Lock()
-	defer t.mu.Unlock()
-
-	cur, ok := t.writers[targetID]
-	if !ok || cur != w || !cur.sweepOwned {
-		return
-	}
-
-	delete(t.writers, targetID)
-}
-
-// newWriter builds the writer for a database target's archive. Its
-// path is the one ArchivePath gives for the webhook and the target as
-// the main database names them now; from then on only rename changes
-// the name the writer uses. It does not touch the archive files.
-func (t *databaseTarget) newWriter(
-	targetID string,
-) (*archiveWriter, error) {
-	if t.eng.dbManager == nil {
-		return nil, errArchiveNoDataDir
-	}
-
-	var target database.Target
-
-	err := t.eng.database.DB().
-		Preload("Webhook").
-		First(&target, "id = ?", targetID).Error
-	if err != nil {
-		return nil, fmt.Errorf(
-			"loading database target %s: %w", targetID, err,
-		)
-	}
-
-	w := newArchiveWriter(
-		ArchivePath(t.eng.dbManager, &target.Webhook, &target),
-		t.eng.log,
-	)
-	w.webhookID = target.WebhookID
-
-	return w, nil
-}
-
-// rename moves every one of a database target's archive files to the
-// name for webhookName and targetName. It goes through the target's
-// writer, so the move holds the lock that writes and the idle sweep
-// take, and later writes use the new name.
-//
-// The writer is created if there is none, and it stays cached. The
-// handlers rename before they save the new name, so until the save
-// the main database still has the old one; a delivery in that window
-// must find this writer rather than build one from the old name.
-func (t *databaseTarget) rename(
-	targetID, webhookName, targetName string,
-) error {
-	w, err := t.writerFor(targetID)
-	if err != nil {
-		return err
-	}
-
-	return w.rename(ArchiveFileName(webhookName, targetName, targetID))
-}
-
-// evict drops a database target's archive writer from the registry
-// and closes its handle, so a deleted target does not leave a
-// writer (and an open archive handle within its debounce window)
-// alive for the process lifetime.
-//
-// The map entry is removed under the registry lock, which is
-// then released before the handle is closed under the writer's
-// own lock: that ordering keeps the registry available to other
-// targets while an in-flight write on this one drains, and
-// closing under the writer's lock means eviction can never race
-// a write.
-//
-// Eviction is idempotent and silent for a target with no writer,
-// which is the common case: only a database target that has
-// received an event or been renamed has one. It never deletes the
-// archive file.
-func (t *databaseTarget) evict(targetID string) {
-	t.mu.Lock()
-
-	w, ok := t.writers[targetID]
-	if ok {
-		delete(t.writers, targetID)
-	}
-
-	t.mu.Unlock()
-
-	if !ok {
-		return
-	}
-
-	w.evict()
-
-	t.eng.log.Info(
-		"evicted archive writer",
-		"target_id", targetID,
-		"path", w.path,
-	)
-}
-
-// evictWebhook evicts, exactly as evict does, the writer of every
-// database target of a webhook.
-func (t *databaseTarget) evictWebhook(webhookID string) {
-	t.mu.Lock()
-
-	var gone []*archiveWriter
-
-	for targetID, w := range t.writers {
-		if w.webhookID == webhookID {
-			delete(t.writers, targetID)
-
-			gone = append(gone, w)
-		}
-	}
-
-	t.mu.Unlock()
-
-	for _, w := range gone {
-		w.evict()
-
-		t.eng.log.Info(
-			"evicted archive writer",
-			"webhook_id", webhookID,
-			"path", w.path,
-		)
-	}
-}
-
-// evictAll evicts every cached archive writer, exactly as evict
-// does for one target. The engine calls it at shutdown, once its
-// workers have returned. Closing the last handle on an archive
-// moves the contents of its -wal into the .db and removes the
-// -wal, so a clean stop leaves each archive as a single file.
-func (t *databaseTarget) evictAll() {
-	t.mu.Lock()
-
-	writers := t.writers
-	t.writers = nil
-
-	t.mu.Unlock()
-
-	for _, w := range writers {
-		w.evict()
-	}
-}
-
-// sweepArchive prunes one database target's archive of rows older
-// than expiry, without requiring a write. A missing archive file is
-// left missing (see sweepExpired), so a sweep never creates an
-// archive for a target that has never received an event.
-//
-// It also never leaves a registry entry behind: an entry it had
-// to create to reach the writer's mutex is released again once
-// the prune is done, so a sweep racing a target deletion cannot
-// resurrect the writer the eviction just dropped.
-func (t *databaseTarget) sweepArchive(
-	targetID string, expiry time.Duration,
-) error {
-	w, created, err := t.sweepWriterFor(targetID)
-	if err != nil {
-		return err
-	}
-
-	if created {
-		defer t.releaseSweepWriter(targetID, w)
-	}
-
-	return w.sweepExpired(expiry)
-}

internal/delivery/target_database_test.go

@@ -3,24 +3,65 @@ package delivery_test
 import (
 	"database/sql"
 	"fmt"
-	"io/fs"
 	"log/slog"
+	"net/http"
 	"os"
 	"path/filepath"
-	"strings"
 	"testing"
 	"time"
 
+	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"gorm.io/driver/sqlite"
 	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
 	_ "modernc.org/sqlite" // Pure Go SQLite driver.
+	"sneak.berlin/go/webhooker/internal/archive"
 	"sneak.berlin/go/webhooker/internal/database"
+	"sneak.berlin/go/webhooker/internal/database/databasetest"
 	"sneak.berlin/go/webhooker/internal/delivery"
 	"sneak.berlin/go/webhooker/internal/gormlog"
 )
 
+// archiveTestWebhookName is the name of every webhook
+// seedDatabaseTarget creates. It is not safe in a file name as it
+// stands, so every archive file name made from it is made safe first.
+const archiveTestWebhookName = "Sweep Test!"
+
+// archiveEnv bundles the pieces a database target test drives: a main
+// configuration database holding webhooks and targets, a delivery
+// engine whose archive writers write into the data directory, and that
+// directory.
+type archiveEnv struct {
+	eng     *delivery.Engine
+	mainDB  *database.Database
+	dataDir string
+}
+
+func setupArchiveTest(t *testing.T) *archiveEnv {
+	t.Helper()
+
+	dataDir := t.TempDir()
+
+	mainDB, err := database.Open(dataDir, slog.New(slog.DiscardHandler))
+	require.NoError(t, err)
+
+	t.Cleanup(func() { _ = mainDB.Close() })
+
+	return &archiveEnv{
+		eng: delivery.NewTestEngineWithDB(
+			mainDB,
+			databasetest.NewWebhookDBManager(t, dataDir),
+			archiveTestLogger(),
+			&http.Client{Timeout: 5 * time.Second},
+			1,
+		),
+		mainDB:  mainDB,
+		dataDir: dataDir,
+	}
+}
+
 func archiveTestLogger() *slog.Logger {
 	return slog.New(slog.NewTextHandler(
 		os.Stderr,
@@ -28,8 +69,85 @@ func archiveTestLogger() *slog.Logger {
 	))
 }
 
+// archivePath returns where the engine keeps a database target's
+// archive file, for the names seedDatabaseTarget gave it.
+func (env *archiveEnv) archivePath(tgt *database.Target) string {
+	return filepath.Join(
+		env.dataDir,
+		archive.FileName(archiveTestWebhookName, tgt.Name, tgt.ID),
+	)
+}
+
+// seedDatabaseTarget creates a webhook with one database target
+// carrying the given target config JSON, and returns the target.
+func (env *archiveEnv) seedDatabaseTarget(
+	t *testing.T, configJSON string,
+) *database.Target {
+	t.Helper()
+
+	wh := &database.Webhook{
+		UserID: uuid.New().String(),
+		Name:   archiveTestWebhookName,
+	}
+	require.NoError(
+		t,
+		env.mainDB.DB().
+			Omit(clause.Associations).
+			Create(wh).Error,
+	)
+
+	tgt := &database.Target{
+		WebhookID:   wh.ID,
+		Name:        "Archive",
+		Type:        database.TargetTypeDatabase,
+		Active:      true,
+		Config:      configJSON,
+		MaxAttempts: 1,
+	}
+	require.NoError(
+		t,
+		env.mainDB.DB().
+			Omit(clause.Associations).
+			Create(tgt).Error,
+	)
+
+	return tgt
+}
+
+// seedDatabaseTargetDelivery seeds a pending delivery of an event
+// to a database target and returns the in-memory delivery the
+// target handler is invoked with.
+func seedDatabaseTargetDelivery(
+	t *testing.T,
+	webhookDB *gorm.DB,
+	event database.Event,
+	tgt *database.Target,
+) *database.Delivery {
+	t.Helper()
+
+	dlv := seedDelivery(
+		t, webhookDB, event.ID, tgt.ID,
+		database.DeliveryStatusPending,
+	)
+
+	d := &database.Delivery{
+		EventID:  event.ID,
+		TargetID: tgt.ID,
+		Status:   database.DeliveryStatusPending,
+		Event:    event,
+		Target: database.Target{
+			Name:   tgt.Name,
+			Type:   database.TargetTypeDatabase,
+			Config: tgt.Config,
+		},
+	}
+	d.ID = dlv.ID
+
+	return d
+}
+
 // openArchiveDBForRead opens an archive file read-only so a
-// test can inspect the rows the writer persisted.
+// test can inspect the rows the database target archived.
 func openArchiveDBForRead(
 	t *testing.T, path string,
 ) *gorm.DB {
@@ -52,26 +170,45 @@ func openArchiveDBForRead(
 	return gdb
 }
 
-// archiveFileSuffixes returns the archive file itself and the
+// countArchivedRows counts the rows in an archive file without
-// SQLite sidecars that accompany an open database. A test that
+// asserting anything, so it is safe to poll from an
-// asserts no archive was created has to check all of them.
+// assert.Eventually condition (which runs off the test
-func archiveFileSuffixes() []string {
+// goroutine, where testify assertions must not be used).
-	return []string{"", "-wal", "-shm"}
+func countArchivedRows(path string) (int64, error) {
+	sqlDB, err := sql.Open(
+		"sqlite", fmt.Sprintf("file:%s?mode=ro", path),
+	)
+	if err != nil {
+		return 0, err
+	}
+
+	defer func() { _ = sqlDB.Close() }()
+
+	gdb, err := gorm.Open(
+		sqlite.Dialector{Conn: sqlDB},
+		&gorm.Config{Logger: gormlog.New(slog.New(slog.DiscardHandler))},
+	)
+	if err != nil {
+		return 0, err
+	}
+
+	var count int64
+
+	err = gdb.Table("archived_events").Count(&count).Error
+	if err != nil {
+		return 0, err
+	}
+
+	return count, nil
 }
 
-// removeArchiveFiles simulates an operator moving the archive
+// archivedRow is the columns of an archive row these tests read.
-// away by deleting the SQLite file and its sidecar files.
+type archivedRow struct {
-func removeArchiveFiles(t *testing.T, path string) {
+	EventID   string
-	t.Helper()
+	WebhookID string
-
+	Method    string
-	for _, suffix := range []string{
+	RawQuery  string
-		"", "-wal", "-shm", "-journal",
+	Body      string
-	} {
-		err := os.Remove(path + suffix)
-		if err != nil && !os.IsNotExist(err) {
-			t.Fatalf("removing %s%s: %v", path, suffix, err)
-		}
-	}
 }
 
 // TestDeliverDatabase_ArchivesEvent verifies that delivering to
@@ -107,9 +244,9 @@ func TestDeliverDatabase_ArchivesEvent(t *testing.T) {
 
 	rdb := openArchiveDBForRead(t, archivePath)
 
-	var rows []delivery.ExportArchivedEvent
+	var rows []archivedRow
 
-	require.NoError(t, rdb.Find(&rows).Error)
+	require.NoError(t, rdb.Table("archived_events").Find(&rows).Error)
 	require.Len(t, rows, 1)
 	assert.Equal(t, event.ID, rows[0].EventID)
 	assert.Equal(t, event.WebhookID, rows[0].WebhookID)
@@ -118,255 +255,6 @@ func TestDeliverDatabase_ArchivesEvent(t *testing.T) {
 	assert.JSONEq(t, `{"archived":true}`, rows[0].Body)
 }
 
-func TestArchiveWriter_WritesRow(t *testing.T) {
-	t.Parallel()
-
-	path := filepath.Join(t.TempDir(), "archive-wh.db")
-	w := delivery.NewExportArchiveWriter(
-		path, archiveTestLogger(), 0,
-	)
-
-	row := delivery.ExportArchivedEvent{
-		EventID:      "ev-1",
-		WebhookID:    "wh-1",
-		EntrypointID: "ep-1",
-		Method:       "POST",
-		Headers:      `{"X":"Y"}`,
-		Body:         `{"hello":"world"}`,
-		ContentType:  "application/json",
-	}
-
-	require.NoError(t, w.Write(row, 0))
-	assert.FileExists(t, path)
-
-	var got []delivery.ExportArchivedEvent
-
-	require.NoError(t, w.DB().Find(&got).Error)
-	require.Len(t, got, 1)
-	assert.Equal(t, "ev-1", got[0].EventID)
-	assert.Equal(t, "wh-1", got[0].WebhookID)
-	assert.Equal(t, "ep-1", got[0].EntrypointID)
-	assert.Equal(t, row.Method, got[0].Method)
-	assert.Equal(t, row.ContentType, got[0].ContentType)
-	assert.JSONEq(t, `{"hello":"world"}`, got[0].Body)
-	assert.False(t, got[0].ArchivedAt.IsZero())
-}
-
-func TestArchiveWriter_RecreatesAfterRemoval(
-	t *testing.T,
-) {
-	t.Parallel()
-
-	path := filepath.Join(t.TempDir(), "archive-wh.db")
-	w := delivery.NewExportArchiveWriter(
-		path, archiveTestLogger(), 0,
-	)
-
-	require.NoError(t, w.Write(
-		delivery.ExportArchivedEvent{EventID: "a"}, 0,
-	))
-	assert.FileExists(t, path)
-
-	// The operator moves the archive away while the handle is
-	// still open.
-	removeArchiveFiles(t, path)
-	require.NoFileExists(t, path)
-
-	// The next write recreates the file with a fresh schema and
-	// only the new row.
-	require.NoError(t, w.Write(
-		delivery.ExportArchivedEvent{EventID: "b"}, 0,
-	))
-	assert.FileExists(t, path)
-
-	var got []delivery.ExportArchivedEvent
-
-	require.NoError(t, w.DB().Find(&got).Error)
-	require.Len(t, got, 1)
-	assert.Equal(t, "b", got[0].EventID)
-}
-
-// TestStatArchive proves StatArchive finds no file before the first
-// write; after a write still held in the -wal, counts the -wal in the
-// size and takes its later time as the last write; and finds no file
-// again once the file has been moved away.
-func TestStatArchive(t *testing.T) {
-	t.Parallel()
-
-	path := filepath.Join(t.TempDir(), "archive-wh.db")
-
-	_, err := delivery.StatArchive(path)
-	require.ErrorIs(t, err, fs.ErrNotExist)
-
-	// With the clock stopped, the reopen debounce never passes, so
-	// the handle stays open after the write.
-	stopped := time.Now()
-	w := delivery.NewExportArchiveWriter(path, archiveTestLogger(), 0)
-	w.SetNow(func() time.Time { return stopped })
-
-	require.NoError(t, w.Write(delivery.ExportArchivedEvent{EventID: "a"}, 0))
-
-	written := time.Date(2026, 1, 2, 3, 4, 5, 0, time.UTC)
-	earlier := written.Add(-time.Hour)
-	require.NoError(t, os.Chtimes(path, earlier, earlier))
-	require.NoError(t, os.Chtimes(path+"-wal", written, written))
-
-	file, err := os.Stat(path)
-	require.NoError(t, err)
-
-	wal, err := os.Stat(path + "-wal")
-	require.NoError(t, err)
-	require.Positive(t, wal.Size())
-
-	got, err := delivery.StatArchive(path)
-	require.NoError(t, err)
-	assert.Equal(t, 1, got.Files)
-	assert.Equal(t, file.Size()+wal.Size(), got.Size)
-	assert.True(t, written.Equal(got.Written), got.Written)
-
-	removeArchiveFiles(t, path)
-
-	_, err = delivery.StatArchive(path)
-	require.ErrorIs(t, err, fs.ErrNotExist)
-}
-
-func TestArchiveWriter_ReopenDebounce(t *testing.T) {
-	t.Parallel()
-
-	const debounce = 2 * time.Second
-
-	path := filepath.Join(t.TempDir(), "archive-wh.db")
-	w := delivery.NewExportArchiveWriter(
-		path, archiveTestLogger(), debounce,
-	)
-
-	// The writer measures its reopen debounce on this clock, which
-	// only the test moves, so how long the host takes between
-	// writes cannot change the result.
-	now := time.Now()
-
-	w.SetNow(func() time.Time { return now })
-
-	require.NoError(t, w.Write(
-		delivery.ExportArchivedEvent{EventID: "a"}, 0,
-	))
-	require.NoError(t, w.Write(
-		delivery.ExportArchivedEvent{EventID: "b"}, 0,
-	))
-
-	// Two writes inside the debounce window trigger only the
-	// initial open — no extra close/reopen.
-	assert.Equal(t, 1, w.Reopens())
-
-	now = now.Add(debounce)
-
-	require.NoError(t, w.Write(
-		delivery.ExportArchivedEvent{EventID: "c"}, 0,
-	))
-
-	// A write after the window elapses closes and reopens once.
-	assert.Equal(t, 2, w.Reopens())
-}
-
-func TestArchiveWriter_ExpiryPrune(t *testing.T) {
-	t.Parallel()
-
-	path := filepath.Join(t.TempDir(), "archive-wh.db")
-	w := delivery.NewExportArchiveWriter(
-		path, archiveTestLogger(), 0,
-	)
-
-	require.NoError(t, w.Open(0))
-
-	old := delivery.ExportArchivedEvent{
-		EventID:    "old",
-		ArchivedAt: time.Now().Add(-2 * time.Hour),
-	}
-	fresh := delivery.ExportArchivedEvent{
-		EventID:    "fresh",
-		ArchivedAt: time.Now(),
-	}
-
-	require.NoError(t, w.DB().Create(&old).Error)
-	require.NoError(t, w.DB().Create(&fresh).Error)
-
-	// Reopening with a one-hour expiry prunes the old row.
-	require.NoError(t, w.Reopen(time.Hour))
-
-	var got []delivery.ExportArchivedEvent
-
-	require.NoError(t, w.DB().Find(&got).Error)
-	require.Len(t, got, 1)
-	assert.Equal(t, "fresh", got[0].EventID)
-}
-
-func TestParseArchiveExpiry(t *testing.T) {
-	t.Parallel()
-
-	cases := []struct {
-		name    string
-		in      string
-		want    time.Duration
-		wantErr bool
-	}{
-		{"empty config", "", 0, false},
-		{"explicit never", `{"expiry":"never"}`, 0, false},
-		{"empty expiry", `{"expiry":""}`, 0, false},
-		{"duration", `{"expiry":"1h"}`, time.Hour, false},
-		{"unparseable", `{"expiry":"nonsense"}`, 0, true},
-		{"zero duration", `{"expiry":"0s"}`, 0, true},
-		{"negative duration", `{"expiry":"-5h"}`, 0, true},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-
-			got, err := delivery.ExportParseArchiveExpiry(tc.in)
-			if tc.wantErr {
-				require.Error(t, err)
-
-				return
-			}
-
-			require.NoError(t, err)
-			assert.Equal(t, tc.want, got)
-		})
-	}
-}
-
-// seedDatabaseTargetDelivery seeds a pending delivery of an event
-// to a database target and returns the in-memory delivery the
-// target handler is invoked with.
-func seedDatabaseTargetDelivery(
-	t *testing.T,
-	webhookDB *gorm.DB,
-	event database.Event,
-	tgt *database.Target,
-) *database.Delivery {
-	t.Helper()
-
-	dlv := seedDelivery(
-		t, webhookDB, event.ID, tgt.ID,
-		database.DeliveryStatusPending,
-	)
-
-	d := &database.Delivery{
-		EventID:  event.ID,
-		TargetID: tgt.ID,
-		Status:   database.DeliveryStatusPending,
-		Event:    event,
-		Target: database.Target{
-			Name:   tgt.Name,
-			Type:   database.TargetTypeDatabase,
-			Config: tgt.Config,
-		},
-	}
-	d.ID = dlv.ID
-
-	return d
-}
-
 // TestDeliverDatabase_ArchiveFailureFailsDelivery verifies that
 // an archive error (here: an unparseable expiry in the target
 // config) fails the delivery loudly: the attempt is recorded as
@@ -416,348 +304,3 @@ func TestDeliverDatabase_ArchiveFailureFailsDelivery(
 		"no archive file should exist for a failed config",
 	)
 }
-
-func TestValidateArchiveExpiry(t *testing.T) {
-	t.Parallel()
-
-	valid := []string{"", "never", "1h", "720h", "30m"}
-	for _, in := range valid {
-		require.NoError(t,
-			delivery.ValidateArchiveExpiry(in),
-			"expiry %q should be accepted", in,
-		)
-	}
-
-	invalid := []string{"nonsense", "7d", "-5h", "0s", "0"}
-	for _, in := range invalid {
-		require.Error(t,
-			delivery.ValidateArchiveExpiry(in),
-			"expiry %q should be rejected", in,
-		)
-	}
-}
-
-// TestArchiveFileName pins the archive file name and the rules
-// that make a webhook or target name safe to put in it.
-func TestArchiveFileName(t *testing.T) {
-	t.Parallel()
-
-	const id = "3f2a1c9e-8d4b-4c1a-9e2f-0a1b2c3d4e5f"
-
-	cases := []struct {
-		name    string
-		webhook string
-		target  string
-		want    string
-	}{
-		{
-			"plain names", "orders", "archive",
-			"archive-orders-archive-" + id + ".db",
-		},
-		{
-			"lowercased", "Orders", "Main Archive",
-			"archive-orders-main-archive-" + id + ".db",
-		},
-		{
-			"a run of other characters is one dash",
-			`a  /\..b`, "c__--d",
-			"archive-a-b-c-d-" + id + ".db",
-		},
-		{
-			"no dash at either end", "  --orders!! ", "(archive)",
-			"archive-orders-archive-" + id + ".db",
-		},
-		{
-			"path separators", "../../etc/passwd", "a/b",
-			"archive-etc-passwd-a-b-" + id + ".db",
-		},
-		{
-			"letters outside ASCII are dropped",
-			"Bestellungen Größe", "café",
-			"archive-bestellungen-gr-e-caf-" + id + ".db",
-		},
-		{
-			"nothing left is unnamed", "", "!!!",
-			"archive-unnamed-unnamed-" + id + ".db",
-		},
-		{
-			"cut to 40 characters", strings.Repeat("a", 50), "x",
-			"archive-" + strings.Repeat("a", 40) + "-x-" + id + ".db",
-		},
-		{
-			"no dash left by the cut",
-			strings.Repeat("a", 39) + " b", "x",
-			"archive-" + strings.Repeat("a", 39) + "-x-" + id + ".db",
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-
-			assert.Equal(
-				t, tc.want,
-				delivery.ArchiveFileName(tc.webhook, tc.target, id),
-			)
-		})
-	}
-}
-
-// TestDeliverDatabase_EachTargetHasItsOwnArchive proves two
-// database targets of one webhook archive into separate files.
-func TestDeliverDatabase_EachTargetHasItsOwnArchive(t *testing.T) {
-	t.Parallel()
-
-	env := setupArchiveTest(t)
-	first := env.seedDatabaseTarget(t, "")
-	second := env.addDatabaseTarget(t, first.WebhookID, "")
-
-	webhookDB := testWebhookDB(t)
-	event := seedEvent(t, webhookDB, `{"n":1}`)
-
-	for _, tgt := range []*database.Target{first, second} {
-		env.eng.ExportDeliverDatabase(
-			webhookDB,
-			seedDatabaseTargetDelivery(t, webhookDB, event, tgt),
-		)
-	}
-
-	require.NotEqual(
-		t, env.archivePath(first), env.archivePath(second),
-	)
-	assert.Equal(
-		t, []string{event.ID},
-		archivedEventIDs(t, env.archivePath(first)),
-	)
-	assert.Equal(
-		t, []string{event.ID},
-		archivedEventIDs(t, env.archivePath(second)),
-	)
-}
-
-// TestRename_MovesTheFile proves a rename moves the archive, rows
-// and all, and that later writes go to the new name.
-func TestRename_MovesTheFile(t *testing.T) {
-	t.Parallel()
-
-	env := setupArchiveTest(t)
-	tgt := env.seedDatabaseTarget(t, "")
-	oldPath := env.archivePath(tgt)
-
-	webhookDB := testWebhookDB(t)
-	first := seedEvent(t, webhookDB, `{"n":1}`)
-	env.eng.ExportDeliverDatabase(
-		webhookDB, seedDatabaseTargetDelivery(t, webhookDB, first, tgt),
-	)
-	require.FileExists(t, oldPath)
-
-	require.NoError(
-		t, env.eng.Rename(tgt.ID, "Orders", "Long Term"),
-	)
-
-	newPath := filepath.Join(
-		env.dataDir, "archive-orders-long-term-"+tgt.ID+".db",
-	)
-
-	assert.NoFileExists(t, oldPath)
-	assert.Equal(t, []string{first.ID}, archivedEventIDs(t, newPath))
-
-	second := seedEvent(t, webhookDB, `{"n":2}`)
-	env.eng.ExportDeliverDatabase(
-		webhookDB,
-		seedDatabaseTargetDelivery(t, webhookDB, second, tgt),
-	)
-
-	assert.ElementsMatch(
-		t, []string{first.ID, second.ID},
-		archivedEventIDs(t, newPath),
-	)
-	assert.NoFileExists(
-		t, oldPath, "a write after the rename must use the new name",
-	)
-}
-
-// TestRename_NeverReplacesAFile plants a file at the new name, once
-// the .db alone, once a lone -wal and once a lone -shm, and proves
-// each time that the rename is refused, the planted file survives,
-// and the archive keeps its name and its rows.
-func TestRename_NeverReplacesAFile(t *testing.T) {
-	t.Parallel()
-
-	for _, suffix := range archiveFileSuffixes() {
-		t.Run("planted .db"+suffix, func(t *testing.T) {
-			t.Parallel()
-
-			env := setupArchiveTest(t)
-			tgt := env.seedDatabaseTarget(t, "")
-			oldPath := env.archivePath(tgt)
-
-			webhookDB := testWebhookDB(t)
-			first := seedEvent(t, webhookDB, `{"n":1}`)
-			env.eng.ExportDeliverDatabase(
-				webhookDB,
-				seedDatabaseTargetDelivery(t, webhookDB, first, tgt),
-			)
-
-			newPath := filepath.Join(
-				env.dataDir, "archive-orders-long-term-"+tgt.ID+".db",
-			)
-			plantedPath := newPath + suffix
-			require.NoError(
-				t, os.WriteFile(plantedPath, []byte("planted"), 0o600),
-			)
-
-			require.ErrorIs(
-				t, env.eng.Rename(tgt.ID, "Orders", "Long Term"),
-				delivery.ErrArchiveNameTaken,
-			)
-
-			//nolint:gosec // reads the file the test planted under t.TempDir()
-			planted, err := os.ReadFile(plantedPath)
-			require.NoError(t, err)
-			assert.Equal(t, "planted", string(planted))
-
-			second := seedEvent(t, webhookDB, `{"n":2}`)
-			env.eng.ExportDeliverDatabase(
-				webhookDB,
-				seedDatabaseTargetDelivery(t, webhookDB, second, tgt),
-			)
-
-			assert.ElementsMatch(
-				t, []string{first.ID, second.ID},
-				archivedEventIDs(t, oldPath),
-			)
-		})
-	}
-}
-
-// TestRename_BeforeTheNameIsSaved covers the order the handlers
-// use: they rename before they save the new name, so a delivery in
-// between must write under the new name although the main database
-// still has the old one. It also shows that renaming an archive that
-// does not exist yet is not an error.
-func TestRename_BeforeTheNameIsSaved(t *testing.T) {
-	t.Parallel()
-
-	env := setupArchiveTest(t)
-	tgt := env.seedDatabaseTarget(t, "")
-
-	require.NoError(
-		t, env.eng.Rename(tgt.ID, "Orders", "Archive"),
-	)
-
-	webhookDB := testWebhookDB(t)
-	event := seedEvent(t, webhookDB, `{"n":1}`)
-	env.eng.ExportDeliverDatabase(
-		webhookDB, seedDatabaseTargetDelivery(t, webhookDB, event, tgt),
-	)
-
-	assert.FileExists(
-		t,
-		filepath.Join(
-			env.dataDir, "archive-orders-archive-"+tgt.ID+".db",
-		),
-	)
-	assert.NoFileExists(t, env.archivePath(tgt))
-}
-
-// TestArchiveWriter_RenameMovesSidecars proves a rename carries
-// the -wal and -shm a crash can leave beside an archive no handle
-// has opened since. SQLite finds them by name, so a -wal left
-// behind would lose the transactions it holds.
-func TestArchiveWriter_RenameMovesSidecars(t *testing.T) {
-	t.Parallel()
-
-	dir := t.TempDir()
-	oldPath := filepath.Join(dir, "archive-old.db")
-	newPath := filepath.Join(dir, "archive-new.db")
-
-	for _, suffix := range archiveFileSuffixes() {
-		require.NoError(
-			t, os.WriteFile(oldPath+suffix, []byte(suffix), 0o600),
-		)
-	}
-
-	w := delivery.NewExportArchiveWriter(
-		oldPath, archiveTestLogger(), 0,
-	)
-
-	require.NoError(t, w.Rename("archive-new.db"))
-
-	for _, suffix := range archiveFileSuffixes() {
-		assert.NoFileExists(t, oldPath+suffix)
-		assert.FileExists(t, newPath+suffix)
-	}
-
-	assert.Equal(t, newPath, w.Path())
-}
-
-// TestArchiveWriter_RenameMovesBackOnFailure makes the -wal fail to
-// move after the .db has moved, and proves the .db is moved back, so
-// the archive is never split across two names. The new name is 255
-// bytes, the longest a file name may be, so the .db can take it but
-// the -wal, four bytes longer, cannot.
-func TestArchiveWriter_RenameMovesBackOnFailure(t *testing.T) {
-	t.Parallel()
-
-	dir := t.TempDir()
-	oldPath := filepath.Join(dir, "archive-old.db")
-	newName := strings.Repeat("a", 252) + ".db"
-
-	for _, suffix := range archiveFileSuffixes() {
-		require.NoError(
-			t, os.WriteFile(oldPath+suffix, []byte(suffix), 0o600),
-		)
-	}
-
-	w := delivery.NewExportArchiveWriter(
-		oldPath, archiveTestLogger(), 0,
-	)
-
-	require.Error(t, w.Rename(newName))
-
-	for _, suffix := range archiveFileSuffixes() {
-		assert.FileExists(t, oldPath+suffix)
-	}
-
-	assert.NoFileExists(t, filepath.Join(dir, newName))
-	assert.Equal(t, oldPath, w.Path())
-}
-
-// TestArchiveWriter_RenameMovesBackEveryFile renames a target with a
-// file without a period and a file for a month, and proves that when
-// the month's file fails to move, the file already moved is moved back:
-// both files are under the old name with their rows, and nothing is
-// under the new name. The new name is 251 bytes, so the file without a
-// period, with its -wal and -shm, can take it, but the month's file,
-// eight bytes longer, cannot.
-func TestArchiveWriter_RenameMovesBackEveryFile(t *testing.T) {
-	t.Parallel()
-
-	dir := t.TempDir()
-	oldPath := filepath.Join(dir, "archive-old.db")
-	monthPath := filepath.Join(dir, "archive-old-2026-03.db")
-	w := delivery.NewExportArchiveWriter(oldPath, archiveTestLogger(), 0)
-
-	require.NoError(t, w.WritePeriod(
-		delivery.ExportArchivedEvent{EventID: "in-none"}, 0, "",
-	))
-	require.NoError(t, w.WritePeriod(
-		delivery.ExportArchivedEvent{EventID: "in-month"}, 0, "2026-03",
-	))
-
-	require.Error(t, w.Rename(strings.Repeat("a", 248)+".db"))
-
-	assert.Equal(t, []string{"in-none"}, archivedEventIDs(t, oldPath))
-	assert.Equal(t, []string{"in-month"}, archivedEventIDs(t, monthPath))
-
-	entries, err := os.ReadDir(dir)
-	require.NoError(t, err)
-
-	for _, entry := range entries {
-		assert.True(t, strings.HasPrefix(entry.Name(), "archive-old"),
-			"%s is not under the old name", entry.Name())
-	}
-
-	assert.Equal(t, oldPath, w.Path())
-}

internal/delivery/target_headers_test.go

@@ -189,6 +189,7 @@ func TestNewTargetConfigForm(t *testing.T) {
 		Config: `{"url":"https://example.com/h",` +
 			`"headers":{"Authorization":"Bearer abc"},` +
 			`"timeout":9}`,
+		MaxAttempts: 1,
 	})
 	require.NoError(t, err)
 	assert.Equal(t, "https://example.com/h", form.URL)
@@ -196,8 +197,9 @@ func TestNewTargetConfigForm(t *testing.T) {
 	assert.Equal(t, "9", form.Timeout)
 
 	form, err = delivery.NewTargetConfigForm(&database.Target{
-		Type:   database.TargetTypeSlack,
+		Type:        database.TargetTypeSlack,
-		Config: `{"webhookUrl":"https://hooks.example/s"}`,
+		Config:      `{"webhookUrl":"https://hooks.example/s"}`,
+		MaxAttempts: 1,
 	})
 	require.NoError(t, err)
 	assert.Equal(t, "https://hooks.example/s", form.URL)
@@ -242,9 +244,9 @@ func TestNewTargetConfigForm_UnreadableConfigErrors(t *testing.T) {
 	t.Parallel()
 
 	cases := []*database.Target{
-		{Type: database.TargetTypeHTTP, Config: "not json"},
+		{Type: database.TargetTypeHTTP, Config: "not json", MaxAttempts: 1},
-		{Type: database.TargetTypeHTTP, Config: `{}`},
+		{Type: database.TargetTypeHTTP, Config: `{}`, MaxAttempts: 1},
-		{Type: database.TargetTypeSlack, Config: ""},
+		{Type: database.TargetTypeSlack, Config: "", MaxAttempts: 1},
 		{
 			Type:   database.TargetTypeDatabase,
 			Config: `{"expiry":"soon"}`,

internal/delivery/target_http.go

@@ -53,34 +53,72 @@ type httpCore struct {
 }
 
 // deliver runs one delivery attempt through the retry core.
-// A maxRetries of 0 is fire-and-forget: a single attempt is
+// A maxAttempts of 1 is a single attempt, recorded without
-// recorded and no circuit breaker is consulted. A positive
+// consulting a circuit breaker. A higher maxAttempts gates the
-// maxRetries gates the attempt on the circuit breaker and
+// attempt on the circuit breaker and schedules a backed-off retry
-// schedules a backed-off retry on failure.
+// on failure, until maxAttempts attempts have been made.
+//
+// ctx is the context attempt sends its request with. Stopping the
+// engine cancels it; see interruptedByStop.
 func (c *httpCore) deliver(
+	ctx context.Context,
 	webhookDB *gorm.DB,
 	d *database.Delivery,
 	task *Task,
 	sched Scheduler,
-	maxRetries int,
+	maxAttempts int,
 	attempt func() attemptResult,
 ) {
-	if maxRetries == 0 {
+	if maxAttempts == 1 {
-		c.fireAndForget(webhookDB, d, attempt())
+		c.fireAndForget(ctx, webhookDB, d, attempt())
 
 		return
 	}
 
 	c.withRetry(
-		webhookDB, d, task, sched, maxRetries, attempt,
+		ctx, webhookDB, d, task, sched, maxAttempts, attempt,
 	)
 }
 
+// interruptedByStop reports whether an attempt failed because the
+// engine is stopping, which cancels the context its request is made
+// with. Such an attempt is not recorded: no DeliveryResult, no circuit
+// breaker outcome, no status change, no count in the attempt metrics.
+// The delivery stays pending or retrying, and the recovery routine
+// sends it again on the next start.
+//
+// A target's own timeout leaves that context alone, so its attempt is
+// still recorded as the failure it is.
+func (c *httpCore) interruptedByStop(
+	ctx context.Context,
+	d *database.Delivery,
+	res attemptResult,
+) bool {
+	if res.success || ctx.Err() == nil {
+		return false
+	}
+
+	c.eng.log.Warn(
+		"delivery attempt interrupted by shutdown; not recorded, "+
+			"it is sent again on the next start",
+		"delivery_id", d.ID,
+		"event_id", d.EventID,
+		"target_id", d.TargetID,
+	)
+
+	return true
+}
+
 func (c *httpCore) fireAndForget(
+	ctx context.Context,
 	webhookDB *gorm.DB,
 	d *database.Delivery,
 	res attemptResult,
 ) {
+	if c.interruptedByStop(ctx, d, res) {
+		return
+	}
+
 	c.eng.observeAttempt(d.Target.Type, res.elapsed())
 
 	err := c.eng.recordResult(
@@ -110,11 +148,12 @@ func (c *httpCore) fireAndForget(
 }
 
 func (c *httpCore) withRetry(
+	ctx context.Context,
 	webhookDB *gorm.DB,
 	d *database.Delivery,
 	task *Task,
 	sched Scheduler,
-	maxRetries int,
+	maxAttempts int,
 	attempt func() attemptResult,
 ) {
 	cb := c.getCircuitBreaker(task.TargetID)
@@ -131,6 +170,10 @@ func (c *httpCore) withRetry(
 
 	res := attempt()
 
+	if c.interruptedByStop(ctx, d, res) {
+		return
+	}
+
 	c.eng.observeAttempt(d.Target.Type, res.elapsed())
 
 	err := c.eng.recordResult(
@@ -162,7 +205,7 @@ func (c *httpCore) withRetry(
 	cb.RecordFailure()
 
 	c.handleRetry(
-		webhookDB, d, task, sched, maxRetries, attemptNum,
+		webhookDB, d, task, sched, maxAttempts, attemptNum,
 	)
 }
 
@@ -223,10 +266,10 @@ func (c *httpCore) handleRetry(
 	d *database.Delivery,
 	task *Task,
 	sched Scheduler,
-	maxRetries int,
+	maxAttempts int,
 	attemptNum int,
 ) {
-	if attemptNum >= maxRetries {
+	if attemptNum >= maxAttempts {
 		c.eng.settleStatus(
 			webhookDB, d, d.Target.Type,
 			database.DeliveryStatusFailed,
@@ -291,7 +334,8 @@ func (c *httpCore) publishCircuitState(
 
 // remainingBackoff returns how long remains of the backoff
 // window for the last attempt of a recovered retrying
-// delivery. It implements rescheduler.
+// delivery: zero once it has passed, or when the last attempt
+// cannot be read. It implements rescheduler.
 func (c *httpCore) remainingBackoff(
 	webhookDB *gorm.DB,
 	deliveryID string,
@@ -314,29 +358,6 @@ func (c *httpCore) remainingBackoff(
 	return max(remaining, 0)
 }
 
-// backoffElapsed reports whether the backoff window for the
-// last attempt of a retrying delivery has passed. It
-// implements rescheduler.
-func (c *httpCore) backoffElapsed(
-	webhookDB *gorm.DB,
-	deliveryID string,
-	attemptNum int,
-) bool {
-	var lastResult database.DeliveryResult
-
-	err := webhookDB.
-		Where("delivery_id = ?", deliveryID).
-		Order("created_at DESC").
-		First(&lastResult).Error
-	if err != nil {
-		return true
-	}
-
-	backoff := Backoff(attemptNum)
-
-	return time.Since(lastResult.CreatedAt) >= backoff
-}
-
 // Backoff is how long an http or slack target with retries waits after
 // a delivery's failed attempt attemptNum before trying it again.
 func Backoff(attemptNum int) time.Duration {
@@ -395,8 +416,8 @@ func (t *httpTarget) Deliver(
 	}
 
 	t.deliver(
-		webhookDB, d, task, sched,
+		ctx, webhookDB, d, task, sched,
-		d.Target.MaxRetries, attempt,
+		d.Target.MaxAttempts, attempt,
 	)
 }
 

internal/delivery/target_http_query_test.go

@@ -47,7 +47,7 @@ func deliverWithQuery(t *testing.T, cfg string) database.DeliveryResult {
 		database.DeliveryStatusPending,
 	)
 	task := iTask(
-		d, event, s.WebhookID, d.TargetID, "query", cfg, 0, 1, &event.Body,
+		d, event, s.WebhookID, d.TargetID, "query", cfg, 1, 1, &event.Body,
 	)
 	task.RawQuery = eventQuery
 
@@ -144,8 +144,9 @@ func TestDeliverHTTP_ForwardedQueryKeepsTheTargetURLMasked(t *testing.T) {
 	t.Cleanup(ts.Close)
 
 	target := &database.Target{
-		Type:   database.TargetTypeHTTP,
+		Type:        database.TargetTypeHTTP,
-		Config: httpTargetConfig(t, ts.URL+"/in?token="+secret, true),
+		Config:      httpTargetConfig(t, ts.URL+"/in?token="+secret, true),
+		MaxAttempts: 1,
 	}
 
 	deliverWithQuery(t, target.Config)

internal/delivery/target_redact_test.go

@@ -22,8 +22,9 @@ func TestRedactor_RemovesSlackWebhookURL(t *testing.T) {
 	t.Parallel()
 
 	r := delivery.NewRedactor(&database.Target{
-		Type:   database.TargetTypeSlack,
+		Type:        database.TargetTypeSlack,
-		Config: `{"webhookUrl":"` + redactWebhookURL + `"}`,
+		Config:      `{"webhookUrl":"` + redactWebhookURL + `"}`,
+		MaxAttempts: 1,
 	})
 
 	got := r.Redact("no_service for " + redactWebhookURL)
@@ -52,8 +53,9 @@ func TestRedactor_RemovesSecretSeveredByACut(t *testing.T) {
 	t.Parallel()
 
 	r := delivery.NewRedactor(&database.Target{
-		Type:   database.TargetTypeSlack,
+		Type:        database.TargetTypeSlack,
-		Config: `{"webhookUrl":"` + redactWebhookURL + `"}`,
+		Config:      `{"webhookUrl":"` + redactWebhookURL + `"}`,
+		MaxAttempts: 1,
 	})
 
 	// Every cut position inside the credential, not just a
@@ -96,6 +98,7 @@ func TestRedactor_RedactsCredentialShapedHeaderValues(
 			`"X-Credential":"HHHHHHHHHHHH",` +
 			`"Accept":"application/json",` +
 			`"User-Agent":"webhooker/1.0"}}`,
+		MaxAttempts: 1,
 	})
 
 	for _, secret := range []string{
@@ -136,6 +139,7 @@ func TestRedactor_IgnoresVeryShortHeaderValues(t *testing.T) {
 		Type: database.TargetTypeHTTP,
 		Config: `{"url":"https://example.com/in",` +
 			`"headers":{"X-Api-Key":"ab"}}`,
+		MaxAttempts: 1,
 	})
 
 	const response = "rabbit"
@@ -150,8 +154,9 @@ func TestRedactor_RemovesBarePath(t *testing.T) {
 	t.Parallel()
 
 	r := delivery.NewRedactor(&database.Target{
-		Type:   database.TargetTypeSlack,
+		Type:        database.TargetTypeSlack,
-		Config: `{"webhookUrl":"` + redactWebhookURL + `"}`,
+		Config:      `{"webhookUrl":"` + redactWebhookURL + `"}`,
+		MaxAttempts: 1,
 	})
 
 	got := r.Redact("POST " + redactSecretPath + " 404")
@@ -183,8 +188,9 @@ func TestRedactor_RemovesHTTPURLQueryAndUserinfo(t *testing.T) {
 	raw := dest.String()
 
 	r := delivery.NewRedactor(&database.Target{
-		Type:   database.TargetTypeHTTP,
+		Type:        database.TargetTypeHTTP,
-		Config: `{"url":"` + raw + `"}`,
+		Config:      `{"url":"` + raw + `"}`,
+		MaxAttempts: 1,
 	})
 
 	for _, echoed := range []string{
@@ -232,8 +238,9 @@ func TestRedactor_RemovesEchoedQueryOfURLWithoutPath(t *testing.T) {
 		"https://example.com?token=" + secret,
 	} {
 		r := delivery.NewRedactor(&database.Target{
-			Type:   database.TargetTypeHTTP,
+			Type:        database.TargetTypeHTTP,
-			Config: `{"url":"` + dest + `"}`,
+			Config:      `{"url":"` + dest + `"}`,
+			MaxAttempts: 1,
 		})
 
 		for echoed, want := range echoes {
@@ -253,8 +260,9 @@ func TestRedactor_LeavesUnrelatedTextAlone(t *testing.T) {
 	const response = "ok=false error=channel_not_found"
 
 	r := delivery.NewRedactor(&database.Target{
-		Type:   database.TargetTypeSlack,
+		Type:        database.TargetTypeSlack,
-		Config: `{"webhookUrl":"` + redactWebhookURL + `"}`,
+		Config:      `{"webhookUrl":"` + redactWebhookURL + `"}`,
+		MaxAttempts: 1,
 	})
 
 	assert.Equal(t, response, r.Redact(response))
@@ -279,8 +287,9 @@ func TestRedactor_EmptyUserinfoDoesNotShredTheBody(t *testing.T) {
 	require.Empty(t, parsed.User.String())
 
 	r := delivery.NewRedactor(&database.Target{
-		Type:   database.TargetTypeHTTP,
+		Type:        database.TargetTypeHTTP,
-		Config: `{"url":"` + dest + `"}`,
+		Config:      `{"url":"` + dest + `"}`,
+		MaxAttempts: 1,
 	})
 
 	const body = "ok=false error=channel_not_found"
@@ -314,8 +323,8 @@ func TestRedactor_ZeroValueAndConfiglessTargets(t *testing.T) {
 	for _, tgt := range []database.Target{
 		{Type: database.TargetTypeLog},
 		{Type: database.TargetTypeDatabase},
-		{Type: database.TargetTypeSlack, Config: "not json"},
+		{Type: database.TargetTypeSlack, Config: "not json", MaxAttempts: 1},
-		{Type: database.TargetTypeHTTP, Config: ""},
+		{Type: database.TargetTypeHTTP, Config: "", MaxAttempts: 1},
 	} {
 		assert.Equal(
 			t, text,

internal/delivery/target_slack.go

@@ -30,9 +30,8 @@ type SlackTargetConfig struct {
 // slackTarget delivers events to Slack incoming webhooks. It
 // formats the event into a Slack message and posts it as
 // JSON. It shares the retry core with the HTTP target: a
-// MaxRetries of 0 stays single-attempt fire-and-forget
+// MaxAttempts of 1 is a single attempt, while a higher one
-// (preserving existing Slack targets), while a positive
+// adds backoff and circuit breaking.
-// MaxRetries adds backoff and circuit breaking.
 type slackTarget struct {
 	*httpCore
 
@@ -82,8 +81,8 @@ func (t *slackTarget) Deliver(
 	}
 
 	t.deliver(
-		webhookDB, d, task, sched,
+		ctx, webhookDB, d, task, sched,
-		d.Target.MaxRetries, attempt,
+		d.Target.MaxAttempts, attempt,
 	)
 }
 

internal/delivery/terminal_state_test.go

@@ -178,7 +178,7 @@ func TestRecoverSingleRetry_TargetDeleted(t *testing.T) {
 	)
 
 	s.Engine.ExportRecoverWebhookDeliveries(
-		context.Background(), s.WebhookID,
+		context.Background(), s.WebhookID, atStart,
 	)
 
 	iAssertStatus(
@@ -201,7 +201,7 @@ func TestRecoverSingleRetry_TargetDeleted(t *testing.T) {
 	)
 }
 
-func TestSweepSingleRetry_TargetDeleted(t *testing.T) {
+func TestRecoverSingleRetry_OnTick_TargetDeleted(t *testing.T) {
 	t.Parallel()
 
 	s := newISetup(t)
@@ -218,11 +218,11 @@ func TestSweepSingleRetry_TargetDeleted(t *testing.T) {
 	// Twice, because the bug was an error the sweep repeated every
 	// minute for the life of the database: the second sweep must
 	// find nothing left to do.
-	s.Engine.ExportSweepWebhookRetries(
+	s.Engine.ExportRecoverWebhookDeliveries(
-		context.Background(), s.WebhookID,
+		context.Background(), s.WebhookID, onTick,
 	)
-	s.Engine.ExportSweepWebhookRetries(
+	s.Engine.ExportRecoverWebhookDeliveries(
-		context.Background(), s.WebhookID,
+		context.Background(), s.WebhookID, onTick,
 	)
 
 	iAssertStatus(
@@ -239,10 +239,11 @@ func TestSweepSingleRetry_TargetDeleted(t *testing.T) {
 	assert.Zero(t, s.Engine.ExportInflightHeld())
 }
 
-// TestSweepSingleRetry_TargetNeverExisted covers the other half of the
+// TestRecoverSingleRetry_OnTick_TargetNeverExisted covers the other
-// soft-delete distinction: an id with no row at all, deleted or
+// half of the soft-delete distinction: an id with no row at all,
-// otherwise, must not be reported as something the operator deleted.
+// deleted or otherwise, must not be reported as something the operator
-func TestSweepSingleRetry_TargetNeverExisted(t *testing.T) {
+// deleted.
+func TestRecoverSingleRetry_OnTick_TargetNeverExisted(t *testing.T) {
 	t.Parallel()
 
 	s := newISetup(t)
@@ -264,8 +265,8 @@ func TestSweepSingleRetry_TargetNeverExisted(t *testing.T) {
 
 	iSeedFailedResult(t, s.WebhookDB, d.ID)
 
-	s.Engine.ExportSweepWebhookRetries(
+	s.Engine.ExportRecoverWebhookDeliveries(
-		context.Background(), s.WebhookID,
+		context.Background(), s.WebhookID, onTick,
 	)
 
 	iAssertStatus(
@@ -303,8 +304,8 @@ func TestFailMissingTarget_WritesNoTargetRow(
 		database.DeliveryStatusRetrying,
 	)
 
-	s.Engine.ExportSweepWebhookRetries(
+	s.Engine.ExportRecoverWebhookDeliveries(
-		context.Background(), s.WebhookID,
+		context.Background(), s.WebhookID, onTick,
 	)
 
 	iAssertStatus(
@@ -546,7 +547,7 @@ func TestRecoverSingleRetry_TargetUnreadable_LeavesDeliveryAlone(
 	require.NoError(t, sqlDB.Close())
 
 	s.Engine.ExportRecoverRetryingDeliveries(
-		s.WebhookDB, s.WebhookID,
+		context.Background(), s.WebhookDB, s.WebhookID,
 	)
 
 	iAssertStatus(
@@ -564,7 +565,7 @@ func TestRecoverSingleRetry_TargetUnreadable_LeavesDeliveryAlone(
 
 // --- 4. A pending delivery whose target is gone ---
 
-func TestRecoverPending_TargetDeleted(t *testing.T) {
+func TestRecoverPendingDeliveries_TargetDeleted(t *testing.T) {
 	t.Parallel()
 
 	s := newISetup(t)
@@ -577,7 +578,7 @@ func TestRecoverPending_TargetDeleted(t *testing.T) {
 	)
 
 	s.Engine.ExportRecoverWebhookDeliveries(
-		context.Background(), s.WebhookID,
+		context.Background(), s.WebhookID, atStart,
 	)
 
 	iAssertStatus(
@@ -600,10 +601,10 @@ func TestRecoverPending_TargetDeleted(t *testing.T) {
 	)
 }
 
-// TestRecoverPending_TargetDeleted_LeavesAnOwnedDeliveryAlone: the
+// TestRecoverPendingDeliveries_TargetDeleted_LeavesAnOwnedDeliveryAlone:
-// terminal write takes ownership like every other recovery write, so a
+// the terminal write takes ownership like every other recovery write, so
-// delivery the engine still holds is not failed underneath its worker.
+// a delivery the engine still holds is not failed underneath its worker.
-func TestRecoverPending_TargetDeleted_LeavesAnOwnedDeliveryAlone(
+func TestRecoverPendingDeliveries_TargetDeleted_LeavesAnOwnedDeliveryAlone(
 	t *testing.T,
 ) {
 	t.Parallel()
@@ -620,7 +621,7 @@ func TestRecoverPending_TargetDeleted_LeavesAnOwnedDeliveryAlone(
 	require.True(t, s.Engine.ExportRetainDelivery(deliveryID))
 
 	s.Engine.ExportRecoverWebhookDeliveries(
-		context.Background(), s.WebhookID,
+		context.Background(), s.WebhookID, atStart,
 	)
 
 	iAssertStatus(
@@ -675,18 +676,18 @@ func TestFailMissingTarget_LeavesASettledDeliveryAlone(
 	assert.Zero(t, s.Engine.ExportInflightHeld())
 }
 
-// TestSweepPending_TargetDeleted sweeps twice over a batch that also
+// TestRecoverPendingDeliveries_OnTick_TargetDeleted sweeps twice over a
-// holds a healthy stranded delivery. The one whose target is gone is
+// batch that also holds a healthy stranded delivery. The one whose
-// failed once and then left alone; the healthy one is queued by the
+// target is gone is failed once and then left alone; the healthy one is
-// first sweep and not again by the second.
+// queued by the first sweep and not again by the second.
-func TestSweepPending_TargetDeleted(t *testing.T) {
+func TestRecoverPendingDeliveries_OnTick_TargetDeleted(t *testing.T) {
 	t.Parallel()
 
 	liveTargetID := uuid.New().String()
 	s := fSweepSetup(t, liveTargetID, "still-there")
 
 	deliveryID := tSeedDeletedTarget(
-		t, s, "gone-on-pending-sweep", "http://example.com/hook",
+		t, s, "gone-while-pending-on-tick", "http://example.com/hook",
 		database.DeliveryStatusPending,
 	)
 	rAgePending(t, s.WebhookDB, deliveryID)
@@ -703,7 +704,7 @@ func TestSweepPending_TargetDeleted(t *testing.T) {
 
 	ctx := context.Background()
 
-	s.Engine.ExportSweepWebhookRetries(ctx, s.WebhookID)
+	s.Engine.ExportRecoverWebhookDeliveries(ctx, s.WebhookID, onTick)
 
 	tasks := fDrain(s.Engine)
 	require.Len(t, tasks, 1,
@@ -711,7 +712,7 @@ func TestSweepPending_TargetDeleted(t *testing.T) {
 	)
 	assert.Equal(t, healthy.ID, tasks[0].DeliveryID)
 
-	s.Engine.ExportSweepWebhookRetries(ctx, s.WebhookID)
+	s.Engine.ExportRecoverWebhookDeliveries(ctx, s.WebhookID, onTick)
 
 	assert.Empty(t, fDrain(s.Engine),
 		"the second sweep queued a delivery again",
@@ -724,7 +725,7 @@ func TestSweepPending_TargetDeleted(t *testing.T) {
 
 	last := tLastResult(t, s, deliveryID, 2)
 
-	assert.Contains(t, last.Error, "gone-on-pending-sweep")
+	assert.Contains(t, last.Error, "gone-while-pending-on-tick")
 	assert.Contains(t, last.Error, "was deleted")
 }
 
@@ -743,7 +744,7 @@ func TestSendRecoveredDeliveries_TargetMissingFromMap(
 
 	iCreateTarget(
 		t, s.MainDB, targetID, s.WebhookID, "found-on-lookup",
-		database.TargetTypeLog, "", 0,
+		database.TargetTypeLog, "", 1,
 	)
 
 	event := iSeedEvent(
@@ -775,11 +776,11 @@ func TestSendRecoveredDeliveries_TargetMissingFromMap(
 	)
 }
 
-// TestRecoverPending_TargetUnreadable_LeavesDeliveryAlone: a failed
+// TestRecoverPendingDeliveries_TargetUnreadable_LeavesDeliveryAlone: a
-// read of the main database is not a deleted target. Restart recovery
+// failed read of the main database is not a deleted target. At start the
-// holds every pending delivery of the webhook in one batch, so failing
+// recovery routine holds every pending delivery of the webhook in one
-// on this would fail all of them.
+// batch, so failing on this would fail all of them.
-func TestRecoverPending_TargetUnreadable_LeavesDeliveryAlone(
+func TestRecoverPendingDeliveries_TargetUnreadable_LeavesDeliveryAlone(
 	t *testing.T,
 ) {
 	t.Parallel()
@@ -790,7 +791,7 @@ func TestRecoverPending_TargetUnreadable_LeavesDeliveryAlone(
 
 	iCreateTarget(
 		t, s.MainDB, targetID, s.WebhookID, "healthy",
-		database.TargetTypeLog, "", 0,
+		database.TargetTypeLog, "", 1,
 	)
 
 	event := iSeedEvent(
@@ -807,7 +808,7 @@ func TestRecoverPending_TargetUnreadable_LeavesDeliveryAlone(
 	require.NoError(t, sqlDB.Close())
 
 	s.Engine.ExportRecoverPendingDeliveries(
-		context.Background(), s.WebhookDB, s.WebhookID,
+		context.Background(), s.WebhookDB, s.WebhookID, atStart,
 	)
 
 	iAssertStatus(

internal/gormlog/gormlog_test.go

@@ -146,7 +146,7 @@ func openDB(
 }
 
 // assertBounded holds every line the adapter wrote to the stated
-// ceiling and proves each was cut rather than merely short.
+// ceiling and proves no line carried a whole client value.
 func assertBounded(t *testing.T, out string) {
 	t.Helper()
 

internal/handlers/archive_rotation_test.go

@@ -12,8 +12,8 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/webhooker/internal/archive"
 	"sneak.berlin/go/webhooker/internal/database"
-	"sneak.berlin/go/webhooker/internal/delivery"
 )
 
 // rotationNone is the archive rotation that keeps one file.
@@ -181,7 +181,7 @@ func TestArchiveFileView_Rotated(t *testing.T) {
 		`{"rotation":"daily"}`,
 	)
 
-	path := delivery.ArchivePath(env.dbMgr, &webhook, target)
+	path := archive.Path(env.dbMgr, &webhook, target)
 	stem := strings.TrimSuffix(path, ".db")
 	written := time.Date(2026, 10, 2, 9, 0, 0, 0, time.UTC)
 

internal/handlers/delivery_replay.go

@@ -308,7 +308,7 @@ func createReplayDelivery(
 		TargetName:   target.Name,
 		TargetType:   target.Type,
 		TargetConfig: target.Config,
-		MaxRetries:   target.MaxRetries,
+		MaxAttempts:  target.MaxAttempts,
 		Method:       event.Method,
 		RawQuery:     event.RawQuery,
 		Headers:      event.Headers,

internal/handlers/delivery_result_view_test.go

@@ -158,8 +158,7 @@ func TestHandleSourceLogs_RendersFailedAttempt(t *testing.T) {
 // TestHandleSourceLogs_EscapesResponseBody proves the
 // response body is treated as the untrusted remote content it
 // is. The remote chooses these bytes and the page is rendered
-// inside the operator's authenticated origin, where the
+// inside the operator's authenticated origin.
-// application's own CSP allows inline script from 'self'.
 func TestHandleSourceLogs_EscapesResponseBody(t *testing.T) {
 	t.Parallel()
 

internal/handlers/event_body.go

@@ -35,11 +35,10 @@ const eventBodyQuery = "SELECT cast(body as blob) " +
 // response is deliberately not renderable. Content-Disposition
 // makes the browser download rather than display it, and the
 // octet-stream type plus nosniff stop it being interpreted as
-// HTML or script. Without those a stored payload would execute
+// HTML or script. Without those a stored payload would be shown
-// as the logged-in operator. The application's CSP does not
+// as a page of the operator's own origin. The application's CSP
-// help here: script-src allows 'unsafe-inline' from 'self', so
+// is a second defence behind them: it allows no inline script,
-// a document served from this origin could run its own inline
+// so such a page could not run script of its own.
-// script.
 func (h *Handlers) HandleEventBodyDownload() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		webhook, ok := h.ownedWebhook(w, r)

internal/handlers/event_detail_test.go

@@ -84,7 +84,7 @@ func TestHandleEventDetail_ShowsEventWholeWithDeliveries(t *testing.T) {
 	assert.Contains(t, page, strconv.Itoa(len(body))+" bytes")
 	assert.Contains(t, page, "{\n  "pad": "xxx")
 	assert.Contains(t, page, ""tail": ""+sentinel+""\n}")
-	assert.Contains(t, page, `style="max-height: 32rem; overflow-y: auto"`)
+	assert.Contains(t, page, `break-all max-h-[32rem] overflow-y-auto"`)
 	assert.NotContains(t, page, "Showing the first")
 	assert.Contains(t, page, target.Name)
 	assert.Contains(t, page, ">failed</span>")

internal/handlers/event_log.go

@@ -496,7 +496,7 @@ const deliveryIDChunkSize = 500
 //
 // Each response body is cut by SQLite rather than in Go, for
 // the reason deliveryResultColumns gives. How many attempts a
-// delivery has is the target's MaxRetries, which the
+// delivery has is bounded by the target's MaxAttempts, which the
 // authenticated operator sets; how many of them reach the page
 // is bounded again by maxRenderedAttempts.
 func (h *Handlers) loadDeliveryResults(

internal/handlers/export_test.go

@@ -37,10 +37,10 @@ const MaxRenderedResponseBytesForTest = maxRenderedResponseBytes
 // per-delivery attempt ceiling to the handlers_test package.
 const MaxRenderedAttemptsForTest = maxRenderedAttempts
 
-// MaxTargetRetriesForTest exposes the target max_retries ceiling to
+// MaxTargetAttemptsForTest exposes the target max_attempts ceiling to
 // the handlers_test package, so the tests assert against the constant
 // the handlers enforce rather than a number copied beside it.
-const MaxTargetRetriesForTest = maxTargetRetries
+const MaxTargetAttemptsForTest = maxTargetAttempts
 
 // EventDBLeftMsgForTest and SidecarLeftMsgForTest expose the two
 // messages the webhook delete handler logs when a file of the event

internal/handlers/gormlogbound_test.go

@@ -374,7 +374,7 @@ func assertFloodBounded(t *testing.T, label, out string) {
 // this service's three gorm.Open sites: the main database behind the
 // two unauthenticated lookups, and the per-webhook database the
 // WebhookDBManager opens. The third, the archive writer, is pinned in
-// internal/delivery, where its type lives.
+// internal/archive, where its type lives.
 //
 // What each assertion is worth, since two of the three would pass
 // against a service that had never been fixed if the capture were set

internal/handlers/handlers.go

@@ -10,11 +10,11 @@ import (
 	"html/template"
 	"log/slog"
 	"net/http"
-	"sync"
 	"sync/atomic"
 
 	"github.com/prometheus/client_golang/prometheus"
 	"go.uber.org/fx"
+	"sneak.berlin/go/webhooker/internal/archive"
 	"sneak.berlin/go/webhooker/internal/config"
 	"sneak.berlin/go/webhooker/internal/database"
 	"sneak.berlin/go/webhooker/internal/delivery"
@@ -65,7 +65,7 @@ type HandlersParams struct {
 	Session         *session.Session
 	Middleware      *middleware.Middleware
 	Notifier        delivery.Notifier
-	Archives        delivery.Archives
+	Archives        archive.Archives
 	CircuitBreakers delivery.CircuitBreakers
 	SSRFGuard       *delivery.Guard
 	Metrics         *metrics.Set
@@ -83,7 +83,7 @@ type Handlers struct {
 	session   *session.Session
 	mw        *middleware.Middleware
 	notifier  delivery.Notifier
-	archives  delivery.Archives
+	archives  archive.Archives
 	breakers  delivery.CircuitBreakers
 	mtr       *metrics.Set
 	templates map[string]*template.Template
@@ -93,17 +93,6 @@ type Handlers struct {
 	// is one delivery will actually attempt.
 	ssrf *delivery.Guard
 
-	// renameMu makes the webhook edit, the target edit and target
-	// creation run one at a time, each held from loading the stored
-	// names through the archive rename, the save and any move back.
-	// Interleaved, one could rename an archive between another's
-	// rename and save, leaving the file named for one edit and the
-	// stored names from the other. An archive download holds it while
-	// it reads the stored names and lists the files they give, and
-	// again for each file while it finds the file under the names
-	// stored then and opens it.
-	renameMu sync.Mutex
-
 	// dummyVerifications counts the equivalent-cost verifications
 	// charged for usernames that do not exist. It exists so a test
 	// can prove that path runs without measuring wall-clock time.

internal/handlers/handlers_test.go

@@ -16,6 +16,7 @@ import (
 	"github.com/stretchr/testify/require"
 	"go.uber.org/fx"
 	"go.uber.org/fx/fxtest"
+	"sneak.berlin/go/webhooker/internal/archive"
 	"sneak.berlin/go/webhooker/internal/config"
 	"sneak.berlin/go/webhooker/internal/database"
 	"sneak.berlin/go/webhooker/internal/delivery"
@@ -55,12 +56,14 @@ func (n *recordingNotifier) Tasks() []delivery.Task {
 	return out
 }
 
-// recordingArchives is a delivery.Archives that records what it
+// recordingArchives is an archive.Archives that records what it
 // was asked to do, so a test can prove that a deletion or rename
-// path reached the delivery engine. After FailRenames, every
+// path reached the archive writers. After FailRenames, every
 // rename of that target fails with the given error. After
 // BlockNextRename, the next rename is recorded and then waits.
+// RenameLock returns a plain mutex, as in archive.Writers.
 type recordingArchives struct {
+	renameMu       sync.Mutex
 	mu             sync.Mutex
 	evicted        []string
 	evictedTargets []string
@@ -73,10 +76,10 @@ type recordingArchives struct {
 // errInjectedRename is the failure a test hands FailRenames.
 var errInjectedRename = errors.New("injected rename failure")
 
-// errNameTaken is what the delivery engine returns when a file
+// errNameTaken is what the archive writers return when a file
 // already has an archive's new name, here archive-taken.db.
 var errNameTaken = fmt.Errorf(
-	"%w: archive-taken.db", delivery.ErrArchiveNameTaken,
+	"%w: archive-taken.db", archive.ErrNameTaken,
 )
 
 // archiveRename is one recorded Rename call.
@@ -86,6 +89,10 @@ type archiveRename struct {
 	TargetName  string
 }
 
+func (r *recordingArchives) RenameLock() *sync.Mutex {
+	return &r.renameMu
+}
+
 func (r *recordingArchives) EvictWebhook(webhookID string) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
@@ -265,7 +272,7 @@ func newTestAppWithConfig(
 			func() *recordingArchives {
 				return &recordingArchives{}
 			},
-			func(r *recordingArchives) delivery.Archives {
+			func(r *recordingArchives) archive.Archives {
 				return r
 			},
 			func() *testCircuitBreakers {

internal/handlers/logbound_test.go

@@ -1,19 +1,15 @@
 package handlers_test
 
-// The handler-side half of the log-field audit. Two slog calls in
+// The handler-side half of the log-field audit. The slog calls in
-// this package reach a value an UNAUTHENTICATED client picks outright
+// this package that reach a value an UNAUTHENTICATED client picks
-// and of a length it picks outright:
+// outright, and of a length it picks outright, are the failed-login
+// DEBUG lines, whose username is a form field.
 //
-//   - the unknown-entrypoint DEBUG line on /h/{uuid}, whose
+// They are at DEBUG, which is off in production by default. That is
-//     path segment matched no stored entrypoint and so is bounded by
-//     nothing;
-//   - the failed-login DEBUG lines, whose username is a form field.
-//
-// Both are at DEBUG, which is off in production by default. That is
 // not a bound: an operator turning DEBUG on to diagnose a flood must
-// not thereby hand the flood an unbounded write. Both spend the same
+// not thereby hand the flood an unbounded write. They spend the same
-// internal/logfield budget as the access log, and both are held here
+// internal/logfield budget as the access log, and are held here to
-// to middleware.MaxAccessLogLineBytes.
+// middleware.MaxAccessLogLineBytes.
 //
 // The two login lines past the username lookup — "invalid password"
 // and "user logged in" — carry the same cap without needing it, since
@@ -195,13 +191,12 @@ func receiverRouter(h *handlers.Handlers) *chi.Mux {
 	return router
 }
 
-// postReceiver sends one POST at /h/<segment>.
+// postReceiver sends one POST with an empty body at /h/<segment>
+// through router and returns the response status.
 //
 // RawPath is cleared after parsing so chi routes on the decoded path
 // and the handler sees the raw bytes rather than their percent-escaped
-// spelling. That is the harder case for the budget: the escaped
+// spelling.
-// spelling is plain ASCII, which costs one byte per byte, while the
-// decoded bytes are what the log handler has to escape.
 func postReceiver(
 	t *testing.T, router *chi.Mux, segment string,
 ) int {
@@ -260,43 +255,6 @@ func postLoginWithPassword(
 	return w.Code
 }
 
-// TestUnknownEntrypoint_LogLineDoesNotTrackPathSize drives 8 KB of
-// client-chosen path at the unauthenticated receiver's
-// unknown-entrypoint DEBUG line and holds it to the same ceiling the
-// access log states.
-func TestUnknownEntrypoint_LogLineDoesNotTrackPathSize(t *testing.T) {
-	t.Parallel()
-
-	for handlerName, newHandler := range logHandlers() {
-		for fillName, fill := range escapeFills() {
-			t.Run(handlerName+"/"+fillName, func(t *testing.T) {
-				t.Parallel()
-
-				h, buf := capturingHandlers(t, newHandler)
-				router := receiverRouter(h)
-
-				for i := range floodRequests {
-					assert.Equal(
-						t,
-						http.StatusNotFound,
-						postReceiver(
-							t, router,
-							oversizedFill(fill)+
-								strings.Repeat("y", i),
-						),
-					)
-				}
-
-				lines := logLines(t, buf)
-				require.Len(t, lines, floodRequests)
-				assertNoClientText(t, buf)
-
-				assertBoundedFlood(t, buf.Len())
-			})
-		}
-	}
-}
-
 // TestFailedLogin_LogLineDoesNotTrackUsernameSize drives 8 KB of
 // client-chosen username at the unauthenticated login endpoint's
 // DEBUG line and holds it to the same ceiling.

internal/handlers/shared.go

@@ -16,21 +16,16 @@ import (
 //
 // An empty value yields fallback, which lets the create path apply the
 // default and the edit path leave the stored value unchanged. A value
-// of 0 is returned as 0 and is rewritten to the retain-forever
+// of 0 means retain events forever and is returned as it is. Anything
-// sentinel by database.Webhook's BeforeSave hook. Anything unparseable
+// unparseable or negative is refused rather than silently given a
-// or negative is refused rather than silently given a default.
+// default.
 //
 // The upper bound is not cosmetic. The reaper computes its cutoff as a
 // time.Duration, an int64 nanosecond count, so a day count above
 // database.MaxFiniteRetentionDays overflows, puts the cutoff in the
-// future, and deletes every event the webhook has. A finite value
+// future, and deletes every event the webhook has. A value above that
-// above that ceiling is therefore refused, and the message names the
+// ceiling is therefore refused, and the message names the ceiling
-// ceiling rather than implying the input was not a number.
+// rather than implying the input was not a number.
-//
-// A value at or above the retain-forever sentinel is not out of range:
-// it is what the edit form pre-fills for a retain-forever webhook, so
-// submitting the form back unchanged has to keep meaning "forever"
-// rather than being rejected.
 func parseRetentionDays(raw string, fallback int) (int, string) {
 	raw = strings.TrimSpace(raw)
 	if raw == "" {
@@ -43,10 +38,6 @@ func parseRetentionDays(raw string, fallback int) (int, string) {
 			"retain events forever."
 	}
 
-	if v >= database.RetentionForeverDays {
-		return database.RetentionForeverDays, ""
-	}
-
 	if v > database.MaxFiniteRetentionDays {
 		return 0, "Retention must be at most " +
 			strconv.Itoa(database.MaxFiniteRetentionDays) +

internal/handlers/source_delete_test.go

@@ -16,8 +16,8 @@ import (
 	"github.com/stretchr/testify/require"
 	"gorm.io/gorm"
 	"gorm.io/gorm/clause"
+	"sneak.berlin/go/webhooker/internal/archive"
 	"sneak.berlin/go/webhooker/internal/database"
-	"sneak.berlin/go/webhooker/internal/delivery"
 	"sneak.berlin/go/webhooker/internal/handlers"
 	"sneak.berlin/go/webhooker/internal/session"
 )
@@ -64,10 +64,11 @@ func seedTarget(
 	t.Helper()
 
 	tgt := &database.Target{
-		WebhookID: webhookID,
+		WebhookID:   webhookID,
-		Name:      "t-" + string(targetType),
+		Name:        "t-" + string(targetType),
-		Type:      targetType,
+		Type:        targetType,
-		Active:    true,
+		Active:      true,
+		MaxAttempts: 1,
 	}
 
 	require.NoError(
@@ -179,7 +180,7 @@ func failSaveOnTable(
 }
 
 // archivePathFor returns the archive database path the
-// delivery engine would use for a database target: beside the
+// archive writers would use for a database target: beside the
 // webhook's event database in the data directory.
 func archivePathFor(
 	t *testing.T,
@@ -191,7 +192,7 @@ func archivePathFor(
 
 	return filepath.Join(
 		filepath.Dir(mgr.DBPath(wh.ID)),
-		delivery.ArchiveFileName(wh.Name, tgt.Name, tgt.ID),
+		archive.FileName(wh.Name, tgt.Name, tgt.ID),
 	)
 }
 
@@ -227,9 +228,9 @@ func postRequest(
 }
 
 // TestHandleSourceDelete_EvictsArchiveWriter proves that
-// deleting a webhook reaches the delivery engine and releases
+// deleting a webhook releases the webhook's archive writers,
-// the webhook's archive writers, exercised through the real
+// exercised through the real deletion handler rather than by
-// deletion handler rather than by calling the engine directly.
+// calling the archive writers directly.
 func TestHandleSourceDelete_EvictsArchiveWriter(t *testing.T) {
 	t.Parallel()
 
@@ -289,7 +290,7 @@ func TestHandleSourceDelete_KeepsArchiveFile(t *testing.T) {
 	wh := seedWebhook(t, db)
 	tgt := seedTarget(t, db, wh.ID, database.TargetTypeDatabase)
 
-	// Place an archive file where the delivery engine would.
+	// Place an archive file where the archive writers would.
 	archivePath := archivePathFor(t, mgr, wh, tgt)
 	require.NoError(
 		t,

internal/handlers/source_detail_test.go

@@ -37,11 +37,12 @@ func seedConfiguredTarget(
 	t.Helper()
 
 	tgt := &database.Target{
-		WebhookID: webhookID,
+		WebhookID:   webhookID,
-		Name:      "t-" + string(targetType),
+		Name:        "t-" + string(targetType),
-		Type:      targetType,
+		Type:        targetType,
-		Active:    true,
+		Active:      true,
-		Config:    config,
+		Config:      config,
+		MaxAttempts: 1,
 	}
 
 	require.NoError(
@@ -273,7 +274,7 @@ func TestHandleSourceDetail_FitsWideAndNarrowWindows(t *testing.T) {
 
 	assert.Contains(
 		t, body,
-		`<div class="mx-auto px-6 py-8" style="max-width: 108rem"`,
+		`<div class="max-w-[108rem] mx-auto px-6 py-8">`,
 	)
 	assert.Contains(
 		t, body,
@@ -286,8 +287,8 @@ func TestHandleSourceDetail_FitsWideAndNarrowWindows(t *testing.T) {
 // target and says what deleting it loses, that the webhook's gives its
 // number of stored events (5 received, 2 removed by retention, so 3,
 // the statistics pane's "Within retention" figure), and that an
-// entrypoint with no description is named by its URL. The template
+// entrypoint with no description is named by its URL. Each prompt is
-// writes the slashes after http: as \/, which the browser reads as /.
+// its form's data-confirm attribute, where &#10; is a line break.
 func TestHandleSourceDetail_DeletePromptsNameWhatIsLost(t *testing.T) {
 	t.Parallel()
 
@@ -325,29 +326,28 @@ func TestHandleSourceDetail_DeletePromptsNameWhatIsLost(t *testing.T) {
 	body := renderSourceDetailPage(t, h, sess, wh.ID)
 
 	assert.Contains(t, body,
-		`Delete webhook &quot;delete-me&quot;?\n\n`+
+		`data-confirm="Delete webhook &quot;delete-me&quot;?&#10;&#10;`+
 			`This deletes its stored events (3) and their deliveries. `+
-			`Any archive files it wrote are kept.`)
+			`Any archive files it wrote are kept."`)
 	assert.Contains(t, body,
-		`Delete entrypoint &quot;Stripe&quot;?\n\n`+
+		`data-confirm="Delete entrypoint &quot;Stripe&quot;?&#10;&#10;`+
 			`Senders using its URL get an error from now on, `+
-			`and the URL cannot be restored.`)
+			`and the URL cannot be restored."`)
 	assert.Contains(t, body,
-		`Delete entrypoint &quot;http:\/\/example.com/h/`+
+		`data-confirm="Delete entrypoint &quot;http://example.com/h/`+
-			unnamed.Path+`&quot;?`)
+			unnamed.Path+`&quot;?&#10;&#10;`)
 	assert.Contains(t, body,
-		`Delete target &quot;t-log&quot;?\n\n`+
+		`data-confirm="Delete target &quot;t-log&quot;?&#10;&#10;`+
 			`Nothing more is delivered to it. `+
-			`Its past deliveries stay in the event log.`)
+			`Its past deliveries stay in the event log."`)
 }
 
 // TestHandleSourceDetail_DeletePromptKeepsQuotesInName checks that a
 // webhook name with quotes, a backslash, a closing script tag and a
-// newline reaches its delete prompt escaped for the script, which the
+// newline reaches its delete prompt escaped for the attribute, which
-// browser reads back as the name typed: each quote and angle bracket
+// the browser reads back as the name typed: each quote and angle
-// as a \u escape, the slash as \/, the newline as \n and the backslash
+// bracket as a character reference, the rest as typed. An unescaped
-// doubled. An unescaped newline would break the prompt's script, and
+// double quote would end the attribute and cut the prompt short.
-// the form would then submit without asking.
 func TestHandleSourceDetail_DeletePromptKeepsQuotesInName(t *testing.T) {
 	t.Parallel()
 
@@ -373,6 +373,6 @@ func TestHandleSourceDetail_DeletePromptKeepsQuotesInName(t *testing.T) {
 	body := renderSourceDetailPage(t, h, sess, wh.ID)
 
 	assert.Contains(t, body,
-		"Delete webhook &quot;Bob\\u0027s \\u0022best\\u0022 \\\\ hook"+
+		"Delete webhook &quot;Bob&#39;s &#34;best&#34; \\ hook"+
-			"\\u003c\\/script\\u003e\\nline two&quot;?")
+			"&lt;/script&gt;\nline two&quot;?")
 }

internal/handlers/source_management_test.go

@@ -137,8 +137,7 @@ func onlyWebhook(
 }
 
 // seedWebhookWithRetention inserts a webhook owned by the test user
-// with an exact stored retention value, bypassing Webhook.BeforeSave
+// with the given retention.
-// via a column-level update so that legacy rows can be planted too.
 func seedWebhookWithRetention(
 	t *testing.T,
 	db *database.Database,
@@ -155,13 +154,6 @@ func seedWebhookWithRetention(
 		t,
 		db.DB().Omit(clause.Associations).Create(wh).Error,
 	)
-	require.NoError(
-		t,
-		db.DB().Model(wh).
-			Update("retention_days", retentionDays).Error,
-	)
-
-	wh.RetentionDays = retentionDays
 
 	return *wh
 }
@@ -225,10 +217,9 @@ func setupSourceTest(t *testing.T) *sourceTestEnv {
 	}
 }
 
-// TestHandleSourceCreateSubmit_ZeroRetentionPersistsForever is the core
+// TestHandleSourceCreateSubmit_ZeroRetentionPersistsForever checks
-// regression test for the bug: the create form's 0 must reach the
+// that the create form's 0 reaches the database as 0, which means
-// database as the retain-forever sentinel rather than being replaced by
+// retain forever.
-// the column's default of 30.
 func TestHandleSourceCreateSubmit_ZeroRetentionPersistsForever(
 	t *testing.T,
 ) {
@@ -241,35 +232,60 @@ func TestHandleSourceCreateSubmit_ZeroRetentionPersistsForever(
 	require.Equal(t, http.StatusSeeOther, w.Code)
 
 	wh := onlyWebhook(t, env.db)
-	assert.Equal(
+	assert.Equal(t, 0, storedRetentionDays(t, env.db, wh.ID))
-		t,
-		database.RetentionForeverDays,
-		storedRetentionDays(t, env.db, wh.ID),
-	)
 	assert.True(t, wh.RetainsForever())
 }
 
-func TestHandleSourceCreateSubmit_OmittedRetentionUsesDefault(
+func TestHandleSourceCreateSubmit_DayCountIsStored(t *testing.T) {
+	t.Parallel()
+
+	env := setupSourceTest(t)
+	days := "45"
+
+	w := submitCreate(t, env.handlers, env.cookies, "finite", &days)
+	require.Equal(t, http.StatusSeeOther, w.Code)
+
+	wh := onlyWebhook(t, env.db)
+	assert.Equal(t, 45, storedRetentionDays(t, env.db, wh.ID))
+}
+
+// TestHandleSourceCreateSubmit_BlankRetentionUsesDefault covers a
+// retention field left empty and one missing from the form: both
+// give the default, not forever.
+func TestHandleSourceCreateSubmit_BlankRetentionUsesDefault(
 	t *testing.T,
 ) {
 	t.Parallel()
 
-	env := setupSourceTest(t)
+	blank := ""
 
-	w := submitCreate(t, env.handlers, env.cookies, "defaulted", nil)
+	for name, retention := range map[string]*string{
-	require.Equal(t, http.StatusSeeOther, w.Code)
+		"blank":   &blank,
+		"omitted": nil,
+	} {
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 
-	wh := onlyWebhook(t, env.db)
+			env := setupSourceTest(t)
-	assert.Equal(
+
-		t,
+			w := submitCreate(
-		database.DefaultRetentionDays,
+				t, env.handlers, env.cookies, "defaulted", retention,
-		storedRetentionDays(t, env.db, wh.ID),
+			)
-	)
+			require.Equal(t, http.StatusSeeOther, w.Code)
+
+			wh := onlyWebhook(t, env.db)
+			assert.Equal(
+				t,
+				database.DefaultRetentionDays,
+				storedRetentionDays(t, env.db, wh.ID),
+			)
+		})
+	}
 }
 
-// TestHandleSourceCreate_PrefillsDefaultFromConstant keeps the create
+// TestHandleSourceCreate_PrefillsDefaultFromConstant checks that the
-// form's pre-filled retention from becoming a third hardcoded copy of
+// create form pre-fills its retention from database.DefaultRetentionDays
-// the 30-day policy.
+// rather than from a hardcoded 30.
 func TestHandleSourceCreate_PrefillsDefaultFromConstant(t *testing.T) {
 	t.Parallel()
 
@@ -290,7 +306,7 @@ func TestHandleSourceCreate_PrefillsDefaultFromConstant(t *testing.T) {
 	)
 	assert.NotContains(
 		t, body, `max="365"`,
-		"a max below the sentinel would block retain-forever",
+		"a max of 365 would block any longer retention",
 	)
 	assert.Contains(t, body, `min="0"`)
 }
@@ -368,40 +384,6 @@ func TestHandleSourceCreateSubmit_OverflowingRetentionIsRejected(
 	)
 }
 
-// TestHandleSourceCreateSubmit_SentinelIsAcceptedAsForever guards the
-// boundary between "too large to represent" and "retain forever": the
-// sentinel is above MaxFiniteRetentionDays, but it is the value the
-// edit form pre-fills, so it must be accepted rather than rejected as
-// out of range. A value above the sentinel is stored as the sentinel.
-func TestHandleSourceCreateSubmit_SentinelIsAcceptedAsForever(
-	t *testing.T,
-) {
-	t.Parallel()
-
-	for _, days := range []int{
-		database.RetentionForeverDays,
-		database.RetentionForeverDays + 1,
-	} {
-		raw := strconv.Itoa(days)
-
-		t.Run(raw, func(t *testing.T) {
-			t.Parallel()
-
-			env := setupSourceTest(t)
-
-			w := submitCreate(t, env.handlers, env.cookies, "forever", &raw)
-			require.Equal(t, http.StatusSeeOther, w.Code)
-
-			wh := onlyWebhook(t, env.db)
-			assert.Equal(
-				t,
-				database.RetentionForeverDays,
-				storedRetentionDays(t, env.db, wh.ID),
-			)
-		})
-	}
-}
-
 // TestHandleSourceCreateSubmit_RejectedFormKeepsUserInput checks that a
 // validation failure hands the user's typing back, matching what the
 // edit form already does. Losing a long description to a mistyped
@@ -480,11 +462,7 @@ func TestHandleSourceEditSubmit_ZeroRetentionPersistsForever(
 	w := submitEdit(t, env, wh, "0")
 	require.Equal(t, http.StatusSeeOther, w.Code)
 
-	assert.Equal(
+	assert.Equal(t, 0, storedRetentionDays(t, env.db, wh.ID))
-		t,
-		database.RetentionForeverDays,
-		storedRetentionDays(t, env.db, wh.ID),
-	)
 }
 
 func TestHandleSourceEditSubmit_InvalidRetentionIsRejected(
@@ -867,18 +845,15 @@ func TestHandleSourceEditSubmit_ArchiveNameTaken(t *testing.T) {
 	assert.Equal(t, oldName, stored.Name)
 }
 
-// TestSourceEditForm_ForeverWebhookRoundTrips walks the exact path that
+// TestSourceEditForm_ForeverWebhookRoundTrips renders the edit form for
-// the removed max="365" cap used to break: render the edit form for a
+// a retain-forever webhook, confirms it pre-fills 0, then submits that
-// retain-forever webhook, confirm the pre-filled sentinel is not capped
+// pre-filled value straight back and confirms the retention policy
-// by browser validation, then submit that pre-filled value straight
+// survives untouched.
-// back and confirm the retention policy survives untouched.
 func TestSourceEditForm_ForeverWebhookRoundTrips(t *testing.T) {
 	t.Parallel()
 
 	env := setupSourceTest(t)
-	wh := seedWebhookWithRetention(
+	wh := seedWebhookWithRetention(t, env.db, 0)
-		t, env.db, database.RetentionForeverDays,
-	)
 
 	req := getRequest(
 		t, "/hook/"+wh.ID+"/edit", env.cookies,
@@ -889,17 +864,12 @@ func TestSourceEditForm_ForeverWebhookRoundTrips(t *testing.T) {
 
 	require.Equal(t, http.StatusOK, w.Code)
 
-	sentinel := strconv.Itoa(database.RetentionForeverDays)
 	body := w.Body.String()
 
 	assert.Contains(
-		t, body, `value="`+sentinel+`"`,
+		t, body, `name="retention_days" value="0"`,
 		"the edit form pre-fills the stored retention",
 	)
-	assert.NotContains(
-		t, body, `max="365"`,
-		"a max below the sentinel would block saving any edit",
-	)
 	// "Currently forever." is the rendered RetentionLabel, not the
 	// static hint below the input, which says "Enter 0 to retain events
 	// forever." A bare Contains of "forever" would pass for any
@@ -910,29 +880,20 @@ func TestSourceEditForm_ForeverWebhookRoundTrips(t *testing.T) {
 	)
 
 	// Submit the pre-filled value back, exactly as a browser would.
-	post := submitEdit(t, env, wh, sentinel)
+	post := submitEdit(t, env, wh, "0")
 	require.Equal(t, http.StatusSeeOther, post.Code)
 
-	assert.Equal(
+	assert.Equal(t, 0, storedRetentionDays(t, env.db, wh.ID))
-		t,
-		database.RetentionForeverDays,
-		storedRetentionDays(t, env.db, wh.ID),
-	)
 }
 
-// TestSourceListAndDetail_ShowForeverNotTheSentinelNumber checks that
+// TestSourceListAndDetail_ShowForeverNotZeroDays checks that a
-// the retain-forever value is never rendered to the user as a raw day
+// retention of 0 is shown as forever, never as a day count, on either
-// count on either read-only view.
+// read-only view.
-func TestSourceListAndDetail_ShowForeverNotTheSentinelNumber(
+func TestSourceListAndDetail_ShowForeverNotZeroDays(t *testing.T) {
-	t *testing.T,
-) {
 	t.Parallel()
 
 	env := setupSourceTest(t)
-	wh := seedWebhookWithRetention(
+	wh := seedWebhookWithRetention(t, env.db, 0)
-		t, env.db, database.RetentionForeverDays,
-	)
-	sentinel := strconv.Itoa(database.RetentionForeverDays)
 
 	listW := httptest.NewRecorder()
 	env.handlers.HandleSourceList().ServeHTTP(
@@ -941,7 +902,7 @@ func TestSourceListAndDetail_ShowForeverNotTheSentinelNumber(
 
 	require.Equal(t, http.StatusOK, listW.Code)
 	assert.Contains(t, listW.Body.String(), "Retention: forever")
-	assert.NotContains(t, listW.Body.String(), sentinel)
+	assert.NotContains(t, listW.Body.String(), "Retention: 0 days")
 
 	detailW := httptest.NewRecorder()
 	env.handlers.HandleSourceDetail().ServeHTTP(
@@ -954,5 +915,5 @@ func TestSourceListAndDetail_ShowForeverNotTheSentinelNumber(
 
 	require.Equal(t, http.StatusOK, detailW.Code)
 	assert.Contains(t, detailW.Body.String(), "Retention: forever")
-	assert.NotContains(t, detailW.Body.String(), sentinel)
+	assert.NotContains(t, detailW.Body.String(), "Retention: 0 days")
 }

internal/handlers/target_attempts.go

@@ -0,0 +1,81 @@
+package handlers
+
+import (
+	"errors"
+	"strconv"
+	"strings"
+)
+
+// maxTargetAttempts bounds a target's max_attempts.
+//
+// Both target forms already declare max="20" on the input, so this
+// enforces server-side what the UI has always advertised rather than
+// introducing a new limit.
+//
+// The number is not cosmetic. Every attempt writes a delivery_results
+// row that the event log then loads and renders, and the engine backs
+// off by 2^(n-1) seconds, so attempt 20 is already about six days
+// after the first. A value beyond this buys no additional durability
+// and only costs rows.
+const maxTargetAttempts = 20
+
+// Errors returned when a max_attempts form value cannot be turned into
+// a number of attempts.
+var (
+	// errAttemptsInvalid signals a max_attempts form value that is not
+	// a whole number of at least 1.
+	errAttemptsInvalid = errors.New(
+		"must be a whole number, at least 1",
+	)
+
+	// errAttemptsTooLarge signals a max_attempts form value that is a
+	// whole number but above maxTargetAttempts. It is distinguished
+	// from errAttemptsInvalid so the message can name the ceiling
+	// instead of implying the input was not a number.
+	errAttemptsTooLarge = errors.New("out of range")
+)
+
+// parseMaxAttempts interprets a max_attempts form value.
+//
+// An ABSENT value — the field empty or not submitted — yields
+// fallback, which lets the create path apply its default and the edit
+// path leave the stored value alone. A value that is SET BUT INVALID
+// is an error: unparseable, below 1, or above maxTargetAttempts.
+//
+// The distinction is the whole point of this function. Returning a
+// default for input the operator typed but that did not parse would
+// silently turn retries off on a store-and-forward proxy — and on the
+// edit path destroy a working configuration over a typo. A default
+// answers a question that was not asked; it never answers one that
+// was asked badly.
+func parseMaxAttempts(raw string, fallback int) (int, error) {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return fallback, nil
+	}
+
+	v, err := strconv.Atoi(raw)
+	if err != nil || v < 1 {
+		return 0, errAttemptsInvalid
+	}
+
+	if v > maxTargetAttempts {
+		return 0, errAttemptsTooLarge
+	}
+
+	return v, nil
+}
+
+// attemptsErrorMessage returns the message the create and edit forms
+// show for a rejected max_attempts value. Any error other than
+// errAttemptsTooLarge falls back to the generic wording, so an
+// unrecognised parse failure still produces a sensible 400.
+func attemptsErrorMessage(err error) string {
+	if errors.Is(err, errAttemptsTooLarge) {
+		return errAttemptsTooLarge.Error() +
+			": at most " + strconv.Itoa(maxTargetAttempts) +
+			" attempts"
+	}
+
+	return errAttemptsInvalid.Error()
+}

internal/handlers/target_attempts_test.go

@@ -0,0 +1,429 @@
+package handlers_test
+
+import (
+	"net/http"
+	"net/url"
+	"strconv"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/webhooker/internal/database"
+	"sneak.berlin/go/webhooker/internal/handlers"
+)
+
+// attemptsTargetURL is the destination the attempts-validation targets
+// point at. It is a literal public address rather than a hostname so
+// the SSRF check resolves nothing and a sandbox without DNS cannot
+// make these cases pass or fail for the wrong reason.
+const attemptsTargetURL = "https://93.184.216.34/hooks/attempts"
+
+const (
+	// wayAboveCeiling is the typo'd-extra-zero case from the report.
+	wayAboveCeiling = "999999999"
+
+	// notANumber is the plainest garbage an operator can type, and
+	// the value the report submitted on the edit form.
+	notANumber = "abc"
+
+	// workingAttempts is the number of attempts a seeded target is
+	// already delivering with, which a rejected submission must not
+	// disturb.
+	workingAttempts = 2
+)
+
+// aboveCeiling is the smallest rejected whole number.
+func aboveCeiling() string {
+	return strconv.Itoa(handlers.MaxTargetAttemptsForTest + 1)
+}
+
+// overCeilingAttempts is whole-number input past the limit, which is
+// rejected with the limit named.
+func overCeilingAttempts() []string {
+	return []string{aboveCeiling(), wayAboveCeiling}
+}
+
+// belowOneAttempts is whole-number input under the floor of one
+// attempt, which is rejected with the floor named.
+func belowOneAttempts() []string {
+	return []string{"0", "-5"}
+}
+
+// unparseableAttempts is input an operator can type into the field
+// that is not a number of attempts. Each must be REJECTED: silently
+// reading any of them as a default turns retries off on a
+// store-and-forward proxy without saying so.
+//
+// The twenty-digit case is here because it parses as digits but
+// overflows int, which is the one failure the field's own min/max
+// attributes cannot describe.
+func unparseableAttempts() []string {
+	return []string{
+		notANumber,
+		"2.7",
+		"12345678901234567890",
+		"1e3",
+	}
+}
+
+// createAttemptsForm is a complete, otherwise-valid HTTP target
+// creation, so the only thing any case below varies is max_attempts.
+func createAttemptsForm(attempts string) url.Values {
+	form := url.Values{}
+	form.Set("name", "attempts-target")
+	form.Set("type", string(database.TargetTypeHTTP))
+	form.Set("url", attemptsTargetURL)
+
+	if attempts != absentField {
+		form.Set("max_attempts", attempts)
+	}
+
+	return form
+}
+
+// absentField marks a field the form does not submit at all, which is
+// the case that legitimately takes a default and must stay distinct
+// from a field submitted with garbage in it.
+const absentField = "\x00absent"
+
+// absentAttempts is every way of saying "the operator did not set
+// this", each of which takes the default rather than a 400. Blank and
+// whitespace-only count as absent here because they do in the timeout
+// and retention controls on the same forms; a rule the fields do not
+// share would be its own surprise.
+func absentAttempts() []string {
+	return []string{absentField, "", "  "}
+}
+
+// createWithAttempts posts the target create form for a fresh webhook
+// and returns the webhook and the response.
+func createWithAttempts(
+	t *testing.T,
+	env *sourceTestEnv,
+	attempts string,
+) (database.Webhook, int, string) {
+	t.Helper()
+
+	webhook := seedWebhookWithRetention(t, env.db, 30)
+
+	w := serveTarget(
+		env, http.MethodPost,
+		"/hook/"+webhook.ID+"/targets",
+		createAttemptsForm(attempts),
+	)
+
+	return webhook, w.Code, w.Body.String()
+}
+
+// TestTargetCreate_AttemptsAboveCeilingRejected proves the create form
+// enforces a ceiling at all, and that the 400 names it — a rejection
+// that does not say what the limit is leaves the operator guessing.
+func TestTargetCreate_AttemptsAboveCeilingRejected(t *testing.T) {
+	t.Parallel()
+
+	env := setupSourceTest(t)
+	ceiling := strconv.Itoa(handlers.MaxTargetAttemptsForTest)
+
+	for _, attempts := range overCeilingAttempts() {
+		webhook, code, body := createWithAttempts(t, env, attempts)
+
+		assert.Equal(t, http.StatusBadRequest, code,
+			"max_attempts=%s should be rejected", attempts)
+		assert.Contains(t, body, ceiling,
+			"the rejection for %s should name the ceiling",
+			attempts)
+		assert.Empty(t,
+			targetsForWebhook(t, env.db, webhook.ID),
+			"no target should be created for %s", attempts)
+	}
+}
+
+// TestTargetCreate_AttemptsBelowOneRejected proves the create form
+// refuses 0 and less, naming the floor: every delivery is attempted
+// at least once.
+func TestTargetCreate_AttemptsBelowOneRejected(t *testing.T) {
+	t.Parallel()
+
+	env := setupSourceTest(t)
+
+	for _, attempts := range belowOneAttempts() {
+		webhook, code, body := createWithAttempts(t, env, attempts)
+
+		assert.Equal(t, http.StatusBadRequest, code,
+			"max_attempts=%s should be rejected", attempts)
+		assert.Contains(t, body, "at least 1",
+			"the rejection for %s should name the floor",
+			attempts)
+		assert.Empty(t,
+			targetsForWebhook(t, env.db, webhook.ID),
+			"no target should be created for %s", attempts)
+	}
+}
+
+// TestTargetCreate_UnparseableAttemptsRejected is the core of the
+// defect: each of these was accepted with HTTP 200 and stored as a
+// default.
+func TestTargetCreate_UnparseableAttemptsRejected(t *testing.T) {
+	t.Parallel()
+
+	env := setupSourceTest(t)
+
+	for _, attempts := range unparseableAttempts() {
+		webhook, code, body := createWithAttempts(t, env, attempts)
+
+		assert.Equal(t, http.StatusBadRequest, code,
+			"max_attempts=%q should be rejected, not coerced",
+			attempts)
+		assert.Contains(t, body, "whole number",
+			"the rejection for %q should say why", attempts)
+		assert.Empty(t,
+			targetsForWebhook(t, env.db, webhook.ID),
+			"no target should be created for %q", attempts)
+	}
+}
+
+// TestTargetCreate_ValidAttemptsStored covers the accepting half,
+// including both bounds: a bound that rejects its own limit would
+// make the advertised range unreachable.
+func TestTargetCreate_ValidAttemptsStored(t *testing.T) {
+	t.Parallel()
+
+	env := setupSourceTest(t)
+
+	for _, want := range []int{1, 3, handlers.MaxTargetAttemptsForTest} {
+		webhook, code, body := createWithAttempts(
+			t, env, strconv.Itoa(want),
+		)
+
+		require.Equal(t, http.StatusSeeOther, code, body)
+
+		targets := targetsForWebhook(t, env.db, webhook.ID)
+		require.Len(t, targets, 1)
+		assert.Equal(t, want, targets[0].MaxAttempts)
+	}
+}
+
+// TestTargetCreate_AbsentAttemptsTakesDefault keeps the two cases
+// distinct. An omitted field is not an operator asking for something
+// invalid, so it still gets the default of one attempt rather than a
+// 400 — otherwise the fix above would make the form unusable.
+func TestTargetCreate_AbsentAttemptsTakesDefault(t *testing.T) {
+	t.Parallel()
+
+	env := setupSourceTest(t)
+
+	for _, attempts := range absentAttempts() {
+		webhook, code, body := createWithAttempts(t, env, attempts)
+
+		require.Equal(t, http.StatusSeeOther, code, body)
+
+		targets := targetsForWebhook(t, env.db, webhook.ID)
+		require.Len(t, targets, 1)
+		assert.Equal(t, 1, targets[0].MaxAttempts,
+			"an absent max_attempts should take the default")
+	}
+}
+
+// seedAttemptsTarget creates an HTTP target already delivering with
+// workingAttempts attempts, through the real create handler.
+func seedAttemptsTarget(
+	t *testing.T,
+	env *sourceTestEnv,
+) (database.Webhook, database.Target) {
+	t.Helper()
+
+	webhook, code, body := createWithAttempts(
+		t, env, strconv.Itoa(workingAttempts),
+	)
+	require.Equal(t, http.StatusSeeOther, code, body)
+
+	targets := targetsForWebhook(t, env.db, webhook.ID)
+	require.Len(t, targets, 1)
+	require.Equal(t, workingAttempts, targets[0].MaxAttempts)
+
+	return webhook, targets[0]
+}
+
+// editAttemptsForm is a complete edit submission that changes the
+// target's name as well, so a rejected submission can be shown to
+// have written nothing at all rather than merely to have left
+// max_attempts alone.
+func editAttemptsForm(attempts string) url.Values {
+	form := url.Values{}
+	form.Set("name", "renamed-by-edit")
+	form.Set("url", attemptsTargetURL)
+
+	if attempts != absentField {
+		form.Set("max_attempts", attempts)
+	}
+
+	return form
+}
+
+// assertEditRejectedAndUnchanged submits an edit expected to fail and
+// checks both halves of the requirement: the 400 explains itself, and
+// the target it was submitted against is untouched.
+func assertEditRejectedAndUnchanged(
+	t *testing.T,
+	env *sourceTestEnv,
+	attempts, wantReason string,
+) {
+	t.Helper()
+
+	webhook, target := seedAttemptsTarget(t, env)
+
+	w := submitTargetEdit(
+		env, webhook.ID, target.ID, editAttemptsForm(attempts),
+	)
+
+	assert.Equal(t, http.StatusBadRequest, w.Code,
+		"max_attempts=%q should be rejected on edit", attempts)
+	assert.Contains(t, w.Body.String(), wantReason,
+		"the rejection for %q should say why", attempts)
+
+	stored := storedTarget(t, env, target.ID)
+	assert.Equal(t, workingAttempts, stored.MaxAttempts,
+		"a rejected edit must not destroy the working number "+
+			"of attempts with %q", attempts)
+	assert.Equal(t, "attempts-target", stored.Name,
+		"a rejected edit must write nothing at all")
+}
+
+// TestTargetEdit_UnparseableAttemptsRejected is the damaging half of
+// the defect. A target delivering with retries, re-saved with a typo
+// in the field, returned 200 and was left with retries disabled and
+// nothing said.
+func TestTargetEdit_UnparseableAttemptsRejected(t *testing.T) {
+	t.Parallel()
+
+	env := setupSourceTest(t)
+
+	for _, attempts := range unparseableAttempts() {
+		assertEditRejectedAndUnchanged(
+			t, env, attempts, "whole number",
+		)
+	}
+}
+
+// TestTargetEdit_AttemptsBelowOneRejected proves the floor applies
+// to the edit path too.
+func TestTargetEdit_AttemptsBelowOneRejected(t *testing.T) {
+	t.Parallel()
+
+	env := setupSourceTest(t)
+
+	for _, attempts := range belowOneAttempts() {
+		assertEditRejectedAndUnchanged(t, env, attempts, "at least 1")
+	}
+}
+
+// TestTargetEdit_AttemptsAboveCeilingRejected proves the ceiling
+// applies to the edit path too, naming itself, so the two paths
+// cannot disagree about what is storable.
+func TestTargetEdit_AttemptsAboveCeilingRejected(t *testing.T) {
+	t.Parallel()
+
+	env := setupSourceTest(t)
+	ceiling := strconv.Itoa(handlers.MaxTargetAttemptsForTest)
+
+	for _, attempts := range overCeilingAttempts() {
+		assertEditRejectedAndUnchanged(t, env, attempts, ceiling)
+	}
+}
+
+// TestTargetEdit_ValidAttemptsStored covers the accepting half of the
+// edit path, so the bounds cannot be enforced by simply refusing
+// every submission.
+func TestTargetEdit_ValidAttemptsStored(t *testing.T) {
+	t.Parallel()
+
+	env := setupSourceTest(t)
+
+	for _, want := range []int{1, 9, handlers.MaxTargetAttemptsForTest} {
+		webhook, target := seedAttemptsTarget(t, env)
+
+		w := submitTargetEdit(
+			env, webhook.ID, target.ID,
+			editAttemptsForm(strconv.Itoa(want)),
+		)
+		require.Equal(t,
+			http.StatusSeeOther, w.Code, w.Body.String(),
+		)
+
+		assert.Equal(t, want,
+			storedTarget(t, env, target.ID).MaxAttempts)
+	}
+}
+
+// TestTargetEdit_AbsentAttemptsLeavesStoredValue is the edit path's
+// absent-versus-invalid case. The field is only offered by the forms
+// for types that retry, so a submission without it must leave the
+// stored count alone rather than be rejected or reset.
+func TestTargetEdit_AbsentAttemptsLeavesStoredValue(t *testing.T) {
+	t.Parallel()
+
+	env := setupSourceTest(t)
+
+	for _, attempts := range absentAttempts() {
+		webhook, target := seedAttemptsTarget(t, env)
+
+		w := submitTargetEdit(
+			env, webhook.ID, target.ID,
+			editAttemptsForm(attempts),
+		)
+		require.Equal(t,
+			http.StatusSeeOther, w.Code, w.Body.String(),
+		)
+
+		assert.Equal(t, workingAttempts,
+			storedTarget(t, env, target.ID).MaxAttempts,
+			"an absent max_attempts must leave the stored "+
+				"count alone (%q)", attempts)
+	}
+}
+
+// TestTargetAttempts_CreateAndEditAgreeOnEveryCase proves the two
+// paths cannot disagree, which is what let the create form and the
+// edit form drift apart in the first place. Every input is submitted
+// to both and the accept/reject verdicts are compared.
+func TestTargetAttempts_CreateAndEditAgreeOnEveryCase(t *testing.T) {
+	t.Parallel()
+
+	env := setupSourceTest(t)
+
+	accepted := []string{
+		"1", "2",
+		strconv.Itoa(handlers.MaxTargetAttemptsForTest),
+	}
+	overCeiling := overCeilingAttempts()
+	belowOne := belowOneAttempts()
+	unparseable := unparseableAttempts()
+
+	cases := make(
+		[]string, 0,
+		len(accepted)+len(overCeiling)+len(belowOne)+
+			len(unparseable),
+	)
+	cases = append(cases, accepted...)
+	cases = append(cases, overCeiling...)
+	cases = append(cases, belowOne...)
+	cases = append(cases, unparseable...)
+
+	for _, attempts := range cases {
+		_, createCode, _ := createWithAttempts(t, env, attempts)
+
+		webhook, target := seedAttemptsTarget(t, env)
+		editCode := submitTargetEdit(
+			env, webhook.ID, target.ID,
+			editAttemptsForm(attempts),
+		).Code
+
+		assert.Equal(t,
+			createCode == http.StatusBadRequest,
+			editCode == http.StatusBadRequest,
+			"create and edit must agree on max_attempts=%q "+
+				"(create %d, edit %d)",
+			attempts, createCode, editCode,
+		)
+	}
+}

internal/handlers/target_create.go

@@ -9,6 +9,7 @@ import (
 	"strings"
 
 	"github.com/go-chi/chi"
+	"sneak.berlin/go/webhooker/internal/archive"
 	"sneak.berlin/go/webhooker/internal/database"
 	"sneak.berlin/go/webhooker/internal/delivery"
 )
@@ -27,8 +28,8 @@ func (h *Handlers) HandleTargetCreate() http.HandlerFunc {
 
 		sourceID := chi.URLParam(r, "sourceID")
 
-		h.renameMu.Lock()
+		h.archives.RenameLock().Lock()
-		defer h.renameMu.Unlock()
+		defer h.archives.RenameLock().Unlock()
 
 		var webhook database.Webhook
 
@@ -102,9 +103,10 @@ func (h *Handlers) newTarget(
 	in targetFormInput,
 ) (*database.Target, string, error) {
 	target := &database.Target{
-		WebhookID: webhookID,
+		WebhookID:   webhookID,
-		Type:      in.Type,
+		Type:        in.Type,
-		Active:    true,
+		Active:      true,
+		MaxAttempts: 1,
 	}
 
 	errMsg, err := h.setTargetFromForm(ctx, target, in)
@@ -117,9 +119,10 @@ func (h *Handlers) newTarget(
 
 // setTargetFromForm validates a target form against the target's type
 // and, when it accepts it, sets the target's name, configuration and
-// retry count from it. It returns the message the form shows for
+// number of delivery attempts from it. It returns the message the form
-// anything it refuses, an unknown type among them, and then leaves the
+// shows for anything it refuses, an unknown type among them, and then
-// target unchanged; an error is the server's fault, as for newTarget.
+// leaves the target unchanged; an error is the server's fault, as for
+// newTarget.
 // The add target form and the target edit form both go through here,
 // so the two cannot come to disagree about what a target may be.
 func (h *Handlers) setTargetFromForm(
@@ -136,20 +139,20 @@ func (h *Handlers) setTargetFromForm(
 		return errMsg, err
 	}
 
-	// An empty max_retries keeps the target's count: the
+	// An empty max_attempts keeps the target's count: the default of
-	// fire-and-forget default of 0 for a new target, and the stored
+	// 1 for a new target, and the stored count for an edited one,
-	// count for an edited one, since the forms for target types that
+	// since the forms for target types that do not retry have no such
-	// do not retry have no such field. A value that is filled in but
+	// field. A value that is filled in but invalid is refused rather
-	// invalid is refused rather than becoming that count, so a typo
+	// than becoming that count, so a typo cannot destroy the count a
-	// cannot destroy the count a target is delivering with.
+	// target is delivering with.
-	maxRetries, err := parseMaxRetries(in.MaxRetries, target.MaxRetries)
+	maxAttempts, err := parseMaxAttempts(in.MaxAttempts, target.MaxAttempts)
 	if err != nil {
-		return "Invalid delivery attempts: " + retriesErrorMessage(err), nil
+		return "Invalid delivery attempts: " + attemptsErrorMessage(err), nil
 	}
 
 	target.Name = in.Name
 	target.Config = configJSON
-	target.MaxRetries = maxRetries
+	target.MaxAttempts = maxAttempts
 
 	return "", nil
 }
@@ -176,8 +179,8 @@ type targetFormInput struct {
 	// ForwardQuery is an HTTP target's checkbox that passes each
 	// event's query string on to it.
 	ForwardQuery bool
-	// MaxRetries is an HTTP or Slack target's max_retries.
+	// MaxAttempts is an HTTP or Slack target's max_attempts.
-	MaxRetries string
+	MaxAttempts string
 	// Expiry is a database (archive) target's row expiry.
 	Expiry string
 	// Rotation is a database (archive) target's rotation.
@@ -204,7 +207,7 @@ func targetFormInputFrom(r *http.Request) targetFormInput {
 		Headers:      r.PostFormValue("headers"),
 		Timeout:      r.PostFormValue("timeout"),
 		ForwardQuery: r.PostFormValue("forward_query") != "",
-		MaxRetries:   r.PostFormValue("max_retries"),
+		MaxAttempts:  r.PostFormValue("max_attempts"),
 		Expiry:       r.PostFormValue("expiry"),
 		Rotation:     r.PostFormValue("rotation"),
 	}
@@ -359,12 +362,12 @@ func buildDatabaseTargetConfig(
 ) (string, string, error) {
 	expiry = strings.TrimSpace(expiry)
 
-	err := delivery.ValidateArchiveExpiry(expiry)
+	err := archive.ValidateExpiry(expiry)
 	if err != nil {
 		return "", fmt.Sprintf("Invalid archive expiry: %v", err), nil
 	}
 
-	err = delivery.ValidateArchiveRotation(rotation)
+	err = archive.ValidateRotation(rotation)
 	if err != nil {
 		return "", fmt.Sprintf("Invalid archive rotation: %v", err), nil
 	}

internal/handlers/target_create_query_test.go

@@ -196,7 +196,7 @@ func TestHandleTargetCreate_QueryStringCannotSupplyNameOrType(
 
 	w, _ := postTargetCreate(
 		t, env, webhook.ID,
-		"name=leaky&type=slack&max_retries=9&expiry=30d&url="+
+		"name=leaky&type=slack&max_attempts=9&expiry=30d&url="+
 			url.QueryEscape(targetSecretURL),
 		url.Values{},
 	)

internal/handlers/target_create_test.go

@@ -21,24 +21,24 @@ func TestHandleTargetCreate_EveryType(t *testing.T) {
 
 	// fields is the rest of each submission, as a query string.
 	cases := []struct {
-		targetType  database.TargetType
+		targetType   database.TargetType
-		fields      string
+		fields       string
-		wantConfig  string
+		wantConfig   string
-		wantRetries int
+		wantAttempts int
 	}{
 		{
-			database.TargetTypeHTTP, "timeout=12&max_retries=3",
+			database.TargetTypeHTTP, "timeout=12&max_attempts=3",
 			`{"url":"` + editOriginalURL + `","timeout":12}`, 3,
 		},
 		{
-			database.TargetTypeSlack, "max_retries=4",
+			database.TargetTypeSlack, "max_attempts=4",
 			`{"webhookUrl":"` + editOriginalURL + `"}`, 4,
 		},
 		{
 			database.TargetTypeDatabase, "expiry=720h",
-			`{"expiry":"720h"}`, 0,
+			`{"expiry":"720h"}`, 1,
 		},
-		{database.TargetTypeLog, "", "", 0},
+		{database.TargetTypeLog, "", "", 1},
 	}
 
 	for _, tc := range cases {
@@ -62,7 +62,7 @@ func TestHandleTargetCreate_EveryType(t *testing.T) {
 			targets := targetsForWebhook(t, env.db, webhook.ID)
 			require.Len(t, targets, 1)
 			assert.Equal(t, tc.targetType, targets[0].Type)
-			assert.Equal(t, tc.wantRetries, targets[0].MaxRetries)
+			assert.Equal(t, tc.wantAttempts, targets[0].MaxAttempts)
 
 			if tc.wantConfig == "" {
 				assert.Empty(t, targets[0].Config)
@@ -90,11 +90,11 @@ func TestHandleTargetCreate_RefusedFormComesBack(t *testing.T) {
 		{
 			database.TargetTypeHTTP,
 			"name=private&url=" + editBlockedURL +
-				"&timeout=12&max_retries=3",
+				"&timeout=12&max_attempts=3",
 			"Invalid target URL",
 		},
 		{
-			database.TargetTypeSlack, "name=no-url&max_retries=4",
+			database.TargetTypeSlack, "name=no-url&max_attempts=4",
 			"Webhook URL is required for Slack targets",
 		},
 		{
@@ -133,8 +133,8 @@ func TestHandleTargetCreate_RefusedFormComesBack(t *testing.T) {
 			assert.Contains(t, page, html.EscapeString(tc.reason))
 
 			// Each value comes back in a data attribute of the targets
-			// section named after its field (max_retries as
+			// section named after its field (max_attempts as
-			// data-max-retries), except url, which comes back in
+			// data-max-attempts), except url, which comes back in
 			// data-destination; templates/source_detail.html says why.
 			for field := range typed {
 				attr := "data-" + strings.ReplaceAll(field, "_", "-")

internal/handlers/target_download.go

@@ -6,8 +6,8 @@ import (
 	"net/http"
 	"time"
 
+	"sneak.berlin/go/webhooker/internal/archive"
 	"sneak.berlin/go/webhooker/internal/database"
-	"sneak.berlin/go/webhooker/internal/delivery"
 )
 
 // downloadWriteTimeout is how long one write of a download may wait
@@ -16,7 +16,7 @@ const downloadWriteTimeout = 60 * time.Second
 
 // HandleTargetDownload serves a database target's archive as one
 // gzipped JSON file, named for the webhook, the target and the time;
-// see delivery.ArchiveExport.WriteGzipJSON for what it holds. Other
+// see archive.Export.WriteGzipJSON for what it holds. Other
 // target types have no archive and are a 404.
 //
 // A download runs for as long as the client keeps reading: it reads
@@ -37,7 +37,7 @@ func (h *Handlers) HandleTargetDownload() http.HandlerFunc {
 		w.Header().Set("Content-Type", "application/gzip")
 		w.Header().Set(
 			"Content-Disposition",
-			`attachment; filename="`+delivery.ArchiveExportFileName(
+			`attachment; filename="`+archive.ExportFileName(
 				webhook.Name, target.Name, now,
 			)+`"`,
 		)
@@ -82,17 +82,17 @@ func (d downloadWriter) Write(b []byte) (int, error) {
 // listTargetArchive lists the archive files of the request's database
 // target for export. It reports false once it has written the response.
 //
-// It holds renameMu, which every archive rename runs under, while it
+// It holds the rename lock, which every archive rename runs under,
-// reads the stored names and lists the files, so the files it lists
+// while it reads the stored names and lists the files, so the files it
-// are the ones those names give. It lets go before the export is
+// lists are the ones those names give. It lets go before the export is
-// streamed, which takes renameMu again for each file only while it
+// streamed, which takes the lock again for each file only while it
 // finds the file under the names stored then and opens it.
 func (h *Handlers) listTargetArchive(
 	w http.ResponseWriter,
 	r *http.Request,
-) (database.Webhook, *database.Target, *delivery.ArchiveExport, bool) {
+) (database.Webhook, *database.Target, *archive.Export, bool) {
-	h.renameMu.Lock()
+	h.archives.RenameLock().Lock()
-	defer h.renameMu.Unlock()
+	defer h.archives.RenameLock().Unlock()
 
 	webhook, target, ok := h.ownedTarget(w, r)
 	if !ok {
@@ -105,9 +105,9 @@ func (h *Handlers) listTargetArchive(
 		return database.Webhook{}, nil, nil, false
 	}
 
-	export, err := delivery.NewArchiveExport(
+	export, err := archive.NewExport(
-		delivery.ArchivePath(h.dbMgr, &webhook, target),
+		archive.Path(h.dbMgr, &webhook, target),
-		&h.renameMu,
+		h.archives.RenameLock(),
 		func() (string, error) {
 			return h.storedArchivePath(webhook.ID, target.ID)
 		},
@@ -122,9 +122,9 @@ func (h *Handlers) listTargetArchive(
 	return webhook, target, export, true
 }
 
-// storedArchivePath returns the path delivery.ArchivePath gives a
+// storedArchivePath returns the path archive.Path gives a
 // database target under the names stored for it and its webhook now.
-// Its caller holds renameMu. A webhook or target deleted since is still
+// Its caller holds the rename lock. A webhook or target deleted since is still
 // found, since deleting one leaves its archive files under their names.
 func (h *Handlers) storedArchivePath(
 	webhookID, targetID string,
@@ -143,5 +143,5 @@ func (h *Handlers) storedArchivePath(
 		return "", err
 	}
 
-	return delivery.ArchivePath(h.dbMgr, &webhook, &target), nil
+	return archive.Path(h.dbMgr, &webhook, &target), nil
 }

internal/handlers/target_download_test.go

@@ -21,9 +21,9 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/webhooker/internal/archive"
 	"sneak.berlin/go/webhooker/internal/config"
 	"sneak.berlin/go/webhooker/internal/database"
-	"sneak.berlin/go/webhooker/internal/delivery"
 	"sneak.berlin/go/webhooker/internal/middleware/middlewaretest"
 )
 
@@ -223,8 +223,8 @@ func TestHandleTargetDownload_FindsFilesAfterRename(t *testing.T) {
 
 	env := setupSourceTest(t)
 	wh := seedWebhookWithRetention(t, env.db, 7)
-	archive := seedTarget(t, env.db, wh.ID, database.TargetTypeDatabase)
+	target := seedTarget(t, env.db, wh.ID, database.TargetTypeDatabase)
-	oldPath := delivery.ArchivePath(env.dbMgr, &wh, archive)
+	oldPath := archive.Path(env.dbMgr, &wh, target)
 
 	month := func(path string) string {
 		return strings.TrimSuffix(path, ".db") + "-2026-10.db"
@@ -233,19 +233,19 @@ func TestHandleTargetDownload_FindsFilesAfterRename(t *testing.T) {
 	seedArchive(t, oldPath, 1, 16)
 	seedArchive(t, month(oldPath), 1, 16)
 
-	sw, downloaded := startStalledDownload(t, env, wh.ID, archive.ID)
+	sw, downloaded := startStalledDownload(t, env, wh.ID, target.ID)
 
 	require.Equal(t,
-		http.StatusSeeOther, renameTarget(env, wh.ID, archive.ID).Code,
+		http.StatusSeeOther, renameTarget(env, wh.ID, target.ID).Code,
 	)
 
 	// The test's archives record a rename without moving any file, so
-	// the files are moved here, as the delivery engine moves them.
+	// the files are moved here, as the archive writers move them.
 	var renamed database.Target
 
-	require.NoError(t, env.db.DB().First(&renamed, "id = ?", archive.ID).Error)
+	require.NoError(t, env.db.DB().First(&renamed, "id = ?", target.ID).Error)
 
-	newPath := delivery.ArchivePath(env.dbMgr, &wh, &renamed)
+	newPath := archive.Path(env.dbMgr, &wh, &renamed)
 
 	require.NoError(t, os.Rename(oldPath, newPath))
 	require.NoError(t, os.Rename(month(oldPath), month(newPath)))
@@ -355,16 +355,16 @@ func TestHandleTargetDownload_OutlastsTheRequestLimit(t *testing.T) {
 
 	env := setupSourceTest(t)
 	wh := seedWebhookWithRetention(t, env.db, 7)
-	archive := seedTarget(t, env.db, wh.ID, database.TargetTypeDatabase)
+	target := seedTarget(t, env.db, wh.ID, database.TargetTypeDatabase)
 	seedArchive(
-		t, delivery.ArchivePath(env.dbMgr, &wh, archive), rows, bodySize,
+		t, archive.Path(env.dbMgr, &wh, target), rows, bodySize,
 	)
 
 	srv, accessLog := limitedServer(t, env, limit)
 
 	req, err := http.NewRequestWithContext(
 		t.Context(), http.MethodGet,
-		srv.URL+downloadPath(wh.ID, archive.ID), nil,
+		srv.URL+downloadPath(wh.ID, target.ID), nil,
 	)
 	require.NoError(t, err)
 

internal/handlers/target_edit.go

@@ -6,6 +6,7 @@ import (
 	"strconv"
 
 	"github.com/go-chi/chi"
+	"sneak.berlin/go/webhooker/internal/archive"
 	"sneak.berlin/go/webhooker/internal/database"
 	"sneak.berlin/go/webhooker/internal/delivery"
 )
@@ -82,7 +83,7 @@ func (h *Handlers) HandleTargetEdit() http.HandlerFunc {
 			Headers:      cfg.Headers,
 			Timeout:      cfg.Timeout,
 			ForwardQuery: cfg.ForwardQuery,
-			MaxRetries:   strconv.Itoa(target.MaxRetries),
+			MaxAttempts:  strconv.Itoa(target.MaxAttempts),
 			Expiry:       cfg.Expiry,
 			Rotation:     cfg.Rotation,
 		}
@@ -96,8 +97,8 @@ func (h *Handlers) HandleTargetEdit() http.HandlerFunc {
 // HandleTargetEditSubmit handles the target edit form submission.
 func (h *Handlers) HandleTargetEditSubmit() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		h.renameMu.Lock()
+		h.archives.RenameLock().Lock()
-		defer h.renameMu.Unlock()
+		defer h.archives.RenameLock().Unlock()
 
 		webhook, target, ok := h.ownedTarget(w, r)
 		if !ok {
@@ -157,7 +158,7 @@ func (h *Handlers) applyTargetEdit(
 	}
 
 	// A new name renames the archive file before it is saved (see
-	// delivery.Engine.Rename). If either step fails, it goes back to
+	// archive.Writers.Rename). If either step fails, it goes back to
 	// the name that is still stored.
 	err = h.renameTargetArchive(
 		target, webhook.Name, target.Name, edited.Name,
@@ -178,7 +179,7 @@ func (h *Handlers) applyTargetEdit(
 			)
 		}
 
-		if errors.Is(err, delivery.ErrArchiveNameTaken) {
+		if errors.Is(err, archive.ErrNameTaken) {
 			h.renderTargetEdit(
 				w, r, webhook, target, in,
 				"Not saved: "+err.Error()+

internal/handlers/target_edit_test.go

@@ -117,7 +117,7 @@ func seedHTTPTarget(
 	form.Set("url", editOriginalURL)
 	form.Set("headers", headers)
 	form.Set("timeout", timeout)
-	form.Set("max_retries", "3")
+	form.Set("max_attempts", "3")
 
 	w := serveTarget(
 		env, http.MethodPost,
@@ -179,7 +179,7 @@ func editForm(targetURL, headers, timeout string) url.Values {
 	form.Set("url", targetURL)
 	form.Set("headers", headers)
 	form.Set("timeout", timeout)
-	form.Set("max_retries", "5")
+	form.Set("max_attempts", "5")
 
 	return form
 }
@@ -280,9 +280,9 @@ func TestHandleTargetEditSubmit_Saves(t *testing.T) {
 		assertEditClearingRemovesThem(t, env)
 	})
 
-	t.Run("absent max_retries is not zeroed", func(t *testing.T) {
+	t.Run("absent max_attempts is kept", func(t *testing.T) {
 		t.Parallel()
-		assertEditKeepsAbsentMaxRetries(t, env)
+		assertEditKeepsAbsentMaxAttempts(t, env)
 	})
 }
 
@@ -307,7 +307,7 @@ func assertEditChangesDestination(
 
 	reloaded := storedTarget(t, env, target.ID)
 	assert.Equal(t, "edited-name", reloaded.Name)
-	assert.Equal(t, 5, reloaded.MaxRetries)
+	assert.Equal(t, 5, reloaded.MaxAttempts)
 	assert.Equal(
 		t, database.TargetTypeHTTP, reloaded.Type,
 		"the edit form must not change a target's type",
@@ -368,25 +368,25 @@ func assertEditClearingRemovesThem(
 	assert.Zero(t, cfg.Timeout)
 }
 
-// Retries are offered only by the forms for target types that retry.
+// Delivery attempts are offered only by the forms for target types
-// An absent field means the form does not edit retries, not that
+// that retry. An absent field means the form does not edit them, not
-// they should be turned off.
+// that retries should be turned off.
-func assertEditKeepsAbsentMaxRetries(
+func assertEditKeepsAbsentMaxAttempts(
 	t *testing.T, env *sourceTestEnv,
 ) {
 	t.Helper()
 
 	webhook, target := seedHTTPTarget(t, env, "", "")
-	require.Equal(t, 3, target.MaxRetries)
+	require.Equal(t, 3, target.MaxAttempts)
 
 	form := editForm(editOriginalURL, "", "")
-	form.Del("max_retries")
+	form.Del("max_attempts")
 
 	w := submitTargetEdit(env, webhook.ID, target.ID, form)
 	require.Equal(t, http.StatusSeeOther, w.Code, w.Body.String())
 
 	assert.Equal(
-		t, 3, storedTarget(t, env, target.ID).MaxRetries,
+		t, 3, storedTarget(t, env, target.ID).MaxAttempts,
 	)
 }
 
@@ -659,12 +659,12 @@ func TestHandleTargetEditSubmit_RefusedFormComesBack(t *testing.T) {
 		{
 			database.TargetTypeHTTP,
 			"name=edited&url=" + editBlockedURL +
-				"&headers=X-Edited:+kept&timeout=12&max_retries=3",
+				"&headers=X-Edited:+kept&timeout=12&max_attempts=3",
 			"Invalid target URL",
 		},
 		{
 			database.TargetTypeSlack,
-			"name=edited&url=" + editOriginalURL + "&max_retries=25",
+			"name=edited&url=" + editOriginalURL + "&max_attempts=25",
 			"Invalid delivery attempts",
 		},
 		{

internal/handlers/target_list.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/dustin/go-humanize"
 	"gorm.io/gorm"
+	"sneak.berlin/go/webhooker/internal/archive"
 	"sneak.berlin/go/webhooker/internal/database"
 	"sneak.berlin/go/webhooker/internal/delivery"
 )
@@ -242,7 +243,7 @@ func readTargetDeliveries(
 func (h *Handlers) archiveFileView(
 	webhook *database.Webhook, target *database.Target, now time.Time,
 ) *ArchiveFileView {
-	current, err := delivery.ArchivePathAt(h.dbMgr, webhook, target, now)
+	current, err := archive.PathAt(h.dbMgr, webhook, target, now)
 	if err != nil {
 		return h.archiveUnreadable(&ArchiveFileView{}, target, err)
 	}
@@ -254,8 +255,8 @@ func (h *Handlers) archiveFileView(
 		view.Note = "not created yet"
 	}
 
-	files, err := delivery.StatArchive(
+	files, err := archive.Stat(
-		delivery.ArchivePath(h.dbMgr, webhook, target),
+		archive.Path(h.dbMgr, webhook, target),
 	)
 
 	switch {

internal/handlers/target_list_test.go

@@ -10,8 +10,8 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/webhooker/internal/archive"
 	"sneak.berlin/go/webhooker/internal/database"
-	"sneak.berlin/go/webhooker/internal/delivery"
 	"sneak.berlin/go/webhooker/internal/handlers"
 	"sneak.berlin/go/webhooker/internal/logger"
 	"sneak.berlin/go/webhooker/internal/session"
@@ -38,10 +38,10 @@ func TestHandleSourceDetail_ShowsArchiveFile(t *testing.T) {
 	t.Cleanup(app.RequireStop)
 
 	wh := seedWebhook(t, db)
-	archive := seedTarget(t, db, wh.ID, database.TargetTypeDatabase)
+	target := seedTarget(t, db, wh.ID, database.TargetTypeDatabase)
 	seedTarget(t, db, wh.ID, database.TargetTypeLog)
 
-	path := delivery.ArchivePath(dbMgr, wh, archive)
+	path := archive.Path(dbMgr, wh, target)
 
 	body := renderSourceDetailPage(t, h, sess, wh.ID)
 	assert.Equal(t, 1, strings.Count(body, "Archive file:"))

internal/handlers/target_retries.go

@@ -1,83 +0,0 @@
-package handlers
-
-import (
-	"errors"
-	"strconv"
-	"strings"
-)
-
-// maxTargetRetries bounds a target's max_retries.
-//
-// Both target forms already declare max="20" on the input, so this
-// enforces server-side what the UI has always advertised rather than
-// introducing a new limit.
-//
-// The number is not cosmetic. Every attempt writes a delivery_results
-// row that the event log then loads and renders, and the engine backs
-// off by 2^(n-1) seconds, so attempt 20 is already about six days
-// after the first. A value beyond this buys no additional durability
-// and only costs rows.
-const maxTargetRetries = 20
-
-// Errors returned when a max_retries form value cannot be turned into
-// a retry count.
-var (
-	// errRetriesInvalid signals a max_retries form value that is not
-	// a non-negative whole number.
-	errRetriesInvalid = errors.New(
-		"must be a whole number",
-	)
-
-	// errRetriesTooLarge signals a max_retries form value that is a
-	// whole number but above maxTargetRetries. It is distinguished
-	// from errRetriesInvalid so the message can name the ceiling
-	// instead of implying the input was not a number.
-	errRetriesTooLarge = errors.New("out of range")
-)
-
-// parseMaxRetries interprets a max_retries form value.
-//
-// An ABSENT value — the field empty or not submitted — yields
-// fallback, which lets the create path apply its default and the edit
-// path leave the stored value alone. A value that is SET BUT INVALID
-// is an error: unparseable, negative, or above maxTargetRetries.
-//
-// The distinction is the whole point of this function. max_retries=0
-// means fire-and-forget, so returning 0 for input the operator typed
-// but that did not parse silently disables retries on a
-// store-and-forward proxy — and on the edit path it destroys a
-// working retry configuration over a typo. A default answers a
-// question that was not asked; it never answers one that was asked
-// badly.
-func parseMaxRetries(raw string, fallback int) (int, error) {
-	raw = strings.TrimSpace(raw)
-	if raw == "" {
-		return fallback, nil
-	}
-
-	v, err := strconv.Atoi(raw)
-	if err != nil || v < 0 {
-		return 0, errRetriesInvalid
-	}
-
-	if v > maxTargetRetries {
-		return 0, errRetriesTooLarge
-	}
-
-	return v, nil
-}
-
-// retriesErrorMessage returns the message the create and edit forms
-// show for a rejected max_retries value. Any error other than
-// errRetriesTooLarge falls back to the generic wording, so an
-// unrecognised parse failure still produces a sensible 400.
-func retriesErrorMessage(err error) string {
-	if errors.Is(err, errRetriesTooLarge) {
-		return errRetriesTooLarge.Error() +
-			": at most " + strconv.Itoa(maxTargetRetries) +
-			" attempts"
-	}
-
-	return errRetriesInvalid.Error() +
-		", or 0 for fire-and-forget"
-}

internal/handlers/target_retries_test.go

@@ -1,385 +0,0 @@
-package handlers_test
-
-import (
-	"net/http"
-	"net/url"
-	"strconv"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"sneak.berlin/go/webhooker/internal/database"
-	"sneak.berlin/go/webhooker/internal/handlers"
-)
-
-// retriesTargetURL is the destination the retry-validation targets
-// point at. It is a literal public address rather than a hostname so
-// the SSRF check resolves nothing and a sandbox without DNS cannot
-// make these cases pass or fail for the wrong reason.
-const retriesTargetURL = "https://93.184.216.34/hooks/retries"
-
-const (
-	// wayAboveCeiling is the typo'd-extra-zero case from the report.
-	wayAboveCeiling = "999999999"
-
-	// notANumber is the plainest garbage an operator can type, and
-	// the value the report submitted on the edit form.
-	notANumber = "abc"
-
-	// workingRetries is the retry count a seeded target is already
-	// delivering with, which a rejected submission must not disturb.
-	workingRetries = 2
-)
-
-// aboveCeiling is the smallest rejected whole number.
-func aboveCeiling() string {
-	return strconv.Itoa(handlers.MaxTargetRetriesForTest + 1)
-}
-
-// overCeilingRetries is whole-number input past the limit, which is
-// rejected with the limit named.
-func overCeilingRetries() []string {
-	return []string{aboveCeiling(), wayAboveCeiling}
-}
-
-// unparseableRetries is input an operator can type into the field
-// that is not a retry count. Each must be REJECTED: silently reading
-// any of them as 0 turns a store-and-forward proxy into
-// fire-and-forget without saying so.
-//
-// The twenty-digit case is here because it parses as digits but
-// overflows int, which is the one failure the field's own min/max
-// attributes cannot describe.
-func unparseableRetries() []string {
-	return []string{
-		notANumber,
-		"2.7",
-		"-5",
-		"12345678901234567890",
-		"1e3",
-	}
-}
-
-// createRetriesForm is a complete, otherwise-valid HTTP target
-// creation, so the only thing any case below varies is max_retries.
-func createRetriesForm(retries string) url.Values {
-	form := url.Values{}
-	form.Set("name", "retries-target")
-	form.Set("type", string(database.TargetTypeHTTP))
-	form.Set("url", retriesTargetURL)
-
-	if retries != absentField {
-		form.Set("max_retries", retries)
-	}
-
-	return form
-}
-
-// absentField marks a field the form does not submit at all, which is
-// the case that legitimately takes a default and must stay distinct
-// from a field submitted with garbage in it.
-const absentField = "\x00absent"
-
-// absentRetries is every way of saying "the operator did not set
-// this", each of which takes the default rather than a 400. Blank and
-// whitespace-only count as absent here because they do in the timeout
-// and retention controls on the same forms; a rule the fields do not
-// share would be its own surprise.
-func absentRetries() []string {
-	return []string{absentField, "", "  "}
-}
-
-// createWithRetries posts the target create form for a fresh webhook
-// and returns the webhook and the response.
-func createWithRetries(
-	t *testing.T,
-	env *sourceTestEnv,
-	retries string,
-) (database.Webhook, int, string) {
-	t.Helper()
-
-	webhook := seedWebhookWithRetention(t, env.db, 30)
-
-	w := serveTarget(
-		env, http.MethodPost,
-		"/hook/"+webhook.ID+"/targets",
-		createRetriesForm(retries),
-	)
-
-	return webhook, w.Code, w.Body.String()
-}
-
-// TestTargetCreate_RetriesAboveCeilingRejected proves the create form
-// enforces a ceiling at all, and that the 400 names it — a rejection
-// that does not say what the limit is leaves the operator guessing.
-func TestTargetCreate_RetriesAboveCeilingRejected(t *testing.T) {
-	t.Parallel()
-
-	env := setupSourceTest(t)
-	ceiling := strconv.Itoa(handlers.MaxTargetRetriesForTest)
-
-	for _, retries := range overCeilingRetries() {
-		webhook, code, body := createWithRetries(t, env, retries)
-
-		assert.Equal(t, http.StatusBadRequest, code,
-			"max_retries=%s should be rejected", retries)
-		assert.Contains(t, body, ceiling,
-			"the rejection for %s should name the ceiling",
-			retries)
-		assert.Empty(t,
-			targetsForWebhook(t, env.db, webhook.ID),
-			"no target should be created for %s", retries)
-	}
-}
-
-// TestTargetCreate_UnparseableRetriesRejected is the core of the
-// defect: each of these was accepted with HTTP 200 and stored as 0.
-func TestTargetCreate_UnparseableRetriesRejected(t *testing.T) {
-	t.Parallel()
-
-	env := setupSourceTest(t)
-
-	for _, retries := range unparseableRetries() {
-		webhook, code, body := createWithRetries(t, env, retries)
-
-		assert.Equal(t, http.StatusBadRequest, code,
-			"max_retries=%q should be rejected, not coerced",
-			retries)
-		assert.Contains(t, body, "whole number",
-			"the rejection for %q should say why", retries)
-		assert.Empty(t,
-			targetsForWebhook(t, env.db, webhook.ID),
-			"no target should be created for %q", retries)
-	}
-}
-
-// TestTargetCreate_ValidRetriesStored covers the accepting half,
-// including the ceiling itself: a bound that rejects its own limit
-// would make the advertised maximum unreachable.
-func TestTargetCreate_ValidRetriesStored(t *testing.T) {
-	t.Parallel()
-
-	env := setupSourceTest(t)
-
-	for _, want := range []int{0, 3, handlers.MaxTargetRetriesForTest} {
-		webhook, code, body := createWithRetries(
-			t, env, strconv.Itoa(want),
-		)
-
-		require.Equal(t, http.StatusSeeOther, code, body)
-
-		targets := targetsForWebhook(t, env.db, webhook.ID)
-		require.Len(t, targets, 1)
-		assert.Equal(t, want, targets[0].MaxRetries)
-	}
-}
-
-// TestTargetCreate_AbsentRetriesTakesDefault keeps the two cases
-// distinct. An omitted field is not an operator asking for something
-// invalid, so it still gets the fire-and-forget default rather than a
-// 400 — otherwise the fix above would make the form unusable.
-func TestTargetCreate_AbsentRetriesTakesDefault(t *testing.T) {
-	t.Parallel()
-
-	env := setupSourceTest(t)
-
-	for _, retries := range absentRetries() {
-		webhook, code, body := createWithRetries(t, env, retries)
-
-		require.Equal(t, http.StatusSeeOther, code, body)
-
-		targets := targetsForWebhook(t, env.db, webhook.ID)
-		require.Len(t, targets, 1)
-		assert.Equal(t, 0, targets[0].MaxRetries,
-			"an absent max_retries should take the default")
-	}
-}
-
-// seedRetriesTarget creates an HTTP target already delivering with
-// workingRetries retries, through the real create handler.
-func seedRetriesTarget(
-	t *testing.T,
-	env *sourceTestEnv,
-) (database.Webhook, database.Target) {
-	t.Helper()
-
-	webhook, code, body := createWithRetries(
-		t, env, strconv.Itoa(workingRetries),
-	)
-	require.Equal(t, http.StatusSeeOther, code, body)
-
-	targets := targetsForWebhook(t, env.db, webhook.ID)
-	require.Len(t, targets, 1)
-	require.Equal(t, workingRetries, targets[0].MaxRetries)
-
-	return webhook, targets[0]
-}
-
-// editRetriesForm is a complete edit submission that changes the
-// target's name as well, so a rejected submission can be shown to
-// have written nothing at all rather than merely to have left
-// max_retries alone.
-func editRetriesForm(retries string) url.Values {
-	form := url.Values{}
-	form.Set("name", "renamed-by-edit")
-	form.Set("url", retriesTargetURL)
-
-	if retries != absentField {
-		form.Set("max_retries", retries)
-	}
-
-	return form
-}
-
-// assertEditRejectedAndUnchanged submits an edit expected to fail and
-// checks both halves of the requirement: the 400 explains itself, and
-// the target it was submitted against is untouched.
-func assertEditRejectedAndUnchanged(
-	t *testing.T,
-	env *sourceTestEnv,
-	retries, wantReason string,
-) {
-	t.Helper()
-
-	webhook, target := seedRetriesTarget(t, env)
-
-	w := submitTargetEdit(
-		env, webhook.ID, target.ID, editRetriesForm(retries),
-	)
-
-	assert.Equal(t, http.StatusBadRequest, w.Code,
-		"max_retries=%q should be rejected on edit", retries)
-	assert.Contains(t, w.Body.String(), wantReason,
-		"the rejection for %q should say why", retries)
-
-	stored := storedTarget(t, env, target.ID)
-	assert.Equal(t, workingRetries, stored.MaxRetries,
-		"a rejected edit must not destroy the working retry "+
-			"count with %q", retries)
-	assert.Equal(t, "retries-target", stored.Name,
-		"a rejected edit must write nothing at all")
-}
-
-// TestTargetEdit_UnparseableRetriesRejected is the damaging half of
-// the defect. A target delivering with two retries, re-saved with a
-// typo in the field, returned 200 and was left with retries disabled
-// and nothing said.
-func TestTargetEdit_UnparseableRetriesRejected(t *testing.T) {
-	t.Parallel()
-
-	env := setupSourceTest(t)
-
-	for _, retries := range unparseableRetries() {
-		assertEditRejectedAndUnchanged(
-			t, env, retries, "whole number",
-		)
-	}
-}
-
-// TestTargetEdit_RetriesAboveCeilingRejected proves the ceiling
-// applies to the edit path too, naming itself, so the two paths
-// cannot disagree about what is storable.
-func TestTargetEdit_RetriesAboveCeilingRejected(t *testing.T) {
-	t.Parallel()
-
-	env := setupSourceTest(t)
-	ceiling := strconv.Itoa(handlers.MaxTargetRetriesForTest)
-
-	for _, retries := range overCeilingRetries() {
-		assertEditRejectedAndUnchanged(t, env, retries, ceiling)
-	}
-}
-
-// TestTargetEdit_ValidRetriesStored covers the accepting half of the
-// edit path, so the ceiling cannot be enforced by simply refusing
-// every submission.
-func TestTargetEdit_ValidRetriesStored(t *testing.T) {
-	t.Parallel()
-
-	env := setupSourceTest(t)
-
-	for _, want := range []int{0, 9, handlers.MaxTargetRetriesForTest} {
-		webhook, target := seedRetriesTarget(t, env)
-
-		w := submitTargetEdit(
-			env, webhook.ID, target.ID,
-			editRetriesForm(strconv.Itoa(want)),
-		)
-		require.Equal(t,
-			http.StatusSeeOther, w.Code, w.Body.String(),
-		)
-
-		assert.Equal(t, want,
-			storedTarget(t, env, target.ID).MaxRetries)
-	}
-}
-
-// TestTargetEdit_AbsentRetriesLeavesStoredValue is the edit path's
-// absent-versus-invalid case. Retries are only offered by the forms
-// for types that retry, so a submission without the field must leave
-// the stored count alone rather than be rejected or zeroed.
-func TestTargetEdit_AbsentRetriesLeavesStoredValue(t *testing.T) {
-	t.Parallel()
-
-	env := setupSourceTest(t)
-
-	for _, retries := range absentRetries() {
-		webhook, target := seedRetriesTarget(t, env)
-
-		w := submitTargetEdit(
-			env, webhook.ID, target.ID,
-			editRetriesForm(retries),
-		)
-		require.Equal(t,
-			http.StatusSeeOther, w.Code, w.Body.String(),
-		)
-
-		assert.Equal(t, workingRetries,
-			storedTarget(t, env, target.ID).MaxRetries,
-			"an absent max_retries must leave the stored "+
-				"count alone (%q)", retries)
-	}
-}
-
-// TestTargetRetries_CreateAndEditAgreeOnEveryCase proves the two
-// paths cannot disagree, which is what let the create form and the
-// edit form drift apart in the first place. Every input is submitted
-// to both and the accept/reject verdicts are compared.
-func TestTargetRetries_CreateAndEditAgreeOnEveryCase(t *testing.T) {
-	t.Parallel()
-
-	env := setupSourceTest(t)
-
-	accepted := []string{
-		"0", "1",
-		strconv.Itoa(handlers.MaxTargetRetriesForTest),
-	}
-	overCeiling := overCeilingRetries()
-	unparseable := unparseableRetries()
-
-	cases := make(
-		[]string, 0,
-		len(accepted)+len(overCeiling)+len(unparseable),
-	)
-	cases = append(cases, accepted...)
-	cases = append(cases, overCeiling...)
-	cases = append(cases, unparseable...)
-
-	for _, retries := range cases {
-		_, createCode, _ := createWithRetries(t, env, retries)
-
-		webhook, target := seedRetriesTarget(t, env)
-		editCode := submitTargetEdit(
-			env, webhook.ID, target.ID,
-			editRetriesForm(retries),
-		).Code
-
-		assert.Equal(t,
-			createCode == http.StatusBadRequest,
-			editCode == http.StatusBadRequest,
-			"create and edit must agree on max_retries=%q "+
-				"(create %d, edit %d)",
-			retries, createCode, editCode,
-		)
-	}
-}

internal/handlers/target_toggle_test.go

@@ -59,7 +59,7 @@ func TestHandleTargetToggle_DoesNotUndoAnEdit(t *testing.T) {
 	stored := storedTarget(t, env, tgt.ID)
 	assert.False(t, stored.Active)
 	assert.Equal(t, "edited-name", stored.Name)
-	assert.Equal(t, 5, stored.MaxRetries)
+	assert.Equal(t, 5, stored.MaxAttempts)
 	assert.Equal(
 		t, editReplacedURL, storedHTTPConfig(t, env, tgt.ID).URL,
 	)

internal/handlers/ui_copy_test.go

@@ -184,8 +184,7 @@ func TestEventLogPageIsCalledFullEventLog(t *testing.T) {
 // TestCreateFormRetentionCopyMatchesBehaviour pins the create form's
 // retention copy to what the code does: the reaper permanently deletes
 // events past the cutoff, an empty field falls back to
-// DefaultRetentionDays, and 0 is rewritten to the retain-forever
+// DefaultRetentionDays, and 0 means retain forever.
-// sentinel by Webhook.BeforeSave.
 func TestCreateFormRetentionCopyMatchesBehaviour(t *testing.T) {
 	t.Parallel()
 
@@ -253,10 +252,7 @@ func TestEditFormRetentionCopyMatchesBehaviour(t *testing.T) {
 		"blank means unchanged, not forever",
 	)
 
-	forever := &database.Webhook{
+	forever := &database.Webhook{Name: "wh", RetentionDays: 0}
-		Name:          "wh",
-		RetentionDays: database.RetentionForeverDays,
-	}
 	forever.ID = "wh-2"
 
 	foreverBody := renderPage(
@@ -348,21 +344,19 @@ func TestEntrypointCopyButtonIsProgressiveEnhancement(t *testing.T) {
 	)
 }
 
-// maxRetriesHelp is the wording both target forms must carry. The
+// maxAttemptsHelp is the wording both target forms must carry. The
-// delivery core makes max_retries attempts in total, not that many
+// delivery core makes max_attempts attempts in total, not that many
 // retries on top of a first try (a fresh delivery starts at attempt 1
 // and target_http gives up once the attempt number reaches
-// max_retries), and 0 is special-cased to a single fire-and-forget
+// max_attempts).
-// attempt with no circuit breaker.
+const maxAttemptsHelp = "How many times each delivery is attempted in " +
-const maxRetriesHelp = "How many times each delivery is attempted in " +
+	"all, the first attempt included."
-	"all, the first attempt included. 0 means a single attempt with no " +
-	"retries and no circuit breaker."
 
-// TestTargetFormMaxRetriesCopyMatchesBehaviour pins the max_retries
+// TestTargetFormMaxAttemptsCopyMatchesBehaviour pins the max_attempts
 // label, "Delivery attempts", and help text on both the create form
 // (the add-target form on the webhook detail page) and the edit form,
 // so the copy cannot drift back to calling the number a retry count.
-func TestTargetFormMaxRetriesCopyMatchesBehaviour(t *testing.T) {
+func TestTargetFormMaxAttemptsCopyMatchesBehaviour(t *testing.T) {
 	t.Parallel()
 
 	var h *handlers.Handlers
@@ -394,11 +388,11 @@ func TestTargetFormMaxRetriesCopyMatchesBehaviour(t *testing.T) {
 
 	assert.Contains(t, createBody, "Delivery attempts:</label>")
 	assert.Contains(
-		t, createBody, maxRetriesHelp,
+		t, createBody, maxAttemptsHelp,
-		"the add-target form must explain max_retries as total attempts",
+		"the add-target form must explain max_attempts as total attempts",
 	)
 
-	// A slack target exercises the same max_retries field while needing
+	// A slack target exercises the same max_attempts field while needing
 	// only a URL from the edit template, so the test data stays
 	// minimal. The Target and TargetForm keys mirror the field names
 	// the template reads off the handler's values.
@@ -412,8 +406,8 @@ func TestTargetFormMaxRetriesCopyMatchesBehaviour(t *testing.T) {
 				"Active": true,
 			},
 			"TargetForm": map[string]any{
-				"URL":        "https://hooks.slack.com/services/x",
+				"URL":         "https://hooks.slack.com/services/x",
-				"MaxRetries": "3",
+				"MaxAttempts": "3",
 			},
 			dataKeyError: "",
 		},
@@ -421,8 +415,8 @@ func TestTargetFormMaxRetriesCopyMatchesBehaviour(t *testing.T) {
 
 	assert.Contains(t, editBody, `class="label">Delivery attempts</label>`)
 	assert.Contains(
-		t, editBody, maxRetriesHelp,
+		t, editBody, maxAttemptsHelp,
-		"the target edit form must explain max_retries as total attempts",
+		"the target edit form must explain max_attempts as total attempts",
 	)
 }
 

internal/handlers/webhook.go

@@ -10,7 +10,6 @@ import (
 	"gorm.io/gorm"
 	"sneak.berlin/go/webhooker/internal/database"
 	"sneak.berlin/go/webhooker/internal/delivery"
-	"sneak.berlin/go/webhooker/internal/logfield"
 	"sneak.berlin/go/webhooker/internal/middleware"
 )
 
@@ -49,14 +48,13 @@ func (h *Handlers) HandleWebhook() http.HandlerFunc {
 			return
 		}
 
-		// Logged only once the UUID is known to name a real
+		// Logged only once the lookup has found the entrypoint, so
-		// entrypoint. The UUID comes straight out of the path on
+		// an invented path writes no INFO line; a miss is logged at
-		// the one unauthenticated endpoint, so logging it before
+		// DEBUG. The entrypoint is named by its ID: the UUID is its
-		// the lookup let a client write an INFO line per invented
+		// credential and is never logged.
-		// path; the request itself is already in the access log
-		// and a miss is already logged at DEBUG.
 		h.log.Info("webhook request received",
-			"entrypoint_uuid", entrypointUUID,
+			"entrypoint_id", entrypoint.ID,
+			"webhook_id", entrypoint.WebhookID,
 			"method", r.Method,
 			"remoteIP", middleware.RemoteIP(r),
 			"clientIP", middleware.ClientIP(r),
@@ -133,17 +131,10 @@ func (h *Handlers) lookupEntrypoint(
 		"path = ?", entrypointUUID,
 	).First(&entrypoint)
 	if result.Error != nil {
-		// The receiver is unauthenticated and /h/{uuid}
+		// Not even an unknown UUID is logged. The receiver's log
-		// matches any single segment, so this value is entirely
+		// lines never carry the path segment, which is a credential
-		// client-chosen on exactly the branch where the lookup
+		// whenever it names an entrypoint.
-		// failed. DEBUG is off by default; the cap is what keeps
+		h.log.Debug("entrypoint not found")
-		// turning it on from restoring an unbounded write.
-		h.log.Debug(
-			"entrypoint not found",
-			"path", logfield.Truncate(
-				entrypointUUID, logfield.MaxBytes,
-			),
-		)
 		http.NotFound(w, r)
 
 		return entrypoint, false
@@ -442,7 +433,7 @@ func buildDeliveryTasks(
 			TargetName:   targets[i].Name,
 			TargetType:   targets[i].Type,
 			TargetConfig: targets[i].Config,
-			MaxRetries:   targets[i].MaxRetries,
+			MaxAttempts:  targets[i].MaxAttempts,
 			Method:       event.Method,
 			RawQuery:     event.RawQuery,
 			Headers:      event.Headers,

internal/handlers/webhook_delete.go

@@ -77,8 +77,8 @@ func (h *Handlers) deleteWebhookResources(
 		"user_id", userID,
 	)
 
-	// Release the delivery engine's per-webhook archiving state
+	// Release the webhook's archive writers so a deleted
-	// so a deleted webhook's archive writer (and any handle open
+	// webhook's archive writer (and any handle open
 	// within its debounce window) does not linger for the
 	// process lifetime. The archive file itself is deliberately
 	// left on disk; see evictArchiveWriter.
@@ -150,9 +150,9 @@ func (h *Handlers) commitWebhookDeletion(
 	return tx.Commit().Error
 }
 
-// evictArchiveWriter asks the delivery engine to drop the cached
+// evictArchiveWriter asks the archive writers to drop the cached
-// archive writers of a webhook's database targets, closing their
+// writers of a webhook's database targets, closing their archive
-// archive file handles.
+// file handles.
 //
 // The archive database files are NOT deleted. Unlike the event
 // database — which is per-webhook working storage and is

internal/handlers/webhook_edit.go

@@ -6,8 +6,8 @@ import (
 	"strconv"
 
 	"github.com/go-chi/chi"
+	"sneak.berlin/go/webhooker/internal/archive"
 	"sneak.berlin/go/webhooker/internal/database"
-	"sneak.berlin/go/webhooker/internal/delivery"
 )
 
 // HandleSourceEdit shows the form to edit a webhook.
@@ -59,8 +59,8 @@ func (h *Handlers) HandleSourceEditSubmit() http.HandlerFunc {
 
 		sourceID := chi.URLParam(r, "sourceID")
 
-		h.renameMu.Lock()
+		h.archives.RenameLock().Lock()
-		defer h.renameMu.Unlock()
+		defer h.archives.RenameLock().Unlock()
 
 		var webhook database.Webhook
 
@@ -130,7 +130,7 @@ func (h *Handlers) applyWebhookEdit(
 	edited.RetentionDays = retentionDays
 
 	// A new name renames the archive files before it is saved (see
-	// delivery.Engine.Rename). If either step fails, the same targets'
+	// archive.Writers.Rename). If either step fails, the same targets'
 	// archives go back to the name that is still stored, without
 	// reading the main database again.
 	targets, err := h.renameWebhookArchives(
@@ -150,7 +150,7 @@ func (h *Handlers) applyWebhookEdit(
 			)
 		}
 
-		if errors.Is(err, delivery.ErrArchiveNameTaken) {
+		if errors.Is(err, archive.ErrNameTaken) {
 			h.renderWebhookEdit(
 				w, r, webhook, name, description, retention,
 				"Not saved: "+err.Error()+

internal/handlers/webhook_stats_test.go

@@ -500,7 +500,7 @@ func TestWebhookStats_PaneShowsRetentionPeriod(t *testing.T) {
 		want          string
 	}{
 		{30, "30 days"},
-		{database.RetentionForeverDays, "forever"},
+		{0, "forever"},
 	}
 
 	for _, tt := range tests {

internal/handlers/webhook_test.go

@@ -12,12 +12,15 @@ import (
 	"testing"
 
 	"github.com/go-chi/chi"
+	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"gorm.io/gorm/clause"
 	"sneak.berlin/go/webhooker/internal/config"
 	"sneak.berlin/go/webhooker/internal/database"
 	"sneak.berlin/go/webhooker/internal/handlers"
 	"sneak.berlin/go/webhooker/internal/middleware"
+	"sneak.berlin/go/webhooker/internal/middleware/middlewaretest"
 )
 
 // TestHandleWebhook_LogsClientNextToThePeer checks that the
@@ -99,6 +102,87 @@ func TestHandleWebhook_LogsClientNextToThePeer(t *testing.T) {
 	}
 }
 
+// TestHandleWebhook_LogsNoEntrypointUUID sends an accepted event, a
+// request over the receiver rate limit and a request for an unknown
+// UUID through the receiver as routes.go mounts it, and checks that
+// nothing logged, at any level, carries either UUID.
+func TestHandleWebhook_LogsNoEntrypointUUID(t *testing.T) {
+	t.Parallel()
+
+	var (
+		h  *handlers.Handlers
+		db *database.Database
+	)
+
+	cfg := &config.Config{DataDir: t.TempDir(), ReceiverRateLimit: 1}
+
+	app := newTestAppWithConfig(t, cfg, &h, &db)
+	app.RequireStart()
+
+	t.Cleanup(app.RequireStop)
+
+	buf := new(bytes.Buffer)
+	log := slog.New(slog.NewJSONHandler(
+		buf, &slog.HandlerOptions{Level: slog.LevelDebug},
+	))
+	h.SetLogForTest(log)
+	mw := middlewaretest.New(t, log, cfg, nil)
+
+	webhook := seedWebhook(t, db)
+	entrypoint := &database.Entrypoint{
+		WebhookID: webhook.ID,
+		Path:      uuid.New().String(),
+		Active:    true,
+	}
+	require.NoError(t, db.DB().Omit(clause.Associations).
+		Create(entrypoint).Error)
+
+	unknownUUID := uuid.New().String()
+
+	router := chi.NewRouter()
+	router.Use(mw.Logging())
+	router.With(mw.ReceiverRateLimit()).HandleFunc(
+		middleware.ReceiverRoute, h.HandleWebhook(),
+	)
+
+	// In order: the limit is one request per minute per path, so the
+	// second request for the known UUID is the rejected one.
+	for _, step := range []struct {
+		entrypointUUID string
+		wantStatus     int
+	}{
+		{entrypoint.Path, http.StatusOK},
+		{entrypoint.Path, http.StatusTooManyRequests},
+		{unknownUUID, http.StatusNotFound},
+	} {
+		req := httptest.NewRequestWithContext(
+			context.Background(), http.MethodPost,
+			"/h/"+step.entrypointUUID, strings.NewReader("{}"),
+		)
+		w := httptest.NewRecorder()
+		router.ServeHTTP(w, req)
+
+		require.Equal(t, step.wantStatus, w.Code)
+	}
+
+	// The lines this test is about were all written, so the checks
+	// below are not passing on an empty log.
+	for _, msg := range []string{
+		"webhook request received",
+		"webhook receiver rate limit exceeded",
+		"entrypoint not found",
+	} {
+		assert.Contains(t, buf.String(), `"msg":"`+msg+`"`)
+	}
+
+	assert.NotContains(t, buf.String(), entrypoint.Path)
+	assert.NotContains(t, buf.String(), unknownUUID)
+
+	line := receivedLine(t, buf)
+	assert.Equal(t, entrypoint.ID, line["entrypoint_id"])
+	assert.Equal(t, webhook.ID, line["webhook_id"])
+}
+
 // receivedLine returns the one "webhook request received" line in the
 // captured JSON log.
 func receivedLine(t *testing.T, buf *bytes.Buffer) map[string]any {

internal/middleware/accesslog_test.go

@@ -7,6 +7,7 @@ import (
 	"log/slog"
 	"net/http"
 	"net/http/httptest"
+	"strconv"
 	"strings"
 	"testing"
 
@@ -27,6 +28,13 @@ const floodRequests = 64
 // line for a redirected or rejected request may contain it.
 const attackerMarker = "QQATTACKERTEXTQQ"
 
+// knownEntrypointUUID and failingEntrypointUUID are the UUIDs the
+// stand-in receiver in accessLogRouter answers 200 and 500 to.
+const (
+	knownEntrypointUUID   = "6f1e2a9c-4b7d-4e3a-9c2f-1d8b5a7e3c60"
+	failingEntrypointUUID = "0b7c3e5a-2d9f-4a61-8e4b-7c1d6f2a9e35"
+)
+
 // maxLineBytes bounds a single access log line whose client-supplied
 // fields are of ordinary size. Well above what the fixed fields need,
 // well below the length of the oversized input the amplification tests
@@ -132,17 +140,21 @@ func accessLogRouter(m *middleware.Middleware) *chi.Mux {
 	)
 
 	router.HandleFunc(
-		"/h/{uuid}",
+		middleware.ReceiverRoute,
 		func(w http.ResponseWriter, r *http.Request) {
-			// Stands in for the real handler: an unknown entrypoint
+			// Stands in for the real handler: a known entrypoint
-			// UUID 404s, a known one succeeds.
+			// UUID succeeds, a failing one is a server error, and
-			if chi.URLParam(r, "uuid") != "known" {
+			// any other 404s.
+			switch chi.URLParam(r, "uuid") {
+			case knownEntrypointUUID:
+				w.WriteHeader(http.StatusOK)
+			case failingEntrypointUUID:
+				http.Error(
+					w, "boom", http.StatusInternalServerError,
+				)
+			default:
 				http.Error(w, "not found", http.StatusNotFound)
-
-				return
 			}
-
-			w.WriteHeader(http.StatusOK)
 		},
 	)
 
@@ -335,11 +347,13 @@ func oversizedValue(ch string) string {
 }
 
 // oversizedHeaders fills every client-supplied header the access log
-// reads with the same value.
+// reads with the same value. The Referer carries it as the host of an
+// absolute URL, because the access log keeps only a Referer's scheme
+// and host.
 func oversizedHeaders(value string) map[string]string {
 	return map[string]string{
 		"User-Agent":   value,
-		"Referer":      value,
+		"Referer":      "http://" + value,
 		"X-Request-Id": value,
 	}
 }
@@ -649,17 +663,111 @@ func TestAccessLog_SuccessKeepsConcretePathAndRedactsQuery(
 	router := accessLogRouter(m)
 
 	assert.Equal(
-		t, http.StatusOK, get(t, router, "/h/known?src=ci"),
+		t, http.StatusOK,
+		get(t, router, "/.well-known/healthcheck?src=ci"),
 	)
 
-	// The path resolved against a stored entrypoint, so it stays. The
-	// query never does: see TestAccessLog_UnauthenticatedSuccess...
 	entries := accessLogEntries(t, buf)
 	require.Len(t, entries, 1)
-	assert.Equal(t, "/h/known?(redacted)", entries[0]["url"])
+	assert.Equal(
+		t, "/.well-known/healthcheck?(redacted)", entries[0]["url"],
+	)
 	assert.NotContains(t, buf.String(), "src=ci")
 }
 
+// TestAccessLog_ReceiverNeverLogsTheUUID covers the two statuses that
+// keep the concrete path on every other route. On the receiver that
+// path carries the entrypoint UUID, so the line names the route
+// pattern instead.
+func TestAccessLog_ReceiverNeverLogsTheUUID(t *testing.T) {
+	t.Parallel()
+
+	for entrypointUUID, wantStatus := range map[string]int{
+		knownEntrypointUUID:   http.StatusOK,
+		failingEntrypointUUID: http.StatusInternalServerError,
+	} {
+		t.Run(strconv.Itoa(wantStatus), func(t *testing.T) {
+			t.Parallel()
+
+			m, buf := capturingMiddleware(t)
+			router := accessLogRouter(m)
+
+			assert.Equal(
+				t, wantStatus,
+				get(t, router, "/h/"+entrypointUUID+"?src=ci"),
+			)
+
+			entries := accessLogEntries(t, buf)
+			require.Len(t, entries, 1)
+			assert.Equal(t, middleware.ReceiverRoute, entries[0]["url"])
+			assert.NotContains(t, buf.String(), entrypointUUID)
+		})
+	}
+}
+
+// TestAccessLog_ReceiverPreflightNeverLogsTheUUID sends a CORS
+// preflight to the receiver in dev, in the production middleware
+// order. CORS answers it with 200 before chi routes it, so the line
+// names no route and carries no UUID.
+func TestAccessLog_ReceiverPreflightNeverLogsTheUUID(t *testing.T) {
+	t.Parallel()
+
+	m, buf := capturingMiddleware(t)
+
+	router := chi.NewRouter()
+	router.Use(m.Logging())
+	router.Use(m.CORS())
+	router.HandleFunc(
+		middleware.ReceiverRoute,
+		func(w http.ResponseWriter, _ *http.Request) {
+			w.WriteHeader(http.StatusOK)
+		},
+	)
+
+	req := httptest.NewRequestWithContext(
+		context.Background(), http.MethodOptions,
+		"/h/"+knownEntrypointUUID, nil,
+	)
+	req.Header.Set("Origin", "https://sender.example")
+	req.Header.Set("Access-Control-Request-Method", http.MethodPost)
+
+	w := httptest.NewRecorder()
+	router.ServeHTTP(w, req)
+	assert.Equal(t, http.StatusOK, w.Code)
+
+	entries := accessLogEntries(t, buf)
+	require.Len(t, entries, 1)
+	assert.Equal(t, unmatchedRouteLiteral, entries[0]["url"])
+	assert.NotContains(t, buf.String(), knownEntrypointUUID)
+}
+
+// TestAccessLog_RefererNeverLogsTheUUID sends receiver requests whose
+// Referer is the entrypoint URL, as a sender's is after it follows a
+// redirect from http:// to https://. The referer field keeps only the
+// scheme and host, and a Referer without them is logged as a marker.
+func TestAccessLog_RefererNeverLogsTheUUID(t *testing.T) {
+	t.Parallel()
+
+	m, buf := capturingMiddleware(t)
+	router := accessLogRouter(m)
+
+	for _, referer := range []string{
+		"http://webhooker.example/h/" + knownEntrypointUUID + "?src=ci",
+		"/h/" + knownEntrypointUUID,
+	} {
+		assert.Equal(t, http.StatusOK, getWithHeaders(
+			t, router, "/h/"+knownEntrypointUUID,
+			map[string]string{"Referer": referer},
+		))
+	}
+
+	entries := accessLogEntries(t, buf)
+	require.Len(t, entries, 2)
+	assert.Equal(t, "http://webhooker.example", entries[0]["referer"])
+	assert.Equal(t, "(redacted)", entries[1]["referer"])
+	assert.NotContains(t, buf.String(), knownEntrypointUUID)
+}
+
 func TestAccessLog_ServerErrorKeepsConcreteURL(t *testing.T) {
 	t.Parallel()
 

internal/middleware/logbound_test.go

@@ -10,8 +10,10 @@ package middleware_test
 //     the client's choosing.
 //   - CSRF's 403 rejection, at WARN, also registered ahead of
 //     RequireAuth.
-//   - The rate limiters' 429 rejection, at WARN, on the
+//   - The rate limiters' 429 rejection, at WARN. On the receiver
-//     unauthenticated receiver among others.
+//     route it names the route pattern rather than the path, and
+//     the limiters that log a path sit behind RequireAuth, so its cap
+//     is defensive.
 //   - RequireAuth's own unauthenticated-request line, at DEBUG.
 //   - RecordLoginFailure's throttle rejection, at WARN. Its cap is
 //     defensive rather than load-bearing today: chi pins the one
@@ -268,10 +270,14 @@ func logSites() map[string]logSite {
 			send:       postNoToken,
 			wantStatus: http.StatusForbidden,
 		},
-		// The per-entrypoint receiver limiter, unauthenticated. Its
+		// The 429 line every limiter but the aggregate one shares.
-		// bucket is keyed on the path, so the first request through a
+		// Mounted outside any route, as here, it logs the path, as
-		// fresh path is served and only the ones after it are
+		// it does for the limiters behind RequireAuth; on
-		// rejected; sendUntilLimited absorbs that.
+		// ReceiverRoute it names the pattern instead. The
+		// per-entrypoint receiver limiter's bucket is keyed on the
+		// path, so the first request through a fresh path is served
+		// and only the ones after it are rejected; sendUntilLimited
+		// absorbs that.
 		"receiver rate limit 429": {
 			build: func(
 				t *testing.T, m *middleware.Middleware,

internal/middleware/metrics.go

@@ -41,7 +41,8 @@ const unmatchedMethod = unmatchedRoute
 // after /h/ is client-chosen, so labelling by path lets any
 // unauthenticated client mint permanent series at will, and publishes
 // the entrypoint UUID (the receiver's only credential) in the scrape
-// while doing it.
+// while doing it. The access log and the 429 line read it for the
+// same reason: see ReceiverRoute.
 //
 // chi populates the route context during routeHTTP, so this is only
 // valid once routing has run. Every caller below is on the recording

internal/middleware/middleware.go

@@ -13,7 +13,6 @@ import (
 	"time"
 
 	basicauth "github.com/99designs/basicauth-go"
-	"github.com/go-chi/chi"
 	"github.com/go-chi/chi/middleware"
 	"github.com/go-chi/cors"
 	"github.com/prometheus/client_golang/prometheus"
@@ -23,6 +22,7 @@ import (
 	"sneak.berlin/go/webhooker/internal/config"
 	"sneak.berlin/go/webhooker/internal/globals"
 	"sneak.berlin/go/webhooker/internal/logfield"
+	"sneak.berlin/go/webhooker/internal/referer"
 	"sneak.berlin/go/webhooker/internal/session"
 )
 
@@ -96,14 +96,14 @@ const (
 	// It is also the ceiling on every OTHER line this service writes
 	// THROUGH SLOG that carries text an UNAUTHENTICATED client
 	// supplies. Those lines — the MaxBodySize rejection, the CSRF
-	// rejection, the rate-limit rejection, the unauthenticated-request
+	// rejection, the unauthenticated-request DEBUG line, the
-	// and unknown-entrypoint DEBUG lines, the failed-login DEBUG
+	// failed-login DEBUG lines, and the two login-throttle WARN
-	// lines, and the two login-throttle WARN lines ("login failure
+	// lines ("login failure limit exceeded" in loginguard.go and
-	// limit exceeded" in loginguard.go and "password verification
+	// "password verification capacity exhausted" in
-	// capacity exhausted" in internal/handlers/auth.go) — spend the
+	// internal/handlers/auth.go) — spend the same per-field budgets,
-	// same per-field budgets, and each carries strictly fewer
+	// and each carries strictly fewer client-supplied fields than the
-	// client-supplied fields than the access log does,
+	// access log does, so none of them can reach a width the access
-	// so none of them can reach a width the access log cannot. That is
+	// log cannot. That is
 	// asserted directly, per line and under both handlers, rather than
 	// left to the reasoning: see logbound_test.go in this package and
 	// in internal/handlers.
@@ -115,16 +115,15 @@ const (
 	// a caller on a parameterised route would supply, which is the
 	// only way those caps can be pinned at all.
 	//
-	// One writer in that set is not a handler's own slog call. The
+	// The GORM adapter in internal/gormlog writes through slog as well.
-	// GORM adapter in internal/gormlog logs the statement with the
+	// It logs each statement with its placeholders rather than the
-	// client-chosen parameter already interpolated into it, which on
+	// values bound to them (see its ParamsFilter), so the key a client
-	// the receiver and login lookups is exactly the value the budgets
+	// sends to the receiver or login lookup does not reach its lines.
-	// above exist for. Its widest line spends two logfield.MaxBytes
+	// Its widest line spends two logfield.MaxBytes budgets — the
-	// budgets — the statement and the driver error — against a fixed
+	// statement and the driver error — against a fixed portion smaller
-	// portion smaller than this one's, and
+	// than this one's, and internal/gormlog/gormlog_test.go asserts
-	// internal/gormlog/gormlog_test.go asserts every line it emits
+	// every line it emits against this constant directly rather than
-	// against this constant directly rather than leaving it as
+	// leaving it as arithmetic.
-	// arithmetic.
 	//
 	// What it does NOT cover, so that the figure above is not read as
 	// more than it is:
@@ -151,6 +150,12 @@ const (
 	MaxAccessLogLineBytes = 2560
 )
 
+// ReceiverRoute is the route pattern the webhook receiver is served
+// at. Its path carries the entrypoint UUID, which is the receiver's
+// only credential, so the log lines this package writes name a
+// request on this route by the pattern, never by its path.
+const ReceiverRoute = "/h/{uuid}"
+
 //nolint:revive // MiddlewareParams is a standard fx naming convention.
 type MiddlewareParams struct {
 	fx.In
@@ -268,14 +273,14 @@ func (lrw *loggingResponseWriter) Unwrap() http.ResponseWriter {
 // marker.
 //
 // The path on those branches is bounded by the service's routes or by
-// the operator's data — a 2xx on the receiver means the UUID named a
+// the operator's data — a 2xx under /s means the file is in the
-// stored entrypoint, a 2xx under /s means the file is in the embedded
+// embedded tree. The query is not bounded by anything:
-// tree. The query is not bounded by anything: /.well-known/healthcheck
+// /.well-known/healthcheck and /s/* take no authentication and sit
-// and /s/* take no authentication and sit behind no rate limiter, and
+// behind no rate limiter, and /pages/login behind only the login
-// /pages/login behind only the login limiter, so any of them will
+// limiter, so any of them will answer 200 to a URL carrying an
-// answer 200 to a URL carrying an arbitrary number of arbitrary bytes
+// arbitrary number of arbitrary bytes after the '?'. Keeping the path
-// after the '?'. Keeping the path and dropping the query is what makes
+// and dropping the query is what makes this branch as bounded as the
-// this branch as bounded as the pattern branches below.
+// pattern branches below.
 //
 // Nothing debuggable is lost. The only query parameters the service
 // reads are the login page's `next`, the page to return to,
@@ -297,36 +302,40 @@ func concreteLogURL(r *http.Request) string {
 
 // accessLogURL returns the value for the access log's url field.
 //
-// 2xx and 5xx responses get the concrete path (see concreteLogURL). A
+// On ReceiverRoute it is the route pattern whatever the status, so
-// success resolved against a static route or against the operator's
+// the entrypoint UUID in the path is never logged. A request chi never
-// own data — on the receiver, a 2xx means the UUID named a stored
+// routed gets unmatchedRoute whatever the status, for the same reason:
-// entrypoint — and a server error is our own bug, where the exact URL
+// in dev, CORS answers a preflight to the receiver before routing.
-// is the primary evidence and which no client can provoke at will.
+//
+// On every other route, 2xx and 5xx responses get the concrete path
+// (see concreteLogURL). A success resolved against a static route or
+// against the operator's own data, and a server error is our own bug,
+// where the exact URL is the primary evidence and which no client can
+// provoke at will.
 //
 // 3xx and 4xx responses get the chi route pattern instead. Those are
-// the outcomes an unauthenticated client drives for free: 404 or 429
+// the outcomes an unauthenticated client drives for free, such as a
-// on any invented /h/ path, 303 to the login page on any
+// 303 to the login page on any invented /user/ path. Logging the
-// invented /user/ path. Logging the concrete URL there lets a flood
+// concrete URL there lets a flood write attacker-chosen text, of
-// write attacker-chosen text, of attacker-chosen length, into the
+// attacker-chosen length, into the operator's log at one line per
-// operator's log at one line per request. The pattern comes from the
+// request. The pattern comes from the router's own table, so it is
-// router's own table, so it is bounded by the service's routes while
+// bounded by the service's routes while still naming which class of
-// still naming which class of request was rejected.
+// request was rejected.
 //
 // The pattern is only populated once routing has run, so this must be
 // called after the handler returns, not before.
 func accessLogURL(r *http.Request, status int) string {
+	pattern := routePatternID(r.Context())
+	if pattern == ReceiverRoute || pattern == unmatchedRoute {
+		return pattern
+	}
+
 	if status < http.StatusMultipleChoices ||
 		status >= http.StatusInternalServerError {
 		return concreteLogURL(r)
 	}
 
-	if rc := chi.RouteContext(r.Context()); rc != nil {
+	return pattern
-		if pattern := rc.RoutePattern(); pattern != "" {
-			return pattern
-		}
-	}
-
-	return unmatchedRoute
 }
 
 // Logging returns middleware that logs each HTTP request with
@@ -379,7 +388,8 @@ func (s *Middleware) Logging() func(http.Handler) http.Handler {
 						requestID, maxLogRequestIDBytes,
 					),
 					"referer", logfield.Truncate(
-						r.Referer(), logfield.MaxBytes,
+						referer.SchemeAndHost(r.Referer()),
+						logfield.MaxBytes,
 					),
 					"proto", r.Proto,
 					"remoteIP", RemoteIP(r),
@@ -538,7 +548,9 @@ func (s *Middleware) MetricsAuth() func(http.Handler) http.Handler {
 // SecurityHeaders returns middleware that sets production security
 // headers on every response: HSTS (unless HSTS_MAX_AGE is zero),
 // X-Content-Type-Options, X-Frame-Options, CSP, Referrer-Policy, and
-// Permissions-Policy.
+// Permissions-Policy. The CSP takes scripts and styles only from
+// files on this origin, so a template may hold no inline script,
+// event handler or style attribute.
 func (s *Middleware) SecurityHeaders() func(http.Handler) http.Handler {
 	maxAge := s.params.Config.HSTSMaxAge
 	hsts := "max-age=" + strconv.FormatInt(int64(maxAge/time.Second), 10) +
@@ -560,8 +572,8 @@ func (s *Middleware) SecurityHeaders() func(http.Handler) http.Handler {
 			w.Header().Set(
 				"Content-Security-Policy",
 				"default-src 'self'; "+
-					"script-src 'self' 'unsafe-inline'; "+
+					"script-src 'self'; "+
-					"style-src 'self' 'unsafe-inline'",
+					"style-src 'self'",
 			)
 			w.Header().Set(
 				"Referrer-Policy",

internal/middleware/middleware_test.go

@@ -747,10 +747,10 @@ func TestNoCache_SetsHeaders(t *testing.T) {
 
 // --- SecurityHeaders Middleware Tests ---
 
-// hstsHeaders serves one request through SecurityHeaders built over
+// securityHeaders serves one request through SecurityHeaders built
-// a Config with the given HSTSMaxAge, and returns every
+// over a Config with the given HSTSMaxAge, and returns the response's
-// Strict-Transport-Security value on the response.
+// headers.
-func hstsHeaders(t *testing.T, maxAge time.Duration) []string {
+func securityHeaders(t *testing.T, maxAge time.Duration) http.Header {
 	t.Helper()
 
 	cfg := &config.Config{HSTSMaxAge: maxAge}
@@ -772,7 +772,7 @@ func hstsHeaders(t *testing.T, maxAge time.Duration) []string {
 
 	handler.ServeHTTP(w, req)
 
-	return w.Header().Values("Strict-Transport-Security")
+	return w.Header()
 }
 
 func TestSecurityHeaders_HSTS(t *testing.T) {
@@ -804,11 +804,28 @@ func TestSecurityHeaders_HSTS(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 
-			assert.Equal(t, tt.expected, hstsHeaders(t, tt.maxAge))
+			assert.Equal(
+				t, tt.expected,
+				securityHeaders(t, tt.maxAge).Values(
+					"Strict-Transport-Security",
+				),
+			)
 		})
 	}
 }
 
+// TestSecurityHeaders_CSP pins the Content-Security-Policy: a page
+// takes its scripts and styles only from files on its own origin,
+// never from an inline script, event handler or style.
+func TestSecurityHeaders_CSP(t *testing.T) {
+	t.Parallel()
+
+	assert.Equal(
+		t, "default-src 'self'; script-src 'self'; style-src 'self'",
+		securityHeaders(t, 0).Get("Content-Security-Policy"),
+	)
+}
+
 // --- MaxBodySize Middleware Tests ---
 
 const testBodyLimit int64 = 64

internal/middleware/ratelimit.go

@@ -259,26 +259,28 @@ func (m *Middleware) clientAddr(r *http.Request) (netip.Addr, bool) {
 	return peer, true
 }
 
-// tooManyRequests returns the 429 handler used by the
+// tooManyRequests returns the 429 handler used by the postRateLimit
-// password-change and per-entrypoint receiver limiters: it logs the
+// limiters and the per-entrypoint receiver limiter: it logs the
 // rejection with logMessage and answers with responseMessage.
 // httprate adds the Retry-After header (RFC 6585). The aggregate
 // receiver limiter uses floodTooManyRequests instead.
 //
-// The path is capped against the same budget as the access log's url
+// On ReceiverRoute the line names the route pattern, so the
-// field. The per-entrypoint receiver limiter is unauthenticated and
+// entrypoint UUID in the path is never logged. Elsewhere it names the
-// its path is a client-chosen segment of client-chosen length, so at
+// path, capped against the same budget as the access log's url field;
-// WARN an uncapped path would let a sender pick the size of the line
+// the limiters there sit behind RequireAuth, so the cap is defensive.
-// it writes — the same defect the access log capping closed.
 func (m *Middleware) tooManyRequests(
 	logMessage, responseMessage string,
 ) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
+		path := r.URL.Path
+		if routePatternID(r.Context()) == ReceiverRoute {
+			path = ReceiverRoute
+		}
+
 		m.log.Warn(
 			logMessage,
-			"path", logfield.Truncate(
+			"path", logfield.Truncate(path, logfield.MaxBytes),
-				r.URL.Path, logfield.MaxBytes,
-			),
 			"remoteIP", RemoteIP(r),
 			"clientIP", ClientIP(r),
 		)